@lvce-editor/static-server 0.56.6 → 0.56.7

package/static/345e16e/packages/settings-view/dist/settingsViewWorkerMain.js

@@ -0,0 +1,3478 @@
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine$2 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const NewLine$1 = '\n';
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
+};
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$1(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
+};
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
+};
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$1(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$1(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    message,
+    code: ERR_MODULE_NOT_FOUND
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
+};
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$1(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    message: actualMessage,
+    code: '',
+    stack: rest
+  };
+};
+class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        message,
+        code,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
+}
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$8 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$f = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
+};
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$8(parentIpcRaw);
+  const parentIpc = wrap$f(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    parentIpc.send({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null
+    });
+    parentIpc.dispose();
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
+    }
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$e = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
+};
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$6,
+  wrap: wrap$e
+};
+
+const Two = '2.0';
+const create$4 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const callbacks = Object.create(null);
+const set$2 = (id, fn) => {
+  callbacks[id] = fn;
+};
+const get$2 = id => {
+  return callbacks[id];
+};
+const remove = id => {
+  delete callbacks[id];
+};
+let id = 0;
+const create$3$1 = () => {
+  return ++id;
+};
+const registerPromise = () => {
+  const id = create$3$1();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set$2(id, resolve);
+  return {
+    id,
+    promise
+  };
+};
+const create$2$1 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+const NewLine = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  return currentStack;
+};
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
+  }
+  return parentStack;
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
+    return error;
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine + 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;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$2(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove(id);
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      message: error.message,
+      data: error.stack
+    };
+  }
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: getStack(prettyError),
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1$1 = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error
+  };
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(id, errorProperty);
+};
+const create$5 = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$5(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
+  }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const send = (transport, method, ...params) => {
+  const message = create$4(method, params);
+  transport.send(message);
+};
+const invoke = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
+};
+
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
+  }
+  return fn(...args);
+};
+
+const createRpc = ipc => {
+  const rpc = {
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      send(ipc, method, ...params);
+    },
+    invoke(method, ...params) {
+      return invoke(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer(ipc, method, ...params);
+    },
+    async dispose() {
+      await ipc?.dispose();
+    }
+  };
+  return rpc;
+};
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$3 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebWorkerRpcClient = {
+  __proto__: null,
+  create: create$3
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$2 = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    get(uid) {
+      return states[uid];
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        oldState,
+        newState
+      };
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseInt(key);
+      });
+    },
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (newState === newerState) {
+          return;
+        }
+        const latest = states[uid];
+        states[uid] = {
+          oldState: latest.oldState,
+          newState: newerState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        newState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
+};
+
+const clear$1 = state => {
+  return {
+    ...state,
+    searchValue: ''
+  };
+};
+
+const {
+  get: get$1,
+  set: set$1,
+  wrapCommand,
+  getCommandIds,
+  registerCommands,
+  wrapGetter
+} = create$2();
+
+const create$1 = (id, uri, x, y, width, height) => {
+  const state = {
+    breakPointsExpanded: false,
+    breakPointsVisible: false,
+    focus: 0,
+    id,
+    uri,
+    x,
+    y,
+    width,
+    height,
+    tabs: [],
+    items: [],
+    searchValue: '',
+    filteredItems: [],
+    preferences: {}
+  };
+  set$1(id, state, state);
+};
+
+const isEqual$1 = (oldState, newState) => {
+  return oldState.focus === newState.focus;
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState === newState;
+};
+
+const RenderItems = 1;
+const RenderFocus = 2;
+
+const modules = [isEqual$1, isEqual];
+const numbers = [RenderFocus, RenderItems];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const diff2 = uid => {
+  const {
+    oldState,
+    newState
+  } = get$1(uid);
+  const diffResult = diff(oldState, newState);
+  return diffResult;
+};
+
+const getFilteredItems = (items, tabs, searchValue = '') => {
+  const selectedTab = tabs.find(tab => tab.selected);
+  if (!selectedTab) {
+    return items;
+  }
+  const tabFilteredItems = items.filter(item => item.category === selectedTab.id);
+  if (!searchValue.trim()) {
+    return tabFilteredItems;
+  }
+  const normalizedSearchValue = searchValue.toLowerCase().trim();
+  return tabFilteredItems.filter(item => item.heading.toLowerCase().includes(normalizedSearchValue));
+};
+
+const getSelectedTabId = tabs => {
+  for (const tab of tabs) {
+    if (tab.selected) {
+      return tab.id;
+    }
+  }
+  return '';
+};
+
+const getUpdatedTabs = (tabs, selectedTabId) => {
+  // Check if the clicked tab is already selected
+  const clickedTabId = getSelectedTabId(tabs);
+  if (clickedTabId === selectedTabId) {
+    return tabs;
+  }
+  return tabs.map(tab => ({
+    ...tab,
+    selected: tab.id === selectedTabId
+  }));
+};
+
+const handleClickTab = (state, name) => {
+  if (!name) {
+    return state;
+  }
+  const {
+    items,
+    tabs,
+    searchValue
+  } = state;
+  const updatedTabs = getUpdatedTabs(tabs, name);
+  const filteredItems = getFilteredItems(items, updatedTabs, searchValue);
+  return {
+    ...state,
+    tabs: updatedTabs,
+    filteredItems
+  };
+};
+
+const handleInput = (state, value) => {
+  const {
+    items,
+    tabs
+  } = state;
+  const filteredItems = getFilteredItems(items, tabs, value);
+  return {
+    ...state,
+    searchValue: value,
+    filteredItems
+  };
+};
+
+const initialize = async () => {
+  // TODO
+};
+
+const getPreferences = async () => {
+  return {};
+};
+
+const ApplicationsTab = 'applications';
+const Clear$1 = 'Clear';
+const ExtensionsTab = 'extensions';
+const FeaturesTab = 'features';
+const SecurityTab = 'security';
+const SettingsSearch = 'SettingsSearch';
+const TextEditorTab = 'text-editor';
+const WindowTab = 'window';
+const WorkbenchTab = 'workbench';
+
+const String = 2;
+const Boolean$1 = 3;
+const Number$1 = 5;
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+const AutoSave = 'Auto Save';
+const AutoSaveDescription = 'Automatically save files';
+const AutoUpdateExtensions = 'Auto Update Extensions';
+const AutoUpdateExtensionsDescription = 'Automatically update extensions';
+const AutoUpdates = 'Auto Updates';
+const AutoUpdatesDescription = 'Automatically check for updates';
+const Clear = 'Clear';
+const ExtensionRecommendations = 'Extension Recommendations';
+const ExtensionRecommendationsDescription = 'Show extension recommendations';
+const FileEncryption = 'File Encryption';
+const FileEncryptionDescription = 'Encrypt sensitive files';
+const FontFamily = 'Font Family';
+const FontFamilyDescription = 'The font family of the editor';
+const FontSize = 'Font Size';
+const FontSizeDescription = 'The font size of the editor';
+const FormatOnSave = 'Format on Save';
+const FormatOnSaveDescription = 'Format code when saving';
+const NumberValue = 'number value';
+const SearchSettings = 'Search Settings';
+const SettingsContent = 'Settings Content';
+const SettingsSideBar = 'Settings SideBar';
+const SidebarPosition = 'Sidebar Position';
+const SidebarPositionDescription = 'The position of the sidebar';
+const Telemetry = 'Telemetry';
+const TelemetryDescription = 'Enable telemetry collection';
+const Theme = 'Theme';
+const ThemeDescription = 'The color theme of the workbench';
+const TwoFactorAuth = 'Two Factor Auth';
+const TwoFactorAuthDescription = 'Enable two factor authentication';
+const WindowSize = 'Window Size';
+const WindowSizeDescription = 'The default window size';
+const WindowTitle = 'Window Title';
+const WindowTitleDescription = 'The title shown in the window';
+const NoSettingsMatching = 'No settings matching "{PH1}" found';
+
+// Text Editor Settings
+const WordWrap = 'Word Wrap';
+const WordWrapDescription = 'Controls how lines should wrap';
+const LineNumbers = 'Line Numbers';
+const LineNumbersDescription = 'Controls the display of line numbers';
+const Minimap = 'Minimap';
+const MinimapDescription = 'Controls whether the minimap is shown';
+const ScrollBeyondLastLine = 'Scroll Beyond Last Line';
+const ScrollBeyondLastLineDescription = 'Controls whether the editor will scroll beyond the last line';
+const SmoothScrolling = 'Smooth Scrolling';
+const SmoothScrollingDescription = 'Controls whether the editor will scroll smoothly';
+const CursorBlinking = 'Cursor Blinking';
+const CursorBlinkingDescription = 'Controls how the cursor should blink';
+const CursorStyle = 'Cursor Style';
+const CursorStyleDescription = 'Controls the cursor style';
+const CursorWidth = 'Cursor Width';
+const CursorWidthDescription = 'Controls the width of the cursor';
+const TabSize = 'Tab Size';
+const TabSizeDescription = 'The number of spaces a tab is equal to';
+const InsertSpaces = 'Insert Spaces';
+const InsertSpacesDescription = 'Insert spaces when pressing Tab';
+const DetectIndentation = 'Detect Indentation';
+const DetectIndentationDescription = 'Controls whether the editor will automatically adjust the indentation';
+const TrimAutoWhitespace = 'Trim Auto Whitespace';
+const TrimAutoWhitespaceDescription = 'Remove trailing auto inserted whitespace';
+const LargeFileOptimizations = 'Large File Optimizations';
+const LargeFileOptimizationsDescription = 'Special handling for large files to disable certain features';
+const RenderWhitespace = 'Render Whitespace';
+const RenderWhitespaceDescription = 'Controls how the editor should render whitespace characters';
+const RenderControlCharacters = 'Render Control Characters';
+const RenderControlCharactersDescription = 'Controls whether the editor should render control characters';
+const RenderLineHighlight = 'Render Line Highlight';
+const RenderLineHighlightDescription = 'Controls how the editor should render the current line highlight';
+const CodeLens = 'Code Lens';
+const CodeLensDescription = 'Controls whether the editor shows CodeLens';
+const Folding = 'Folding';
+const FoldingDescription = 'Controls whether the editor has code folding enabled';
+const ShowFoldingControls = 'Show Folding Controls';
+const ShowFoldingControlsDescription = 'Controls when the folding controls on the gutter are automatically hidden';
+const UnfoldOnClickAfterEnd = 'Unfold On Click After End';
+const UnfoldOnClickAfterEndDescription = 'Controls whether clicking on the empty content after a folded line will unfold the line';
+const Links = 'Links';
+const LinksDescription = 'Controls whether the editor should detect links and make them clickable';
+const ColorDecorators = 'Color Decorators';
+const ColorDecoratorsDescription = 'Controls whether the editor should render the inline color decorators and color picker';
+const Lightbulb = 'Lightbulb';
+const LightbulbDescription = 'Controls whether the editor should show the lightbulb code action';
+const CodeActionsOnSave = 'Code Actions On Save';
+const CodeActionsOnSaveDescription = 'Code actions to be run on save';
+const FormatOnPaste = 'Format On Paste';
+const FormatOnPasteDescription = 'Format a file on paste';
+const FormatOnType = 'Format On Type';
+const FormatOnTypeDescription = 'Format a file on type';
+const AcceptSuggestionOnCommitCharacter = 'Accept Suggestion On Commit Character';
+const AcceptSuggestionOnCommitCharacterDescription = 'Controls if suggestions should be accepted on commit characters';
+const AcceptSuggestionOnEnter = 'Accept Suggestion On Enter';
+const AcceptSuggestionOnEnterDescription = 'Controls if suggestions should be accepted on Enter';
+const TabCompletion = 'Tab Completion';
+const TabCompletionDescription = 'Enables tab completions';
+const WordBasedSuggestions = 'Word Based Suggestions';
+const WordBasedSuggestionsDescription = 'Controls whether completions should be computed based on words in the document';
+const SuggestOnTriggerCharacters = 'Suggest On Trigger Characters';
+const SuggestOnTriggerCharactersDescription = 'Controls whether suggestions should automatically show up when typing trigger characters';
+const QuickSuggestions = 'Quick Suggestions';
+const QuickSuggestionsDescription = 'Controls whether suggestions should automatically show up while typing';
+const ParameterHints = 'Parameter Hints';
+const ParameterHintsDescription = 'Controls whether the editor should show parameter hints';
+const AutoClosingBrackets = 'Auto Closing Brackets';
+const AutoClosingBracketsDescription = 'Controls whether the editor should automatically close brackets after opening them';
+const AutoClosingQuotes = 'Auto Closing Quotes';
+const AutoClosingQuotesDescription = 'Controls whether the editor should automatically close quotes after opening them';
+const AutoClosingOvertype = 'Auto Closing Overtype';
+const AutoClosingOvertypeDescription = 'Controls whether the editor should type over closing quotes or brackets';
+const AutoClosingDelete = 'Auto Closing Delete';
+const AutoClosingDeleteDescription = 'Controls whether the editor should remove adjacent closing quotes or brackets when deleting';
+const AutoSurround = 'Auto Surround';
+const AutoSurroundDescription = 'Controls whether the editor should automatically surround selections';
+const BracketPairColorization = 'Bracket Pair Colorization';
+const BracketPairColorizationDescription = 'Controls whether the editor should enable bracket pair colorization';
+const Guides = 'Guides';
+const GuidesDescription = 'Controls whether the editor should render bracket pair guides';
+const DragAndDrop = 'Drag And Drop';
+const DragAndDropDescription = 'Controls whether the editor allows moving selections via drag and drop';
+const CopyWithSyntaxHighlighting = 'Copy With Syntax Highlighting';
+const CopyWithSyntaxHighlightingDescription = 'Controls whether syntax highlighting should be copied when copying text';
+const MultiCursorModifier = 'Multi Cursor Modifier';
+const MultiCursorModifierDescription = 'The modifier to be used to add multiple cursors with the mouse';
+const MultiCursorPaste = 'Multi Cursor Paste';
+const MultiCursorPasteDescription = 'Controls how the editor should handle multiple cursors when pasting';
+const OccurrencesHighlight = 'Occurrences Highlight';
+const OccurrencesHighlightDescription = 'Controls whether the editor should highlight similar matches to the selection';
+const SelectionHighlight = 'Selection Highlight';
+const SelectionHighlightDescription = 'Controls whether the editor should highlight similar matches to the selection';
+const SemanticHighlighting = 'Semantic Highlighting';
+const SemanticHighlightingDescription = 'Controls whether the editor should enable semantic highlighting';
+const TokenColorCustomizations = 'Token Color Customizations';
+const TokenColorCustomizationsDescription = 'Overrides editor syntax highlighting colors';
+const WorkbenchColorCustomizations = 'Workbench Color Customizations';
+const WorkbenchColorCustomizationsDescription = 'Overrides workbench colors';
+const EditorColorCustomizations = 'Editor Color Customizations';
+const EditorColorCustomizationsDescription = 'Overrides editor colors';
+const DiffEditor = 'Diff Editor';
+const DiffEditorDescription = 'Controls whether the diff editor shows the diff side by side or inline';
+const DiffWordWrap = 'Diff Word Wrap';
+const DiffWordWrapDescription = 'Controls whether the diff editor shows the diff side by side or inline';
+const DiffCodeLens = 'Diff Code Lens';
+const DiffCodeLensDescription = 'Controls whether the diff editor shows code lens';
+const DiffRenderSideBySide = 'Diff Render Side By Side';
+const DiffRenderSideBySideDescription = 'Controls whether the diff editor shows the diff side by side or inline';
+const DiffIgnoreTrimWhitespace = 'Diff Ignore Trim Whitespace';
+const DiffIgnoreTrimWhitespaceDescription = 'Controls whether the diff editor ignores changes in whitespace';
+const DiffRenderIndicators = 'Diff Render Indicators';
+const DiffRenderIndicatorsDescription = 'Controls whether the diff editor shows indicators';
+const DiffRenderOverviewRuler = 'Diff Render Overview Ruler';
+const DiffRenderOverviewRulerDescription = 'Controls whether the diff editor shows the overview ruler';
+const DiffRenderMarginRevertIcon = 'Diff Render Margin Revert Icon';
+const DiffRenderMarginRevertIconDescription = 'Controls whether the diff editor shows the revert icon in the margin';
+
+// Additional Text Editor Settings
+const InsertMode = 'Insert Mode';
+const InsertModeDescription = 'Controls whether the editor is in insert mode';
+const OverwriteMode = 'Overwrite Mode';
+const OverwriteModeDescription = 'Controls whether the editor is in overwrite mode';
+const ReadOnly = 'Read Only';
+const ReadOnlyDescription = 'Controls whether the editor is read only';
+const AccessibilitySupport = 'Accessibility Support';
+const AccessibilitySupportDescription = 'Controls whether the editor should run in a mode where it is optimized for screen readers';
+const AutoIndent = 'Auto Indent';
+const AutoIndentDescription = 'Controls whether the editor should automatically adjust the indentation';
+const BracketMatching = 'Bracket Matching';
+const BracketMatchingDescription = 'Controls whether the editor should highlight matching brackets';
+const CenteredLayout = 'Centered Layout';
+const CenteredLayoutDescription = 'Controls whether the editor should use centered layout';
+const ColumnSelection = 'Column Selection';
+const ColumnSelectionDescription = 'Controls whether the editor should support column selection';
+const Contextmenu = 'Context Menu';
+const ContextmenuDescription = 'Controls whether the editor should show the context menu';
+const CursorSmoothCaretAnimation = 'Cursor Smooth Caret Animation';
+const CursorSmoothCaretAnimationDescription = 'Controls whether the cursor should be animated';
+const CursorSurroundingLines = 'Cursor Surrounding Lines';
+const CursorSurroundingLinesDescription = 'Controls the number of extra characters beyond which the editor will scroll horizontally';
+const CursorSurroundingLinesStyle = 'Cursor Surrounding Lines Style';
+const CursorSurroundingLinesStyleDescription = 'Controls when the cursor should be hidden';
+const DisableMonospaceOptimizations = 'Disable Monospace Optimizations';
+const DisableMonospaceOptimizationsDescription = 'Controls whether the editor should disable optimizations for monospace fonts';
+const EmptySelectionClipboard = 'Empty Selection Clipboard';
+const EmptySelectionClipboardDescription = 'Controls whether copying without a selection copies the current line';
+const ExtraEditorClassName = 'Extra Editor Class Name';
+const ExtraEditorClassNameDescription = 'An extra class name to add to the editor';
+const FastScrollSensitivity = 'Fast Scroll Sensitivity';
+const FastScrollSensitivityDescription = 'Scrolling speed multiplier when pressing Alt';
+const Find = 'Find';
+const FindDescription = 'Controls whether the editor should add extra space on the bottom';
+const FixedOverflowWidgets = 'Fixed Overflow Widgets';
+const FixedOverflowWidgetsDescription = 'Controls whether the editor should scroll beyond the last line';
+const FoldingStrategy = 'Folding Strategy';
+const FoldingStrategyDescription = 'Controls the folding strategy';
+const FontLigatures = 'Font Ligatures';
+const FontLigaturesDescription = 'Enables/Disables font ligatures';
+const GlyphMargin = 'Glyph Margin';
+const GlyphMarginDescription = 'Controls whether the editor should render the vertical glyph margin';
+const GotoLocation = 'Go To Location';
+const GotoLocationDescription = "Controls the behavior the 'Go to Definition'-mouse gesture";
+const HideCursorInOverviewRuler = 'Hide Cursor In Overview Ruler';
+const HideCursorInOverviewRulerDescription = 'Controls whether the cursor should be hidden in the overview ruler';
+const Hover = 'Hover';
+const HoverDescription = 'Controls whether the editor should show hover';
+const InDiffEditor = 'In Diff Editor';
+const InDiffEditorDescription = 'Controls whether the editor should be in a diff editor';
+const LetterSpacing = 'Letter Spacing';
+const LetterSpacingDescription = 'The letter spacing';
+const LightbulbEnabled = 'Lightbulb Enabled';
+const LightbulbEnabledDescription = 'Controls whether the editor should show the lightbulb code action';
+const LineDecorationsWidth = 'Line Decorations Width';
+const LineDecorationsWidthDescription = 'The width reserved for line decorations (in px)';
+const LineHeight = 'Line Height';
+const LineHeightDescription = 'The line height';
+const MatchBrackets = 'Match Brackets';
+const MatchBracketsDescription = 'Controls whether the editor should highlight matching brackets';
+const MinimapEnabled = 'Minimap Enabled';
+const MinimapEnabledDescription = 'Controls whether the minimap is shown';
+const MouseWheelScrollSensitivity = 'Mouse Wheel Scroll Sensitivity';
+const MouseWheelScrollSensitivityDescription = 'A multiplier to be used on the deltaX and deltaY of mouse wheel scroll events';
+const MouseWheelZoom = 'Mouse Wheel Zoom';
+const MouseWheelZoomDescription = 'Zoom the font of the editor when using mouse wheel and holding Ctrl';
+const MultiCursorMergeOverlapping = 'Multi Cursor Merge Overlapping';
+const MultiCursorMergeOverlappingDescription = 'Merge overlapping selections';
+const OverviewRulerBorder = 'Overview Ruler Border';
+const OverviewRulerBorderDescription = 'Controls whether a border should be drawn around the overview ruler';
+const OverviewRulerLanes = 'Overview Ruler Lanes';
+const OverviewRulerLanesDescription = 'Controls the number of decorations that can show in the overview ruler';
+const PeekWidgetDefaultFocus = 'Peek Widget Default Focus';
+const PeekWidgetDefaultFocusDescription = 'Controls if the peek widget should be focused by default';
+const QuickSuggestionsDelay = 'Quick Suggestions Delay';
+const QuickSuggestionsDelayDescription = 'Controls the delay in milliseconds after which quick suggestions will show up';
+const RenderFinalNewline = 'Render Final Newline';
+const RenderFinalNewlineDescription = 'Controls whether the editor should render the final newline as a space';
+const RenderValidationDecorations = 'Render Validation Decorations';
+const RenderValidationDecorationsDescription = 'Controls whether the editor should render validation decorations';
+const RevealHorizontalRightPadding = 'Reveal Horizontal Right Padding';
+const RevealHorizontalRightPaddingDescription = 'When revealing the cursor, a virtual padding (px) is added to the cursor, turning on a block cursor';
+const RoundedSelection = 'Rounded Selection';
+const RoundedSelectionDescription = 'Controls whether selections should have rounded corners';
+const Rulers = 'Rulers';
+const RulersDescription = 'Render vertical rulers at a certain number of monospace characters';
+const ScrollBeyondLastColumn = 'Scroll Beyond Last Column';
+const ScrollBeyondLastColumnDescription = 'Controls how many characters the editor will scroll horizontally';
+const Scrollbar = 'Scrollbar';
+const ScrollbarDescription = 'Controls the visibility and behavior of the scrollbars';
+const ScrollPredominantAxis = 'Scroll Predominant Axis';
+const ScrollPredominantAxisDescription = 'Scroll only along the predominant axis when scrolling both vertically and horizontally at the same time';
+const SelectionClipboard = 'Selection Clipboard';
+const SelectionClipboardDescription = 'Controls whether the editor should use the CLIPBOARD selection';
+const ShowUnused = 'Show Unused';
+const ShowUnusedDescription = 'Controls fading out of unused code';
+const SnippetSuggestions = 'Snippet Suggestions';
+const SnippetSuggestionsDescription = 'Controls whether snippets are shown with other suggestions and how they are sorted';
+const Suggest = 'Suggest';
+const SuggestDescription = 'Controls whether suggestions should automatically show up while typing';
+const SuggestFontSize = 'Suggest Font Size';
+const SuggestFontSizeDescription = 'Font size for the suggest widget';
+const SuggestLineHeight = 'Suggest Line Height';
+const SuggestLineHeightDescription = 'Line height for the suggest widget';
+const SuggestSelection = 'Suggest Selection';
+const SuggestSelectionDescription = 'Controls how suggestions are selected when showing the suggest widget';
+const UseTabStops = 'Use Tab Stops';
+const UseTabStopsDescription = 'Inserting and deleting whitespace follows tab stops';
+const WordSeparators = 'Word Separators';
+const WordSeparatorsDescription = 'Characters that will be used as word separators when doing word related navigations or operations';
+const WrappingIndent = 'Wrapping Indent';
+const WrappingIndentDescription = 'Controls the indentation of wrapped lines';
+
+const autoSave = () => {
+  return i18nString(AutoSave);
+};
+const autoSaveDescription = () => {
+  return i18nString(AutoSaveDescription);
+};
+const autoUpdateExtensions = () => {
+  return i18nString(AutoUpdateExtensions);
+};
+const autoUpdateExtensionsDescription = () => {
+  return i18nString(AutoUpdateExtensionsDescription);
+};
+const autoUpdates = () => {
+  return i18nString(AutoUpdates);
+};
+const autoUpdatesDescription = () => {
+  return i18nString(AutoUpdatesDescription);
+};
+const clear = () => {
+  return i18nString(Clear);
+};
+const extensionRecommendations = () => {
+  return i18nString(ExtensionRecommendations);
+};
+const extensionRecommendationsDescription = () => {
+  return i18nString(ExtensionRecommendationsDescription);
+};
+const fileEncryption = () => {
+  return i18nString(FileEncryption);
+};
+const fileEncryptionDescription = () => {
+  return i18nString(FileEncryptionDescription);
+};
+const fontFamily = () => {
+  return i18nString(FontFamily);
+};
+const fontFamilyDescription = () => {
+  return i18nString(FontFamilyDescription);
+};
+const fontSize = () => {
+  return i18nString(FontSize);
+};
+const fontSizeDescription = () => {
+  return i18nString(FontSizeDescription);
+};
+const formatOnSave = () => {
+  return i18nString(FormatOnSave);
+};
+const formatOnSaveDescription = () => {
+  return i18nString(FormatOnSaveDescription);
+};
+const numberValue = () => {
+  return i18nString(NumberValue);
+};
+const searchSettings = () => {
+  return i18nString(SearchSettings);
+};
+const settingsContent = () => {
+  return i18nString(SettingsContent);
+};
+const settingsSideBar = () => {
+  return i18nString(SettingsSideBar);
+};
+const sidebarPosition = () => {
+  return i18nString(SidebarPosition);
+};
+const sidebarPositionDescription = () => {
+  return i18nString(SidebarPositionDescription);
+};
+const telemetry = () => {
+  return i18nString(Telemetry);
+};
+const telemetryDescription = () => {
+  return i18nString(TelemetryDescription);
+};
+const theme = () => {
+  return i18nString(Theme);
+};
+const themeDescription = () => {
+  return i18nString(ThemeDescription);
+};
+const twoFactorAuth = () => {
+  return i18nString(TwoFactorAuth);
+};
+const twoFactorAuthDescription = () => {
+  return i18nString(TwoFactorAuthDescription);
+};
+const windowSize = () => {
+  return i18nString(WindowSize);
+};
+const windowSizeDescription = () => {
+  return i18nString(WindowSizeDescription);
+};
+const windowTitle = () => {
+  return i18nString(WindowTitle);
+};
+const windowTitleDescription = () => {
+  return i18nString(WindowTitleDescription);
+};
+const noSettingsMatching = searchTerm => {
+  return i18nString(NoSettingsMatching, {
+    PH1: searchTerm
+  });
+};
+
+// Text Editor Settings
+const wordWrap = () => {
+  return i18nString(WordWrap);
+};
+const wordWrapDescription = () => {
+  return i18nString(WordWrapDescription);
+};
+const lineNumbers = () => {
+  return i18nString(LineNumbers);
+};
+const lineNumbersDescription = () => {
+  return i18nString(LineNumbersDescription);
+};
+const minimap = () => {
+  return i18nString(Minimap);
+};
+const minimapDescription = () => {
+  return i18nString(MinimapDescription);
+};
+const scrollBeyondLastLine = () => {
+  return i18nString(ScrollBeyondLastLine);
+};
+const scrollBeyondLastLineDescription = () => {
+  return i18nString(ScrollBeyondLastLineDescription);
+};
+const smoothScrolling = () => {
+  return i18nString(SmoothScrolling);
+};
+const smoothScrollingDescription = () => {
+  return i18nString(SmoothScrollingDescription);
+};
+const cursorBlinking = () => {
+  return i18nString(CursorBlinking);
+};
+const cursorBlinkingDescription = () => {
+  return i18nString(CursorBlinkingDescription);
+};
+const cursorStyle = () => {
+  return i18nString(CursorStyle);
+};
+const cursorStyleDescription = () => {
+  return i18nString(CursorStyleDescription);
+};
+const cursorWidth = () => {
+  return i18nString(CursorWidth);
+};
+const cursorWidthDescription = () => {
+  return i18nString(CursorWidthDescription);
+};
+const tabSize = () => {
+  return i18nString(TabSize);
+};
+const tabSizeDescription = () => {
+  return i18nString(TabSizeDescription);
+};
+const insertSpaces = () => {
+  return i18nString(InsertSpaces);
+};
+const insertSpacesDescription = () => {
+  return i18nString(InsertSpacesDescription);
+};
+const detectIndentation = () => {
+  return i18nString(DetectIndentation);
+};
+const detectIndentationDescription = () => {
+  return i18nString(DetectIndentationDescription);
+};
+const trimAutoWhitespace = () => {
+  return i18nString(TrimAutoWhitespace);
+};
+const trimAutoWhitespaceDescription = () => {
+  return i18nString(TrimAutoWhitespaceDescription);
+};
+const largeFileOptimizations = () => {
+  return i18nString(LargeFileOptimizations);
+};
+const largeFileOptimizationsDescription = () => {
+  return i18nString(LargeFileOptimizationsDescription);
+};
+const renderWhitespace = () => {
+  return i18nString(RenderWhitespace);
+};
+const renderWhitespaceDescription = () => {
+  return i18nString(RenderWhitespaceDescription);
+};
+const renderControlCharacters = () => {
+  return i18nString(RenderControlCharacters);
+};
+const renderControlCharactersDescription = () => {
+  return i18nString(RenderControlCharactersDescription);
+};
+const renderLineHighlight = () => {
+  return i18nString(RenderLineHighlight);
+};
+const renderLineHighlightDescription = () => {
+  return i18nString(RenderLineHighlightDescription);
+};
+const codeLens = () => {
+  return i18nString(CodeLens);
+};
+const codeLensDescription = () => {
+  return i18nString(CodeLensDescription);
+};
+const folding = () => {
+  return i18nString(Folding);
+};
+const foldingDescription = () => {
+  return i18nString(FoldingDescription);
+};
+const showFoldingControls = () => {
+  return i18nString(ShowFoldingControls);
+};
+const showFoldingControlsDescription = () => {
+  return i18nString(ShowFoldingControlsDescription);
+};
+const unfoldOnClickAfterEnd = () => {
+  return i18nString(UnfoldOnClickAfterEnd);
+};
+const unfoldOnClickAfterEndDescription = () => {
+  return i18nString(UnfoldOnClickAfterEndDescription);
+};
+const links = () => {
+  return i18nString(Links);
+};
+const linksDescription = () => {
+  return i18nString(LinksDescription);
+};
+const colorDecorators = () => {
+  return i18nString(ColorDecorators);
+};
+const colorDecoratorsDescription = () => {
+  return i18nString(ColorDecoratorsDescription);
+};
+const lightbulb = () => {
+  return i18nString(Lightbulb);
+};
+const lightbulbDescription = () => {
+  return i18nString(LightbulbDescription);
+};
+const codeActionsOnSave = () => {
+  return i18nString(CodeActionsOnSave);
+};
+const codeActionsOnSaveDescription = () => {
+  return i18nString(CodeActionsOnSaveDescription);
+};
+const formatOnPaste = () => {
+  return i18nString(FormatOnPaste);
+};
+const formatOnPasteDescription = () => {
+  return i18nString(FormatOnPasteDescription);
+};
+const formatOnType = () => {
+  return i18nString(FormatOnType);
+};
+const formatOnTypeDescription = () => {
+  return i18nString(FormatOnTypeDescription);
+};
+const acceptSuggestionOnCommitCharacter = () => {
+  return i18nString(AcceptSuggestionOnCommitCharacter);
+};
+const acceptSuggestionOnCommitCharacterDescription = () => {
+  return i18nString(AcceptSuggestionOnCommitCharacterDescription);
+};
+const acceptSuggestionOnEnter = () => {
+  return i18nString(AcceptSuggestionOnEnter);
+};
+const acceptSuggestionOnEnterDescription = () => {
+  return i18nString(AcceptSuggestionOnEnterDescription);
+};
+const tabCompletion = () => {
+  return i18nString(TabCompletion);
+};
+const tabCompletionDescription = () => {
+  return i18nString(TabCompletionDescription);
+};
+const wordBasedSuggestions = () => {
+  return i18nString(WordBasedSuggestions);
+};
+const wordBasedSuggestionsDescription = () => {
+  return i18nString(WordBasedSuggestionsDescription);
+};
+const suggestOnTriggerCharacters = () => {
+  return i18nString(SuggestOnTriggerCharacters);
+};
+const suggestOnTriggerCharactersDescription = () => {
+  return i18nString(SuggestOnTriggerCharactersDescription);
+};
+const quickSuggestions = () => {
+  return i18nString(QuickSuggestions);
+};
+const quickSuggestionsDescription = () => {
+  return i18nString(QuickSuggestionsDescription);
+};
+const parameterHints = () => {
+  return i18nString(ParameterHints);
+};
+const parameterHintsDescription = () => {
+  return i18nString(ParameterHintsDescription);
+};
+const autoClosingBrackets = () => {
+  return i18nString(AutoClosingBrackets);
+};
+const autoClosingBracketsDescription = () => {
+  return i18nString(AutoClosingBracketsDescription);
+};
+const autoClosingQuotes = () => {
+  return i18nString(AutoClosingQuotes);
+};
+const autoClosingQuotesDescription = () => {
+  return i18nString(AutoClosingQuotesDescription);
+};
+const autoClosingOvertype = () => {
+  return i18nString(AutoClosingOvertype);
+};
+const autoClosingOvertypeDescription = () => {
+  return i18nString(AutoClosingOvertypeDescription);
+};
+const autoClosingDelete = () => {
+  return i18nString(AutoClosingDelete);
+};
+const autoClosingDeleteDescription = () => {
+  return i18nString(AutoClosingDeleteDescription);
+};
+const autoSurround = () => {
+  return i18nString(AutoSurround);
+};
+const autoSurroundDescription = () => {
+  return i18nString(AutoSurroundDescription);
+};
+const bracketPairColorization = () => {
+  return i18nString(BracketPairColorization);
+};
+const bracketPairColorizationDescription = () => {
+  return i18nString(BracketPairColorizationDescription);
+};
+const guides = () => {
+  return i18nString(Guides);
+};
+const guidesDescription = () => {
+  return i18nString(GuidesDescription);
+};
+const dragAndDrop = () => {
+  return i18nString(DragAndDrop);
+};
+const dragAndDropDescription = () => {
+  return i18nString(DragAndDropDescription);
+};
+const copyWithSyntaxHighlighting = () => {
+  return i18nString(CopyWithSyntaxHighlighting);
+};
+const copyWithSyntaxHighlightingDescription = () => {
+  return i18nString(CopyWithSyntaxHighlightingDescription);
+};
+const multiCursorModifier = () => {
+  return i18nString(MultiCursorModifier);
+};
+const multiCursorModifierDescription = () => {
+  return i18nString(MultiCursorModifierDescription);
+};
+const multiCursorPaste = () => {
+  return i18nString(MultiCursorPaste);
+};
+const multiCursorPasteDescription = () => {
+  return i18nString(MultiCursorPasteDescription);
+};
+const occurrencesHighlight = () => {
+  return i18nString(OccurrencesHighlight);
+};
+const occurrencesHighlightDescription = () => {
+  return i18nString(OccurrencesHighlightDescription);
+};
+const selectionHighlight = () => {
+  return i18nString(SelectionHighlight);
+};
+const selectionHighlightDescription = () => {
+  return i18nString(SelectionHighlightDescription);
+};
+const semanticHighlighting = () => {
+  return i18nString(SemanticHighlighting);
+};
+const semanticHighlightingDescription = () => {
+  return i18nString(SemanticHighlightingDescription);
+};
+const tokenColorCustomizations = () => {
+  return i18nString(TokenColorCustomizations);
+};
+const tokenColorCustomizationsDescription = () => {
+  return i18nString(TokenColorCustomizationsDescription);
+};
+const workbenchColorCustomizations = () => {
+  return i18nString(WorkbenchColorCustomizations);
+};
+const workbenchColorCustomizationsDescription = () => {
+  return i18nString(WorkbenchColorCustomizationsDescription);
+};
+const editorColorCustomizations = () => {
+  return i18nString(EditorColorCustomizations);
+};
+const editorColorCustomizationsDescription = () => {
+  return i18nString(EditorColorCustomizationsDescription);
+};
+const diffEditor = () => {
+  return i18nString(DiffEditor);
+};
+const diffEditorDescription = () => {
+  return i18nString(DiffEditorDescription);
+};
+const diffWordWrap = () => {
+  return i18nString(DiffWordWrap);
+};
+const diffWordWrapDescription = () => {
+  return i18nString(DiffWordWrapDescription);
+};
+const diffCodeLens = () => {
+  return i18nString(DiffCodeLens);
+};
+const diffCodeLensDescription = () => {
+  return i18nString(DiffCodeLensDescription);
+};
+const diffRenderSideBySide = () => {
+  return i18nString(DiffRenderSideBySide);
+};
+const diffRenderSideBySideDescription = () => {
+  return i18nString(DiffRenderSideBySideDescription);
+};
+const diffIgnoreTrimWhitespace = () => {
+  return i18nString(DiffIgnoreTrimWhitespace);
+};
+const diffIgnoreTrimWhitespaceDescription = () => {
+  return i18nString(DiffIgnoreTrimWhitespaceDescription);
+};
+const diffRenderIndicators = () => {
+  return i18nString(DiffRenderIndicators);
+};
+const diffRenderIndicatorsDescription = () => {
+  return i18nString(DiffRenderIndicatorsDescription);
+};
+const diffRenderOverviewRuler = () => {
+  return i18nString(DiffRenderOverviewRuler);
+};
+const diffRenderOverviewRulerDescription = () => {
+  return i18nString(DiffRenderOverviewRulerDescription);
+};
+const diffRenderMarginRevertIcon = () => {
+  return i18nString(DiffRenderMarginRevertIcon);
+};
+const diffRenderMarginRevertIconDescription = () => {
+  return i18nString(DiffRenderMarginRevertIconDescription);
+};
+
+// Additional Text Editor Settings
+const insertMode = () => {
+  return i18nString(InsertMode);
+};
+const insertModeDescription = () => {
+  return i18nString(InsertModeDescription);
+};
+const overwriteMode = () => {
+  return i18nString(OverwriteMode);
+};
+const overwriteModeDescription = () => {
+  return i18nString(OverwriteModeDescription);
+};
+const readOnly = () => {
+  return i18nString(ReadOnly);
+};
+const readOnlyDescription = () => {
+  return i18nString(ReadOnlyDescription);
+};
+const accessibilitySupport = () => {
+  return i18nString(AccessibilitySupport);
+};
+const accessibilitySupportDescription = () => {
+  return i18nString(AccessibilitySupportDescription);
+};
+const autoIndent = () => {
+  return i18nString(AutoIndent);
+};
+const autoIndentDescription = () => {
+  return i18nString(AutoIndentDescription);
+};
+const bracketMatching = () => {
+  return i18nString(BracketMatching);
+};
+const bracketMatchingDescription = () => {
+  return i18nString(BracketMatchingDescription);
+};
+const centeredLayout = () => {
+  return i18nString(CenteredLayout);
+};
+const centeredLayoutDescription = () => {
+  return i18nString(CenteredLayoutDescription);
+};
+const columnSelection = () => {
+  return i18nString(ColumnSelection);
+};
+const columnSelectionDescription = () => {
+  return i18nString(ColumnSelectionDescription);
+};
+const contextmenu = () => {
+  return i18nString(Contextmenu);
+};
+const contextmenuDescription = () => {
+  return i18nString(ContextmenuDescription);
+};
+const cursorSmoothCaretAnimation = () => {
+  return i18nString(CursorSmoothCaretAnimation);
+};
+const cursorSmoothCaretAnimationDescription = () => {
+  return i18nString(CursorSmoothCaretAnimationDescription);
+};
+const cursorSurroundingLines = () => {
+  return i18nString(CursorSurroundingLines);
+};
+const cursorSurroundingLinesDescription = () => {
+  return i18nString(CursorSurroundingLinesDescription);
+};
+const cursorSurroundingLinesStyle = () => {
+  return i18nString(CursorSurroundingLinesStyle);
+};
+const cursorSurroundingLinesStyleDescription = () => {
+  return i18nString(CursorSurroundingLinesStyleDescription);
+};
+const disableMonospaceOptimizations = () => {
+  return i18nString(DisableMonospaceOptimizations);
+};
+const disableMonospaceOptimizationsDescription = () => {
+  return i18nString(DisableMonospaceOptimizationsDescription);
+};
+const emptySelectionClipboard = () => {
+  return i18nString(EmptySelectionClipboard);
+};
+const emptySelectionClipboardDescription = () => {
+  return i18nString(EmptySelectionClipboardDescription);
+};
+const extraEditorClassName = () => {
+  return i18nString(ExtraEditorClassName);
+};
+const extraEditorClassNameDescription = () => {
+  return i18nString(ExtraEditorClassNameDescription);
+};
+const fastScrollSensitivity = () => {
+  return i18nString(FastScrollSensitivity);
+};
+const fastScrollSensitivityDescription = () => {
+  return i18nString(FastScrollSensitivityDescription);
+};
+const find = () => {
+  return i18nString(Find);
+};
+const findDescription = () => {
+  return i18nString(FindDescription);
+};
+const fixedOverflowWidgets = () => {
+  return i18nString(FixedOverflowWidgets);
+};
+const fixedOverflowWidgetsDescription = () => {
+  return i18nString(FixedOverflowWidgetsDescription);
+};
+const foldingStrategy = () => {
+  return i18nString(FoldingStrategy);
+};
+const foldingStrategyDescription = () => {
+  return i18nString(FoldingStrategyDescription);
+};
+const fontLigatures = () => {
+  return i18nString(FontLigatures);
+};
+const fontLigaturesDescription = () => {
+  return i18nString(FontLigaturesDescription);
+};
+const glyphMargin = () => {
+  return i18nString(GlyphMargin);
+};
+const glyphMarginDescription = () => {
+  return i18nString(GlyphMarginDescription);
+};
+const gotoLocation = () => {
+  return i18nString(GotoLocation);
+};
+const gotoLocationDescription = () => {
+  return i18nString(GotoLocationDescription);
+};
+const hideCursorInOverviewRuler = () => {
+  return i18nString(HideCursorInOverviewRuler);
+};
+const hideCursorInOverviewRulerDescription = () => {
+  return i18nString(HideCursorInOverviewRulerDescription);
+};
+const hover = () => {
+  return i18nString(Hover);
+};
+const hoverDescription = () => {
+  return i18nString(HoverDescription);
+};
+const inDiffEditor = () => {
+  return i18nString(InDiffEditor);
+};
+const inDiffEditorDescription = () => {
+  return i18nString(InDiffEditorDescription);
+};
+const letterSpacing = () => {
+  return i18nString(LetterSpacing);
+};
+const letterSpacingDescription = () => {
+  return i18nString(LetterSpacingDescription);
+};
+const lightbulbEnabled = () => {
+  return i18nString(LightbulbEnabled);
+};
+const lightbulbEnabledDescription = () => {
+  return i18nString(LightbulbEnabledDescription);
+};
+const lineDecorationsWidth = () => {
+  return i18nString(LineDecorationsWidth);
+};
+const lineDecorationsWidthDescription = () => {
+  return i18nString(LineDecorationsWidthDescription);
+};
+const lineHeight = () => {
+  return i18nString(LineHeight);
+};
+const lineHeightDescription = () => {
+  return i18nString(LineHeightDescription);
+};
+const matchBrackets = () => {
+  return i18nString(MatchBrackets);
+};
+const matchBracketsDescription = () => {
+  return i18nString(MatchBracketsDescription);
+};
+const minimapEnabled = () => {
+  return i18nString(MinimapEnabled);
+};
+const minimapEnabledDescription = () => {
+  return i18nString(MinimapEnabledDescription);
+};
+const mouseWheelScrollSensitivity = () => {
+  return i18nString(MouseWheelScrollSensitivity);
+};
+const mouseWheelScrollSensitivityDescription = () => {
+  return i18nString(MouseWheelScrollSensitivityDescription);
+};
+const mouseWheelZoom = () => {
+  return i18nString(MouseWheelZoom);
+};
+const mouseWheelZoomDescription = () => {
+  return i18nString(MouseWheelZoomDescription);
+};
+const multiCursorMergeOverlapping = () => {
+  return i18nString(MultiCursorMergeOverlapping);
+};
+const multiCursorMergeOverlappingDescription = () => {
+  return i18nString(MultiCursorMergeOverlappingDescription);
+};
+const overviewRulerBorder = () => {
+  return i18nString(OverviewRulerBorder);
+};
+const overviewRulerBorderDescription = () => {
+  return i18nString(OverviewRulerBorderDescription);
+};
+const overviewRulerLanes = () => {
+  return i18nString(OverviewRulerLanes);
+};
+const overviewRulerLanesDescription = () => {
+  return i18nString(OverviewRulerLanesDescription);
+};
+const peekWidgetDefaultFocus = () => {
+  return i18nString(PeekWidgetDefaultFocus);
+};
+const peekWidgetDefaultFocusDescription = () => {
+  return i18nString(PeekWidgetDefaultFocusDescription);
+};
+const quickSuggestionsDelay = () => {
+  return i18nString(QuickSuggestionsDelay);
+};
+const quickSuggestionsDelayDescription = () => {
+  return i18nString(QuickSuggestionsDelayDescription);
+};
+const renderFinalNewline = () => {
+  return i18nString(RenderFinalNewline);
+};
+const renderFinalNewlineDescription = () => {
+  return i18nString(RenderFinalNewlineDescription);
+};
+const renderValidationDecorations = () => {
+  return i18nString(RenderValidationDecorations);
+};
+const renderValidationDecorationsDescription = () => {
+  return i18nString(RenderValidationDecorationsDescription);
+};
+const revealHorizontalRightPadding = () => {
+  return i18nString(RevealHorizontalRightPadding);
+};
+const revealHorizontalRightPaddingDescription = () => {
+  return i18nString(RevealHorizontalRightPaddingDescription);
+};
+const roundedSelection = () => {
+  return i18nString(RoundedSelection);
+};
+const roundedSelectionDescription = () => {
+  return i18nString(RoundedSelectionDescription);
+};
+const rulers = () => {
+  return i18nString(Rulers);
+};
+const rulersDescription = () => {
+  return i18nString(RulersDescription);
+};
+const scrollBeyondLastColumn = () => {
+  return i18nString(ScrollBeyondLastColumn);
+};
+const scrollBeyondLastColumnDescription = () => {
+  return i18nString(ScrollBeyondLastColumnDescription);
+};
+const scrollbar = () => {
+  return i18nString(Scrollbar);
+};
+const scrollbarDescription = () => {
+  return i18nString(ScrollbarDescription);
+};
+const scrollPredominantAxis = () => {
+  return i18nString(ScrollPredominantAxis);
+};
+const scrollPredominantAxisDescription = () => {
+  return i18nString(ScrollPredominantAxisDescription);
+};
+const selectionClipboard = () => {
+  return i18nString(SelectionClipboard);
+};
+const selectionClipboardDescription = () => {
+  return i18nString(SelectionClipboardDescription);
+};
+const showUnused = () => {
+  return i18nString(ShowUnused);
+};
+const showUnusedDescription = () => {
+  return i18nString(ShowUnusedDescription);
+};
+const snippetSuggestions = () => {
+  return i18nString(SnippetSuggestions);
+};
+const snippetSuggestionsDescription = () => {
+  return i18nString(SnippetSuggestionsDescription);
+};
+const suggest = () => {
+  return i18nString(Suggest);
+};
+const suggestDescription = () => {
+  return i18nString(SuggestDescription);
+};
+const suggestFontSize = () => {
+  return i18nString(SuggestFontSize);
+};
+const suggestFontSizeDescription = () => {
+  return i18nString(SuggestFontSizeDescription);
+};
+const suggestLineHeight = () => {
+  return i18nString(SuggestLineHeight);
+};
+const suggestLineHeightDescription = () => {
+  return i18nString(SuggestLineHeightDescription);
+};
+const suggestSelection = () => {
+  return i18nString(SuggestSelection);
+};
+const suggestSelectionDescription = () => {
+  return i18nString(SuggestSelectionDescription);
+};
+const useTabStops = () => {
+  return i18nString(UseTabStops);
+};
+const useTabStopsDescription = () => {
+  return i18nString(UseTabStopsDescription);
+};
+const wordSeparators = () => {
+  return i18nString(WordSeparators);
+};
+const wordSeparatorsDescription = () => {
+  return i18nString(WordSeparatorsDescription);
+};
+const wrappingIndent = () => {
+  return i18nString(WrappingIndent);
+};
+const wrappingIndentDescription = () => {
+  return i18nString(WrappingIndentDescription);
+};
+
+const getSettingItems = async () => {
+  return [{
+    id: 'fontSize',
+    heading: fontSize(),
+    description: fontSizeDescription(),
+    type: Number$1,
+    value: '15px',
+    category: TextEditorTab
+  }, {
+    id: 'fontFamily',
+    heading: fontFamily(),
+    description: fontFamilyDescription(),
+    type: String,
+    value: 'Fira Code',
+    category: TextEditorTab
+  },
+  // Text Editor Settings
+  {
+    id: 'wordWrap',
+    heading: wordWrap(),
+    description: wordWrapDescription(),
+    type: String,
+    value: 'off',
+    category: TextEditorTab
+  }, {
+    id: 'lineNumbers',
+    heading: lineNumbers(),
+    description: lineNumbersDescription(),
+    type: String,
+    value: 'on',
+    category: TextEditorTab
+  }, {
+    id: 'minimap',
+    heading: minimap(),
+    description: minimapDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'scrollBeyondLastLine',
+    heading: scrollBeyondLastLine(),
+    description: scrollBeyondLastLineDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'smoothScrolling',
+    heading: smoothScrolling(),
+    description: smoothScrollingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'cursorBlinking',
+    heading: cursorBlinking(),
+    description: cursorBlinkingDescription(),
+    type: String,
+    value: 'blink',
+    category: TextEditorTab
+  }, {
+    id: 'cursorStyle',
+    heading: cursorStyle(),
+    description: cursorStyleDescription(),
+    type: String,
+    value: 'line',
+    category: TextEditorTab
+  }, {
+    id: 'cursorWidth',
+    heading: cursorWidth(),
+    description: cursorWidthDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'tabSize',
+    heading: tabSize(),
+    description: tabSizeDescription(),
+    type: Number$1,
+    value: '4',
+    category: TextEditorTab
+  }, {
+    id: 'insertSpaces',
+    heading: insertSpaces(),
+    description: insertSpacesDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'detectIndentation',
+    heading: detectIndentation(),
+    description: detectIndentationDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'trimAutoWhitespace',
+    heading: trimAutoWhitespace(),
+    description: trimAutoWhitespaceDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'largeFileOptimizations',
+    heading: largeFileOptimizations(),
+    description: largeFileOptimizationsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'renderWhitespace',
+    heading: renderWhitespace(),
+    description: renderWhitespaceDescription(),
+    type: String,
+    value: 'selection',
+    category: TextEditorTab
+  }, {
+    id: 'renderControlCharacters',
+    heading: renderControlCharacters(),
+    description: renderControlCharactersDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'renderLineHighlight',
+    heading: renderLineHighlight(),
+    description: renderLineHighlightDescription(),
+    type: String,
+    value: 'line',
+    category: TextEditorTab
+  }, {
+    id: 'codeLens',
+    heading: codeLens(),
+    description: codeLensDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'folding',
+    heading: folding(),
+    description: foldingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'showFoldingControls',
+    heading: showFoldingControls(),
+    description: showFoldingControlsDescription(),
+    type: String,
+    value: 'mouseover',
+    category: TextEditorTab
+  }, {
+    id: 'unfoldOnClickAfterEnd',
+    heading: unfoldOnClickAfterEnd(),
+    description: unfoldOnClickAfterEndDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'links',
+    heading: links(),
+    description: linksDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'colorDecorators',
+    heading: colorDecorators(),
+    description: colorDecoratorsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'lightbulb',
+    heading: lightbulb(),
+    description: lightbulbDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'codeActionsOnSave',
+    heading: codeActionsOnSave(),
+    description: codeActionsOnSaveDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'formatOnPaste',
+    heading: formatOnPaste(),
+    description: formatOnPasteDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'formatOnType',
+    heading: formatOnType(),
+    description: formatOnTypeDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'acceptSuggestionOnCommitCharacter',
+    heading: acceptSuggestionOnCommitCharacter(),
+    description: acceptSuggestionOnCommitCharacterDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'acceptSuggestionOnEnter',
+    heading: acceptSuggestionOnEnter(),
+    description: acceptSuggestionOnEnterDescription(),
+    type: String,
+    value: 'on',
+    category: TextEditorTab
+  }, {
+    id: 'tabCompletion',
+    heading: tabCompletion(),
+    description: tabCompletionDescription(),
+    type: String,
+    value: 'on',
+    category: TextEditorTab
+  }, {
+    id: 'wordBasedSuggestions',
+    heading: wordBasedSuggestions(),
+    description: wordBasedSuggestionsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'suggestOnTriggerCharacters',
+    heading: suggestOnTriggerCharacters(),
+    description: suggestOnTriggerCharactersDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'quickSuggestions',
+    heading: quickSuggestions(),
+    description: quickSuggestionsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'parameterHints',
+    heading: parameterHints(),
+    description: parameterHintsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingBrackets',
+    heading: autoClosingBrackets(),
+    description: autoClosingBracketsDescription(),
+    type: String,
+    value: 'always',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingQuotes',
+    heading: autoClosingQuotes(),
+    description: autoClosingQuotesDescription(),
+    type: String,
+    value: 'always',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingOvertype',
+    heading: autoClosingOvertype(),
+    description: autoClosingOvertypeDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingDelete',
+    heading: autoClosingDelete(),
+    description: autoClosingDeleteDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'autoSurround',
+    heading: autoSurround(),
+    description: autoSurroundDescription(),
+    type: String,
+    value: 'quotes',
+    category: TextEditorTab
+  }, {
+    id: 'bracketPairColorization',
+    heading: bracketPairColorization(),
+    description: bracketPairColorizationDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'guides',
+    heading: guides(),
+    description: guidesDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'dragAndDrop',
+    heading: dragAndDrop(),
+    description: dragAndDropDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'copyWithSyntaxHighlighting',
+    heading: copyWithSyntaxHighlighting(),
+    description: copyWithSyntaxHighlightingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'multiCursorModifier',
+    heading: multiCursorModifier(),
+    description: multiCursorModifierDescription(),
+    type: String,
+    value: 'alt',
+    category: TextEditorTab
+  }, {
+    id: 'multiCursorPaste',
+    heading: multiCursorPaste(),
+    description: multiCursorPasteDescription(),
+    type: String,
+    value: 'full',
+    category: TextEditorTab
+  }, {
+    id: 'occurrencesHighlight',
+    heading: occurrencesHighlight(),
+    description: occurrencesHighlightDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'selectionHighlight',
+    heading: selectionHighlight(),
+    description: selectionHighlightDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'semanticHighlighting',
+    heading: semanticHighlighting(),
+    description: semanticHighlightingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'tokenColorCustomizations',
+    heading: tokenColorCustomizations(),
+    description: tokenColorCustomizationsDescription(),
+    type: String,
+    value: '{}',
+    category: TextEditorTab
+  }, {
+    id: 'workbenchColorCustomizations',
+    heading: workbenchColorCustomizations(),
+    description: workbenchColorCustomizationsDescription(),
+    type: String,
+    value: '{}',
+    category: TextEditorTab
+  }, {
+    id: 'editorColorCustomizations',
+    heading: editorColorCustomizations(),
+    description: editorColorCustomizationsDescription(),
+    type: String,
+    value: '{}',
+    category: TextEditorTab
+  }, {
+    id: 'diffEditor',
+    heading: diffEditor(),
+    description: diffEditorDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffWordWrap',
+    heading: diffWordWrap(),
+    description: diffWordWrapDescription(),
+    type: String,
+    value: 'inherit',
+    category: TextEditorTab
+  }, {
+    id: 'diffCodeLens',
+    heading: diffCodeLens(),
+    description: diffCodeLensDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderSideBySide',
+    heading: diffRenderSideBySide(),
+    description: diffRenderSideBySideDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffIgnoreTrimWhitespace',
+    heading: diffIgnoreTrimWhitespace(),
+    description: diffIgnoreTrimWhitespaceDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderIndicators',
+    heading: diffRenderIndicators(),
+    description: diffRenderIndicatorsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderOverviewRuler',
+    heading: diffRenderOverviewRuler(),
+    description: diffRenderOverviewRulerDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderMarginRevertIcon',
+    heading: diffRenderMarginRevertIcon(),
+    description: diffRenderMarginRevertIconDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  },
+  // Additional Text Editor Settings
+  {
+    id: 'insertMode',
+    heading: insertMode(),
+    description: insertModeDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'overwriteMode',
+    heading: overwriteMode(),
+    description: overwriteModeDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'readOnly',
+    heading: readOnly(),
+    description: readOnlyDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'accessibilitySupport',
+    heading: accessibilitySupport(),
+    description: accessibilitySupportDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'autoIndent',
+    heading: autoIndent(),
+    description: autoIndentDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'bracketMatching',
+    heading: bracketMatching(),
+    description: bracketMatchingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'centeredLayout',
+    heading: centeredLayout(),
+    description: centeredLayoutDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'columnSelection',
+    heading: columnSelection(),
+    description: columnSelectionDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'contextmenu',
+    heading: contextmenu(),
+    description: contextmenuDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'cursorSmoothCaretAnimation',
+    heading: cursorSmoothCaretAnimation(),
+    description: cursorSmoothCaretAnimationDescription(),
+    type: String,
+    value: 'off',
+    category: TextEditorTab
+  }, {
+    id: 'cursorSurroundingLines',
+    heading: cursorSurroundingLines(),
+    description: cursorSurroundingLinesDescription(),
+    type: Number$1,
+    value: '3',
+    category: TextEditorTab
+  }, {
+    id: 'cursorSurroundingLinesStyle',
+    heading: cursorSurroundingLinesStyle(),
+    description: cursorSurroundingLinesStyleDescription(),
+    type: String,
+    value: 'all',
+    category: TextEditorTab
+  }, {
+    id: 'disableMonospaceOptimizations',
+    heading: disableMonospaceOptimizations(),
+    description: disableMonospaceOptimizationsDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'emptySelectionClipboard',
+    heading: emptySelectionClipboard(),
+    description: emptySelectionClipboardDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'extraEditorClassName',
+    heading: extraEditorClassName(),
+    description: extraEditorClassNameDescription(),
+    type: String,
+    value: '',
+    category: TextEditorTab
+  }, {
+    id: 'fastScrollSensitivity',
+    heading: fastScrollSensitivity(),
+    description: fastScrollSensitivityDescription(),
+    type: Number$1,
+    value: '5',
+    category: TextEditorTab
+  }, {
+    id: 'find',
+    heading: find(),
+    description: findDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'fixedOverflowWidgets',
+    heading: fixedOverflowWidgets(),
+    description: fixedOverflowWidgetsDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'foldingStrategy',
+    heading: foldingStrategy(),
+    description: foldingStrategyDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'fontLigatures',
+    heading: fontLigatures(),
+    description: fontLigaturesDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'glyphMargin',
+    heading: glyphMargin(),
+    description: glyphMarginDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'gotoLocation',
+    heading: gotoLocation(),
+    description: gotoLocationDescription(),
+    type: String,
+    value: 'mouse',
+    category: TextEditorTab
+  }, {
+    id: 'hideCursorInOverviewRuler',
+    heading: hideCursorInOverviewRuler(),
+    description: hideCursorInOverviewRulerDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'hover',
+    heading: hover(),
+    description: hoverDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'inDiffEditor',
+    heading: inDiffEditor(),
+    description: inDiffEditorDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'letterSpacing',
+    heading: letterSpacing(),
+    description: letterSpacingDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'lightbulbEnabled',
+    heading: lightbulbEnabled(),
+    description: lightbulbEnabledDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'lineDecorationsWidth',
+    heading: lineDecorationsWidth(),
+    description: lineDecorationsWidthDescription(),
+    type: Number$1,
+    value: '10',
+    category: TextEditorTab
+  }, {
+    id: 'lineHeight',
+    heading: lineHeight(),
+    description: lineHeightDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'matchBrackets',
+    heading: matchBrackets(),
+    description: matchBracketsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'minimapEnabled',
+    heading: minimapEnabled(),
+    description: minimapEnabledDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'mouseWheelScrollSensitivity',
+    heading: mouseWheelScrollSensitivity(),
+    description: mouseWheelScrollSensitivityDescription(),
+    type: Number$1,
+    value: '1',
+    category: TextEditorTab
+  }, {
+    id: 'mouseWheelZoom',
+    heading: mouseWheelZoom(),
+    description: mouseWheelZoomDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'multiCursorMergeOverlapping',
+    heading: multiCursorMergeOverlapping(),
+    description: multiCursorMergeOverlappingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'overviewRulerBorder',
+    heading: overviewRulerBorder(),
+    description: overviewRulerBorderDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'overviewRulerLanes',
+    heading: overviewRulerLanes(),
+    description: overviewRulerLanesDescription(),
+    type: Number$1,
+    value: '3',
+    category: TextEditorTab
+  }, {
+    id: 'peekWidgetDefaultFocus',
+    heading: peekWidgetDefaultFocus(),
+    description: peekWidgetDefaultFocusDescription(),
+    type: String,
+    value: 'editor',
+    category: TextEditorTab
+  }, {
+    id: 'quickSuggestionsDelay',
+    heading: quickSuggestionsDelay(),
+    description: quickSuggestionsDelayDescription(),
+    type: Number$1,
+    value: '10',
+    category: TextEditorTab
+  }, {
+    id: 'renderFinalNewline',
+    heading: renderFinalNewline(),
+    description: renderFinalNewlineDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'renderValidationDecorations',
+    heading: renderValidationDecorations(),
+    description: renderValidationDecorationsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'revealHorizontalRightPadding',
+    heading: revealHorizontalRightPadding(),
+    description: revealHorizontalRightPaddingDescription(),
+    type: Number$1,
+    value: '30',
+    category: TextEditorTab
+  }, {
+    id: 'roundedSelection',
+    heading: roundedSelection(),
+    description: roundedSelectionDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'rulers',
+    heading: rulers(),
+    description: rulersDescription(),
+    type: String,
+    value: '[]',
+    category: TextEditorTab
+  }, {
+    id: 'scrollBeyondLastColumn',
+    heading: scrollBeyondLastColumn(),
+    description: scrollBeyondLastColumnDescription(),
+    type: Number$1,
+    value: '5',
+    category: TextEditorTab
+  }, {
+    id: 'scrollbar',
+    heading: scrollbar(),
+    description: scrollbarDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'scrollPredominantAxis',
+    heading: scrollPredominantAxis(),
+    description: scrollPredominantAxisDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'selectionClipboard',
+    heading: selectionClipboard(),
+    description: selectionClipboardDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'showUnused',
+    heading: showUnused(),
+    description: showUnusedDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'snippetSuggestions',
+    heading: snippetSuggestions(),
+    description: snippetSuggestionsDescription(),
+    type: String,
+    value: 'bottom',
+    category: TextEditorTab
+  }, {
+    id: 'suggest',
+    heading: suggest(),
+    description: suggestDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'suggestFontSize',
+    heading: suggestFontSize(),
+    description: suggestFontSizeDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'suggestLineHeight',
+    heading: suggestLineHeight(),
+    description: suggestLineHeightDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'suggestSelection',
+    heading: suggestSelection(),
+    description: suggestSelectionDescription(),
+    type: String,
+    value: 'recentlyUsed',
+    category: TextEditorTab
+  }, {
+    id: 'useTabStops',
+    heading: useTabStops(),
+    description: useTabStopsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'wordSeparators',
+    heading: wordSeparators(),
+    description: wordSeparatorsDescription(),
+    type: String,
+    value: '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?',
+    category: TextEditorTab
+  }, {
+    id: 'wrappingIndent',
+    heading: wrappingIndent(),
+    description: wrappingIndentDescription(),
+    type: String,
+    value: 'same',
+    category: TextEditorTab
+  }, {
+    id: 'theme',
+    heading: theme(),
+    description: themeDescription(),
+    type: String,
+    value: 'Dark',
+    category: WorkbenchTab
+  }, {
+    id: 'sidebarPosition',
+    heading: sidebarPosition(),
+    description: sidebarPositionDescription(),
+    type: String,
+    value: 'Left',
+    category: WorkbenchTab
+  }, {
+    id: 'windowTitle',
+    heading: windowTitle(),
+    description: windowTitleDescription(),
+    type: String,
+    value: 'Settings View',
+    category: WindowTab
+  }, {
+    id: 'windowSize',
+    heading: windowSize(),
+    description: windowSizeDescription(),
+    type: String,
+    value: '1024x768',
+    category: WindowTab
+  }, {
+    id: 'autoSave',
+    heading: autoSave(),
+    description: autoSaveDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: FeaturesTab
+  }, {
+    id: 'formatOnSave',
+    heading: formatOnSave(),
+    description: formatOnSaveDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: FeaturesTab
+  }, {
+    id: 'telemetry',
+    heading: telemetry(),
+    description: telemetryDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ApplicationsTab
+  }, {
+    id: 'updates',
+    heading: autoUpdates(),
+    description: autoUpdatesDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ApplicationsTab
+  }, {
+    id: 'encryption',
+    heading: fileEncryption(),
+    description: fileEncryptionDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: SecurityTab
+  }, {
+    id: 'twoFactor',
+    heading: twoFactorAuth(),
+    description: twoFactorAuthDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: SecurityTab
+  }, {
+    id: 'extensionsAutoUpdate',
+    heading: autoUpdateExtensions(),
+    description: autoUpdateExtensionsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ExtensionsTab
+  }, {
+    id: 'extensionRecommendations',
+    heading: extensionRecommendations(),
+    description: extensionRecommendationsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ExtensionsTab
+  }];
+};
+
+const getTabs = () => {
+  const tabs = [{
+    id: TextEditorTab,
+    label: 'Text Editor',
+    selected: true
+  }, {
+    id: WorkbenchTab,
+    label: 'Workbench',
+    selected: false
+  }, {
+    id: WindowTab,
+    label: 'Window',
+    selected: false
+  }, {
+    id: FeaturesTab,
+    label: 'Features',
+    selected: false
+  }, {
+    id: ApplicationsTab,
+    label: 'Applications',
+    selected: false
+  }, {
+    id: SecurityTab,
+    label: 'Security',
+    selected: false
+  }, {
+    id: ExtensionsTab,
+    label: 'Extensions',
+    selected: false
+  }];
+  return tabs;
+};
+
+const loadContent = async (state, savedState) => {
+  const {
+    searchValue
+  } = state;
+  const tabs = getTabs();
+  const items = await getSettingItems();
+  const filteredItems = getFilteredItems(items, tabs, searchValue);
+  const preferences = await getPreferences();
+  return {
+    ...state,
+    tabs,
+    items,
+    filteredItems,
+    preferences
+  };
+};
+
+const Tab$1 = 'tab';
+const TabList = 'tablist';
+const AriaRoles = {
+  __proto__: null,
+  Tab: Tab$1,
+  TabList};
+const Viewlet$1 = 'Viewlet';
+const ClassNames = {
+  __proto__: null,
+  Viewlet: Viewlet$1};
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+const Button = 1;
+const Div = 4;
+const H1 = 5;
+const Input = 6;
+const Text = 12;
+const H2 = 22;
+const H3 = 23;
+const Aside = 28;
+const P = 50;
+const Ul = 60;
+const VirtualDomElements = {
+  __proto__: null,
+  Aside,
+  Button,
+  Div,
+  H1,
+  H2,
+  H3,
+  Input,
+  P,
+  Ul};
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const {
+  Viewlet
+} = ClassNames;
+const Settings = 'Settings';
+
+// TODo use numeric ids
+const HandleClickClear = 'handleClickClear';
+const HandleClickTab = 'handleClickTab';
+const HandleInput = 'handleInput';
+
+const getSettingsInputDom = () => {
+  const placeholder = searchSettings();
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsInputWrapper',
+    childCount: 2
+  }, {
+    type: VirtualDomElements.Input,
+    className: 'InputBox SettingsSearchInput',
+    placeholder,
+    childCount: 0,
+    name: SettingsSearch,
+    onInput: HandleInput
+  }, {
+    type: VirtualDomElements.Button,
+    className: 'Button InputButton',
+    childCount: 1,
+    ariaLabel: clear(),
+    // TODO i18n string
+    name: Clear$1 // TODO add click event listener
+  }, text(clear()) // TODO use icon
+  ];
+};
+
+const getSettingsHeaderDom = () => {
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsHeader',
+    childCount: 1
+  }, ...getSettingsInputDom()];
+};
+
+const getItemNumberVirtualDom = item => {
+  const {
+    heading,
+    description
+  } = item;
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsItem',
+    childCount: 3
+  }, {
+    type: VirtualDomElements.H3,
+    childCount: 1
+  }, text(heading), {
+    type: VirtualDomElements.P,
+    childCount: 1
+  }, text(description), {
+    type: VirtualDomElements.Input,
+    className: 'InputBox',
+    inputType: 'number',
+    placeholder: numberValue(),
+    childCount: 0
+  }];
+};
+
+const getSettingsItemsDom = (items, searchValue) => {
+  if (items.length === 0 && searchValue.trim()) {
+    return [{
+      type: VirtualDomElements.Div,
+      className: 'SettingsItems',
+      childCount: 1
+    }, {
+      type: VirtualDomElements.Div,
+      className: 'SettingsNoResults',
+      childCount: 1
+    }, text(noSettingsMatching(searchValue))];
+  }
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsItems',
+    childCount: items.length
+  }, ...items.flatMap(getItemNumberVirtualDom)];
+};
+
+const getSettingsContentDom = (items, tabs, searchValue) => {
+  const selectedTab = tabs.find(tab => tab.selected);
+  const headerText = selectedTab ? selectedTab.label : settingsContent();
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsContent',
+    childCount: 2
+  }, {
+    type: VirtualDomElements.H1,
+    className: 'SettingsContentHeading',
+    childCount: 1
+  }, text(headerText), ...getSettingsItemsDom(items, searchValue)];
+};
+
+const getTabClassName = tab => {
+  return tab.selected ? mergeClassNames('Tab', 'TabSelected') : 'Tab';
+};
+
+const getTabVirtualDom = tab => {
+  const className = getTabClassName(tab);
+  return [{
+    type: VirtualDomElements.Button,
+    className,
+    childCount: 1,
+    role: AriaRoles.Tab,
+    name: tab.id,
+    id: tab.id,
+    ariaSelected: tab.selected
+  }, text(tab.label)];
+};
+
+const getSettingsTabsDom = tabs => {
+  return [{
+    type: VirtualDomElements.Ul,
+    className: 'SettingsTabs',
+    role: AriaRoles.TabList,
+    childCount: tabs.length,
+    onClick: HandleClickTab
+  }, ...tabs.flatMap(getTabVirtualDom)];
+};
+
+const getSettingsSideBarDom = tabs => {
+  const sideBarHeading = settingsSideBar();
+  return [{
+    type: VirtualDomElements.Aside,
+    className: 'SettingsSideBar',
+    childCount: 2
+  }, {
+    type: VirtualDomElements.H2,
+    className: 'SettingsSideBarHeading',
+    childCount: 1
+  }, text(sideBarHeading), ...getSettingsTabsDom(tabs)];
+};
+
+const getSettingsMainDom = (tabs, items, searchValue) => {
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsMain',
+    childCount: 2
+  }, ...getSettingsSideBarDom(tabs), ...getSettingsContentDom(items, tabs, searchValue)];
+};
+
+const getSettingsDom = state => {
+  const {
+    tabs,
+    filteredItems,
+    searchValue
+  } = state;
+  return [{
+    type: VirtualDomElements.Div,
+    childCount: 2,
+    className: mergeClassNames(Viewlet, Settings)
+  }, ...getSettingsHeaderDom(), ...getSettingsMainDom(tabs, filteredItems, searchValue)];
+};
+
+const renderItems = (oldState, newState) => {
+  const dom = getSettingsDom(newState);
+  return ['Viewlet.setDom2', newState.id, dom];
+};
+
+const getRenderer = diffType => {
+  switch (diffType) {
+    case RenderItems:
+      return renderItems;
+    default:
+      throw new Error('unknown renderer');
+  }
+};
+
+const applyRender = (oldState, newState, diffResult) => {
+  const commands = [];
+  for (const item of diffResult) {
+    const fn = getRenderer(item);
+    commands.push(fn(oldState, newState));
+  }
+  return commands;
+};
+
+const render2 = (uid, diffResult) => {
+  const {
+    oldState,
+    newState
+  } = get$1(uid);
+  set$1(uid, newState, newState);
+  const commands = applyRender(oldState, newState, diffResult);
+  return commands;
+};
+
+const renderActions = () => {
+  return [];
+};
+
+const renderEventListeners = () => {
+  return [{
+    name: HandleClickTab,
+    params: ['handleClickTab', 'event.target.name']
+  }, {
+    name: HandleInput,
+    params: ['handleInput', 'event.target.value']
+  }, {
+    name: HandleClickClear,
+    params: ['clear']
+  }];
+};
+
+const getSavedMinLineY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'minLineY' in savedState && typeof savedState.minLineY === 'number') {
+    return savedState.minLineY;
+  }
+  return 0;
+};
+const getSavedDeltaY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'deltaY' in savedState && typeof savedState.deltaY === 'number') {
+    return savedState.deltaY;
+  }
+  return 0;
+};
+const getSavedWorkspacePath = savedState => {
+  if (savedState && typeof savedState === 'object' && 'workspacePath' in savedState && typeof savedState.workspacePath === 'string') {
+    return savedState.workspacePath;
+  }
+  return '';
+};
+const restoreState = savedState => {
+  if (!savedState) {
+    return {
+      root: '',
+      minLineY: 0,
+      deltaY: 0
+    };
+  }
+  const root = getSavedWorkspacePath(savedState);
+  const minLineY = getSavedMinLineY(savedState);
+  const deltaY = getSavedDeltaY(savedState);
+  return {
+    root,
+    minLineY,
+    deltaY
+  };
+};
+
+const saveState = state => {
+  const {
+    tabs,
+    searchValue
+  } = state;
+  const selectedTab = getSelectedTabId(tabs);
+  return {
+    expandedPaths: [],
+    root: '',
+    minLineY: 0,
+    maxLineY: 0,
+    deltaY: 0,
+    searchValue,
+    selectedTab
+  };
+};
+
+const commandMap = {
+  'Initialize.initialize': initialize,
+  'Settings.create': create$1,
+  'Settings.diff2': diff2,
+  'Settings.getCommandIds': getCommandIds,
+  'Settings.loadContent': wrapCommand(loadContent),
+  'Settings.render2': render2,
+  'Settings.renderActions': renderActions,
+  'Settings.renderEventListeners': renderEventListeners,
+  'Settings.restoreState': restoreState,
+  'Settings.saveState': wrapGetter(saveState),
+  'Settings.terminate': terminate,
+  'Settings.handleClickTab': wrapCommand(handleClickTab),
+  'Settings.clear': wrapCommand(clear$1),
+  'Settings.handleInput': wrapCommand(handleInput)
+};
+
+const rpcs = Object.create(null);
+const set$g = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+
+const create = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$g(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+const RendererWorker$1 = 1;
+const {
+  set: set$3} = create(RendererWorker$1);
+const RendererWorker = {
+  __proto__: null,
+  set: set$3};
+
+const {
+  set
+} = RendererWorker;
+
+const listen = async () => {
+  registerCommands(commandMap);
+  const rpc = await WebWorkerRpcClient.create({
+    commandMap: commandMap
+  });
+  set(rpc);
+};
+
+const main = async () => {
+  await listen();
+};
+
+main();