@lvce-editor/server 0.32.2 → 0.33.1

package/static/{93e00a3 → 2aa17eb}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -2,26 +2,26 @@ const state$R = {
   width: 0,
   height: 0
 };
-const get$g = () => {
+const get$h = () => {
   return {
     width: state$R.width,
     height: state$R.height
   };
 };
-const set$g = (width, height) => {
+const set$h = (width, height) => {
   state$R.width = width, state$R.height = height;
 };
 
-class AssertionError extends Error {
+let AssertionError$1 = class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-}
+};
 
 // TODO treeshake out this whole module in production
 
-const getType = value => {
+const getType$1 = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -47,55 +47,55 @@ const getType = value => {
   }
 };
 const object = value => {
-  const type = getType(value);
+  const type = getType$1(value);
   if (type !== 'object') {
-    throw new AssertionError('expected value to be of type object');
+    throw new AssertionError$1('expected value to be of type object');
   }
 };
-const number = value => {
-  const type = getType(value);
+const number$1 = value => {
+  const type = getType$1(value);
   if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
+    throw new AssertionError$1('expected value to be of type number');
   }
   if (isNaN(value)) {
-    throw new AssertionError('value is NaN');
+    throw new AssertionError$1('value is NaN');
   }
 };
 const array = value => {
-  const type = getType(value);
+  const type = getType$1(value);
   if (type !== 'array') {
-    throw new AssertionError('expected value to be of type array');
+    throw new AssertionError$1('expected value to be of type array');
   }
 };
 const string = value => {
-  const type = getType(value);
+  const type = getType$1(value);
   if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
+    throw new AssertionError$1('expected value to be of type string');
   }
 };
 const boolean = value => {
-  const type = getType(value);
+  const type = getType$1(value);
   if (type !== 'boolean') {
-    throw new AssertionError('expected value to be of type boolean');
+    throw new AssertionError$1('expected value to be of type boolean');
   }
 };
 const fn = value => {
-  const type = getType(value);
+  const type = getType$1(value);
   if (type !== 'function') {
-    throw new AssertionError('expected value to be of type function');
+    throw new AssertionError$1('expected value to be of type function');
   }
 };
 
 const state$Q = {
   pending: Object.create(null)
 };
-const get$f = id => {
+const get$g = id => {
   return state$Q.pending[id];
 };
 const has$1 = id => {
   return id in state$Q.pending;
 };
-const set$f = (id, value) => {
+const set$g = (id, value) => {
   state$Q.pending[id] = value;
 };
 
@@ -109,7 +109,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/93e00a3';
+    return '/2aa17eb';
   }
 };
 const assetDir = getAssetDir();
@@ -122,14 +122,14 @@ const getText$3 = response => {
 const getJson$6 = response => {
   return response.json();
 };
-const create$1b = (value, options) => {
+const create$1a = (value, options) => {
   return new Response(value, options);
 };
 
 const Dash = '-';
 const Dot = '.';
 const EmptyString = '';
-const NewLine = '\n';
+const NewLine$1 = '\n';
 const Slash$2 = '/';
 const Space$2 = ' ';
 const Tab$5 = '\t';
@@ -143,8 +143,8 @@ const DiffSeparator = '<->';
  * @param {number|undefined} startIndex
  * @returns
  */
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$1, startIndex);
 };
 
 const normalizeLine = line => {
@@ -161,8 +161,8 @@ const mergeStacks = (parent, child) => {
   if (!child) {
     return parent;
   }
-  const parentNewLineIndex = getNewLineIndex(parent);
-  const childNewLineIndex = getNewLineIndex(child);
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
   if (childNewLineIndex === -1) {
     return parent;
   }
@@ -230,53 +230,80 @@ const getCssId = path => {
   return 'Css' + path.replace('/css/parts/', '').replaceAll(Slash$2, Dash).replace('.css', EmptyString);
 };
 
+// @ts-nocheck
+const Two = "2.0";
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AssertionError";
+  }
+}
+const getType = value => {
+  switch (typeof value) {
+    case "number":
+      return "number";
+    case "function":
+      return "function";
+    case "string":
+      return "string";
+    case "object":
+      if (value === null) {
+        return "null";
+      }
+      if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    case "boolean":
+      return "boolean";
+    default:
+      return "unknown";
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== "number") {
+    throw new AssertionError("expected value to be of type number");
+  }
+};
+const state$1$1 = {
+  callbacks: Object.create(null)
+};
+const set$f = (id, fn) => {
+  state$1$1.callbacks[id] = fn;
+};
+const get$f = id => {
+  return state$1$1.callbacks[id];
+};
+const remove$b = id => {
+  delete state$1$1.callbacks[id];
+};
 const state$P = {
   id: 0
 };
-const create$1a = () => {
+const create$3$1 = () => {
   return ++state$P.id;
 };
-
-const info$1 = (...args) => {
-  console.info(...args);
-};
-const warn$1 = (...args) => {
+const warn$2 = (...args) => {
   console.warn(...args);
 };
-const error = (...args) => {
-  console.error(...args);
-};
-
-const withResolvers = () => {
-  /**
-   * @type {any}
-   */
+const withResolvers$1 = () => {
   let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve;
-    _reject = reject;
+  const promise = new Promise(resolve2 => {
+    _resolve = resolve2;
   });
   return {
     resolve: _resolve,
-    reject: _reject,
     promise
   };
 };
-
-const state$O = {
-  callbacks: Object.create(null)
-};
 const registerPromise = () => {
-  const id = create$1a();
+  const id = create$3$1();
   const {
-    resolve,
+    resolve: resolve2,
     promise
-  } = withResolvers();
-  state$O.callbacks[id] = resolve;
+  } = withResolvers$1();
+  set$f(id, resolve2);
   return {
     id,
     promise
@@ -284,13 +311,242 @@ const registerPromise = () => {
 };
 const resolve = (id, args) => {
   number(id);
-  if (!(id in state$O.callbacks)) {
+  const fn = get$f(id);
+  if (!fn) {
     console.log(args);
-    warn$1(`callback ${id} may already be disposed`);
+    warn$2(`callback ${id} may already be disposed`);
     return;
   }
-  state$O.callbacks[id](args);
-  delete state$O.callbacks[id];
+  fn(args);
+  remove$b(id);
+};
+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 getNewLineIndex = (string, startIndex = void 0) => {
+  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 joinLines$1 = lines => {
+  return lines.join(NewLine);
+};
+const MethodNotFound = -32601;
+const splitLines$1 = lines => {
+  return lines.split(NewLine);
+};
+const restoreJsonRpcError = error => {
+  if (error && error instanceof Error) {
+    return error;
+  }
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || "").slice(1));
+  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) {
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || "";
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        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 isMessagePort$1 = value => {
+  return typeof MessagePort !== "undefined" && value instanceof MessagePort;
+};
+const isInstanceOf = (value, constructorName) => {
+  var _a;
+  return ((_a = value == null ? void 0 : value.constructor) == null ? void 0 : _a.name) === constructorName;
+};
+const isMessagePortMain = value => {
+  return isInstanceOf(value, "MessagePortMain");
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas;
+};
+const isSocket = value => {
+  return isInstanceOf(value, "Socket");
+};
+const transferrables = [isMessagePort$1, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables2) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables2.push(value);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables2);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables2);
+    }
+  }
+};
+const getTransferrables = value => {
+  const transferrables2 = [];
+  walkValue(value, transferrables2);
+  return transferrables2;
+};
+const isSingleTransferrable = value => {
+  return isSocket(value);
+};
+const getTransferrableParams = value => {
+  const transferrables2 = getTransferrables(value);
+  if (transferrables2.length === 0) {
+    return void 0;
+  }
+  if (isSingleTransferrable(transferrables2[0])) {
+    return transferrables2[0];
+  }
+  return transferrables2;
+};
+const invoke$9 = async (ipc, method, ...params) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  ipc.send(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
+const invokeAndTransfer$8 = async (ipc, handle, method, ...params) => {
+  let transfer = handle;
+  if (typeof handle === "string") {
+    params = [method, ...params];
+    method = handle;
+    transfer = getTransferrableParams(params);
+  }
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  ipc.sendAndTransfer(message, transfer);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
 };
 
 const ENOENT = 'ENOENT';
@@ -622,7 +878,7 @@ const getModuleId$1 = commandId => {
   }
 };
 
-const state$N = {
+const state$O = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -645,26 +901,26 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$N.load(moduleId);
+    const module = await state$O.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$N.pendingModules[moduleId]) {
-    state$N.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$O.pendingModules[moduleId]) {
+    state$O.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$N.pendingModules[moduleId];
+  return state$O.pendingModules[moduleId];
 };
 const loadCommand = command => getOrLoadModule(getModuleId$1(command));
 const register$2 = (commandId, listener) => {
-  state$N.commands[commandId] = listener;
+  state$O.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$N.commands) {
-    const fn = state$N.commands[command];
+  if (command in state$O.commands) {
+    const fn = state$O.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -673,7 +929,7 @@ const execute$4 = (command, ...args) => {
   return loadCommand(command)
   // TODO can skip then block in prod (only to prevent endless loop in dev)
   .then(() => {
-    if (!(command in state$N.commands)) {
+    if (!(command in state$O.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -684,11 +940,9 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$N.load = load;
+  state$O.load = load;
 };
 
-const Two = '2.0';
-
 const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
   if (!message || typeof message === 'string') {
     console.warn(`unexpected message from ${source}: ${message}`);
@@ -699,14 +953,14 @@ const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
       try {
         const result = await execute(message.method, ...message.params);
         ipc.send({
-          jsonrpc: Two,
+          jsonrpc: '2.0',
           id: message.id,
           result
         });
         return;
       } catch (error) {
         ipc.send({
-          jsonrpc: Two,
+          jsonrpc: '2.0',
           id: message.id,
           error
         });
@@ -769,13 +1023,13 @@ class Ipc extends EventTarget {
   }
 }
 const readyMessage = "ready";
-const listen$3 = () => {
+const listen$4 = () => {
   if (typeof WorkerGlobalScope === "undefined") {
     throw new TypeError("module is not in web worker scope");
   }
   return globalThis;
 };
-const signal$2 = global => {
+const signal$3 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -794,14 +1048,14 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener("message", callback);
   }
 }
-const wrap$5$1 = global => {
+const wrap$6$1 = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
-  listen: listen$3,
-  signal: signal$2,
-  wrap: wrap$5$1
+  listen: listen$4,
+  signal: signal$3,
+  wrap: wrap$6$1
 };
 
 const getModule$a = method => {
@@ -827,182 +1081,8 @@ const listen$2 = async ({
   return ipc;
 };
 
-const create$19 = (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 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 joinLines = lines => {
-  return lines.join(NewLine);
-};
-
-const MethodNotFound = -32601;
-
-const splitLines = lines => {
-  string(lines);
-  return lines.split(NewLine);
-};
-
-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 getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
-  }
-  return parentStack;
-};
-const restoreJsonRpcError = error => {
-  if (error && error instanceof Error) {
-    return error;
-  }
-  const currentStack = joinLines(splitLines(new Error().stack).slice(1));
-  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) {
-        // TODO accessing stack might be slow
-        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 invoke$9 = async (ipc, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$19(method, params);
-  ipc.send(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
-};
-const invokeAndTransfer$8 = async (ipc, transfer, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$19(method, params);
-  ipc.sendAndTransfer(message, transfer);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
-};
-
 /* istanbul ignore file */
-const state$M = {
+const state$N = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -1015,19 +1095,16 @@ const getIpc = () => {
   });
 };
 const listen$1 = async () => {
-  console.assert(state$M.pendingMessages.length === 0);
+  console.assert(state$N.pendingMessages.length === 0);
   const ipc = await getIpc();
   handleIpc(ipc);
-  state$M.ipc = ipc;
+  state$N.ipc = ipc;
 };
 const invoke$8 = (method, ...params) => {
-  return invoke$9(state$M.ipc, method, ...params);
-};
-const invokeAndTransfer$7 = (method, transfer, ...params) => {
-  return invokeAndTransfer$8(state$M.ipc, transfer, method, ...params);
+  return invoke$9(state$N.ipc, method, ...params);
 };
-const sendAndTransfer = (message, transferables) => {
-  state$M.ipc.sendAndTransfer(message, transferables);
+const invokeAndTransfer$7 = (method, ...params) => {
+  return invokeAndTransfer$8(state$N.ipc, method, ...params);
 };
 
 const actuallyLoadCssStyleSheet = async css => {
@@ -1037,9 +1114,9 @@ const actuallyLoadCssStyleSheet = async css => {
 };
 const loadCssStyleSheet = id => {
   if (!has$1(id)) {
-    set$f(id, actuallyLoadCssStyleSheet(id));
+    set$g(id, actuallyLoadCssStyleSheet(id));
   }
-  return get$f(id);
+  return get$g(id);
 };
 const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
@@ -1053,9 +1130,9 @@ const actuallyAddDynamicCss = async (id, getCss, preferences) => {
 };
 const addDynamicCss = (id, getCss, preferences) => {
   if (!has$1(id)) {
-    set$f(id, actuallyAddDynamicCss(id, getCss, preferences));
+    set$g(id, actuallyAddDynamicCss(id, getCss, preferences));
   }
-  return get$f(id);
+  return get$g(id);
 };
 
 /**
@@ -1136,6 +1213,11 @@ const getResponse$1 = async (url, options) => {
   }
 };
 
+const splitLines = lines => {
+  string(lines);
+  return lines.split(NewLine$1);
+};
+
 const RE_AT = /^\s+at/;
 const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
 const RE_OBJECT_AS = /^\s*at Object\.\w+ \[as ([\w\.]+)\]/;
@@ -1292,7 +1374,7 @@ const getMarkerLines = (loc, source, opts) => {
     markerLines
   };
 };
-const create$18 = (rawLines, loc, opts = {}) => {
+const create$19 = (rawLines, loc, opts = {}) => {
   const lines = rawLines.split(NEWLINE);
   const {
     start,
@@ -1320,7 +1402,7 @@ const create$18 = (rawLines, loc, opts = {}) => {
       return ['>', gutter, line.length > 0 ? ` ${line}` : '', markerLine].join('');
     }
     return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`;
-  }).join(NewLine);
+  }).join(NewLine$1);
   if (opts.message && !hasColumns) {
     frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
   }
@@ -1330,13 +1412,13 @@ const create$18 = (rawLines, loc, opts = {}) => {
 const RE_SOURCE_MAP = /^\/\/# sourceMappingURL=(.*)$/;
 const getSourceMapMatch = text => {
   string(text);
-  const index = text.lastIndexOf(NewLine, text.length - 2);
+  const index = text.lastIndexOf(NewLine$1, text.length - 2);
   const lastLine = text.slice(index + 1, -1);
   const lastLineMatch = lastLine.match(RE_SOURCE_MAP);
   if (lastLineMatch) {
     return lastLineMatch;
   }
-  const secondLastLineIndex = getNewLineIndex(text, index - 1);
+  const secondLastLineIndex = getNewLineIndex$1(text, index - 1);
   const secondLastLine = text.slice(secondLastLineIndex, index);
   const secondLastLineMatch = secondLastLine.match(RE_SOURCE_MAP);
   return secondLastLineMatch;
@@ -1349,6 +1431,20 @@ const isActualSourceFile = path => {
   return true;
 };
 
+const joinLines = lines => {
+  return lines.join(NewLine$1);
+};
+
+const info$1 = (...args) => {
+  console.info(...args);
+};
+const warn$1 = (...args) => {
+  console.warn(...args);
+};
+const error = (...args) => {
+  console.error(...args);
+};
+
 const isEmptyString = string => {
   return string === EmptyString;
 };
@@ -1395,8 +1491,8 @@ const decode$1 = string => {
 
 const getColumnMapping = (mappings, line, column) => {
   string(mappings);
-  number(line);
-  number(column);
+  number$1(line);
+  number$1(column);
   let currentColumn = 0;
   let currentLine = 1;
   let originalSourceFileIndex = 0;
@@ -1455,8 +1551,8 @@ const getOriginalPosition = (sourceMap, line, column) => {
     string(sourceMap.mappings);
     array(sourceMap.sources);
     array(sourceMap.names);
-    number(line);
-    number(column);
+    number$1(line);
+    number$1(column);
     const {
       sources,
       mappings
@@ -1599,7 +1695,7 @@ const prepareErrorMessageWithoutCodeFrame = async error => {
       } = getOriginalPosition(sourceMap, parsedLine, parsedColumn);
       const absoluteSourceUrl = toAbsoluteUrl(path, source);
       const originalSourceContent = await getText$2(absoluteSourceUrl);
-      const codeFrame = create$18(originalSourceContent, {
+      const codeFrame = create$19(originalSourceContent, {
         start: {
           line: originalLine,
           column: originalColumn
@@ -1617,7 +1713,7 @@ const prepareErrorMessageWithoutCodeFrame = async error => {
         _error: error
       };
     }
-    const codeFrame = create$18(text, {
+    const codeFrame = create$19(text, {
       start: {
         line: parsedLine,
         column: parsedColumn
@@ -1690,7 +1786,7 @@ const getMessage$5 = error => {
   return `Error: ${error}`;
 };
 
-const state$L = {
+const state$M = {
   /**
    * @type {string[]}
    */
@@ -1723,14 +1819,14 @@ const showErrorDialog = async error => {
 };
 const warn = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$L.seenWarnings.includes(stringified)) {
+  if (state$M.seenWarnings.includes(stringified)) {
     return;
   }
-  state$L.seenWarnings.push(stringified);
+  state$M.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
-const state$K = {
+const state$L = {
   /**
    * @type {any}
    */
@@ -1741,15 +1837,15 @@ const state$K = {
 const invoke$7 = async (method, ...params) => {
   const {
     ipc
-  } = state$K;
+  } = state$L;
   const result = await invoke$9(ipc, method, ...params);
   return result;
 };
-const invokeAndTransfer$6 = async (transfer, method, ...params) => {
+const invokeAndTransfer$6 = async (method, ...params) => {
   const {
     ipc
-  } = state$K;
-  const result = await invokeAndTransfer$8(ipc, transfer, method, ...params);
+  } = state$L;
+  const result = await invokeAndTransfer$8(ipc, method, ...params);
   return result;
 };
 
@@ -1927,29 +2023,29 @@ const canBeRestored$6 = async uri => {
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
 // TODO use normal event target
-const state$J = {
+const state$K = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$J.listenerMap[event] || [];
+  const listeners = state$K.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$J.listenerMap[event] ||= [];
-  if (state$J.listenerMap[event].includes(fn)) {
+  state$K.listenerMap[event] ||= [];
+  if (state$K.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$J.listenerMap[event].unshift(fn);
+    state$K.listenerMap[event].unshift(fn);
   } else {
-    state$J.listenerMap[event].push(fn);
+    state$K.listenerMap[event].push(fn);
   }
 };
 
 const stringify = value => {
-  return JSON.stringify(value, null, 2) + NewLine;
+  return JSON.stringify(value, null, 2) + NewLine$1;
 };
 const stringifyCompact = value => {
   return JSON.stringify(value);
@@ -1994,7 +2090,7 @@ const openUri$1 = async (path, focus = true, props = {}) => {
   await execute$4( /* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const state$I = Object.create(null);
+const state$J = Object.create(null);
 const openSettingsJson = async () => {
   await openUri$1('app://settings.json');
 };
@@ -2025,25 +2121,25 @@ const hydrate$b = async () => {
     // TODO should configuration be together with all other preferences (e.g. selecting color theme code is not needed on startup)
     // TODO probably not all preferences need to be kept in memory
     const preferences = await getPreferences();
-    Object.assign(state$I, preferences);
+    Object.assign(state$J, preferences);
   } catch (error) {
     logError(error);
   }
 };
 const get$d = key => {
-  return state$I[key];
+  return state$J[key];
 };
 const set$e = async (key, value) => {
-  state$I[key] = value;
+  state$J[key] = value;
   if (platform === Web$1) {
     const preferences = {
-      ...state$I,
+      ...state$J,
       [key]: value
     };
     await execute$4( /* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
     return;
   }
-  const content = stringify(state$I);
+  const content = stringify(state$J);
   await writeFile$e('app://settings.json', content);
 };
 
@@ -2097,7 +2193,7 @@ const setThemeColor = async themeColor => {
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
 // actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
 
-const state$H = {
+const state$I = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2108,7 +2204,7 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$H.colorTheme = colorThemeId;
+    state$I.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
     if (platform === Web$1) {
@@ -2128,10 +2224,10 @@ const setColorTheme$1 = async colorThemeId => {
   await set$e('workbench.colorTheme', colorThemeId);
 };
 const watch$2 = async id => {
-  if (state$H.watchedTheme === id) {
+  if (state$I.watchedTheme === id) {
     return;
   }
-  state$H.watchedTheme = id;
+  state$I.watchedTheme = id;
   await invoke$7('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
@@ -2225,18 +2321,18 @@ const remove$9 = key => {
   delete contexts[key];
 };
 
-const state$G = {
+const state$H = {
   // TODO use numeric focus key
   currentFocus: ''
 };
 const get$b = () => {
-  return state$G.currentFocus;
+  return state$H.currentFocus;
 };
 const set$c = value => {
-  state$G.currentFocus = value;
+  state$H.currentFocus = value;
 };
 
-const state$F = {
+const state$G = {
   keyBindings: [],
   keyBindingSets: Object.create(null),
   /**
@@ -2249,7 +2345,7 @@ const state$F = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$F.matchingKeyBindings) {
+  for (const keyBinding of state$G.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -2272,26 +2368,26 @@ const getAvailableKeyBindings = keyBindings => {
   return new Uint32Array(keyBindings.map(getKey$1));
 };
 const update = () => {
-  const matchingKeyBindings = getMatchingKeyBindings(state$F.keyBindingSets);
+  const matchingKeyBindings = getMatchingKeyBindings(state$G.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
   invoke$8('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$F.matchingKeyBindings = matchingKeyBindings;
-  state$F.keyBindingIdentifiers = keyBindingIdentifiers;
+  state$G.matchingKeyBindings = matchingKeyBindings;
+  state$G.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings$1 = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$F.keyBindingSets) {
+  if (id in state$G.keyBindingSets) {
     warn$1(`cannot add keybindings multiple times: ${id}`);
     return;
   }
-  state$F.keyBindingSets[id] = keyBindings;
+  state$G.keyBindingSets[id] = keyBindings;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets
-  } = state$F;
+  } = state$G;
   if (!(id in keyBindingSets)) {
     warn$1(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -2343,7 +2439,7 @@ const FocusConfirm = 40;
  * @param {number} focusKey
  */
 const setFocus = focusKey => {
-  number(focusKey);
+  number$1(focusKey);
   if (get$b()) {
     remove$9(get$b());
   }
@@ -2388,7 +2484,7 @@ const hydrate$9 = async () => {
   update();
 };
 
-const state$E = {
+const state$F = {
   /**
    * @type {any[]}
    */
@@ -2407,7 +2503,7 @@ const getIconThemeJson = async iconThemeId => {
       extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`
     };
   }
-  for (const webExtension of state$E.webExtensions) {
+  for (const webExtension of state$F.webExtensions) {
     if (webExtension.iconThemes) {
       for (const iconTheme of webExtension.iconThemes) {
         // TODO handle error when icon theme path is not of type string
@@ -2425,7 +2521,7 @@ const getIconThemeJson = async iconThemeId => {
 
 const initialIconTheme = undefined;
 
-const state$D = {
+const state$E = {
   seenFiles: [],
   seenFolders: [],
   hasWarned: [],
@@ -2445,6 +2541,13 @@ const isOpen = () => {
   return false;
 };
 
+const state$D = {
+  id: 0
+};
+const create$18 = () => {
+  return ++state$D.id;
+};
+
 class CancelationError extends Error {
   constructor() {
     super('canceled');
@@ -2900,7 +3003,7 @@ const loadModule$3 = async (id, module) => {
     await (Array.isArray(module.Css) ? loadCssStyleSheets(module.Css) : loadCssStyleSheet(module.Css));
   }
   if (module.getDynamicCss) {
-    await addDynamicCss(id, module.getDynamicCss, state$I);
+    await addDynamicCss(id, module.getDynamicCss, state$J);
   }
 };
 
@@ -3196,12 +3299,12 @@ const wrapViewletCommandWithSideEffectLazy = (id, key, importFn) => {
 const create$17 = (getModule, id, parentUid, uri, x, y, width, height) => {
   fn(getModule);
   string(id);
-  number(parentUid);
+  number$1(parentUid);
   string(uri);
-  number(x);
-  number(y);
-  number(width);
-  number(height);
+  number$1(x);
+  number$1(y);
+  number$1(width);
+  number$1(height);
   return {
     type: 0,
     getModule,
@@ -3317,7 +3420,7 @@ const maybeRegisterEvents = module => {
           return;
         }
         const uid = instance.uid || instance.state.uid;
-        number(uid);
+        number$1(uid);
         const commands = render$Q(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
@@ -3392,7 +3495,7 @@ const load$7 = async (viewlet, focus = false, restore = false, restoreState = un
   }
   let state = ViewletState.Default;
   // @ts-ignore
-  const viewletUid = viewlet.uid || create$1a();
+  const viewletUid = viewlet.uid || create$18();
   let module;
   try {
     viewlet.type = 1;
@@ -3439,7 +3542,7 @@ const load$7 = async (viewlet, focus = false, restore = false, restoreState = un
     if (module.getChildren) {
       const children = module.getChildren(newState);
       for (const child of children) {
-        const childUid = child.uid || create$1a();
+        const childUid = child.uid || create$18();
         const childId = child.id;
         const childViewlet = {
           x: child.x,
@@ -3519,7 +3622,7 @@ const load$7 = async (viewlet, focus = false, restore = false, restoreState = un
         }
         if (viewlet.append) {
           const parentUid = viewlet.parentUid;
-          number(parentUid);
+          number$1(parentUid);
           allCommands.push([kAppend, parentUid, viewletUid]);
         }
         return allCommands;
@@ -3706,7 +3809,7 @@ const create$16 = async ({
 };
 
 const handleKeyBinding$1 = async identifier => {
-  number(identifier);
+  number$1(identifier);
   const keyBinding = getKeyBinding(identifier);
   if (!keyBinding) {
     throw new Error(`keybinding not found for identifier ${identifier}`);
@@ -3828,7 +3931,7 @@ const disposeFunctional = id => {
       instance.factory.dispose(instance.state);
     }
     const uid = instance.state.uid;
-    number(uid);
+    number$1(uid);
     const commands = [[/* Viewlet.dispose */'Viewlet.dispose', /* id */uid]];
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(id);
@@ -3890,7 +3993,7 @@ const hideFunctional = id => {
       instance.factory.dispose(instance.state);
     }
     const uid = instance.state.uid;
-    number(uid);
+    number$1(uid);
     const commands = [[/* Viewlet.dispose */'Viewlet.dispose', /* id */uid]];
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(id);
@@ -3914,7 +4017,7 @@ const hideFunctional = id => {
   }
 };
 const resize$n = (id, dimensions) => {
-  number(id);
+  number$1(id);
   object(dimensions);
   const instance = getInstance(id);
   if (!instance || !instance.factory || !instance.factory.resize) {
@@ -3987,7 +4090,7 @@ const getAllStates = () => {
 const openWidget = async (moduleId, ...args) => {
   const hasInstance$1 = hasInstance(moduleId);
   const type = args[0];
-  const childUid = create$1a();
+  const childUid = create$18();
   const commands = await load$7({
     getModule: load$5,
     id: moduleId,
@@ -4109,7 +4212,7 @@ const disposeWidgetWithValue = async (id, value) => {
       instance.factory.dispose(instance.state);
     }
     const uid = instance.state.uid;
-    number(uid);
+    number$1(uid);
     const commands = [[/* Viewlet.dispose */'Viewlet.dispose', /* id */uid]];
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(uid);
@@ -4187,7 +4290,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
   return '';
 };
 const getLanguageConfigurationFromWebExtension = async languageId => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$E.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$F.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined;
   }
@@ -4413,7 +4516,7 @@ const warnFileNames = (languageId, language) => {
       break;
     }
   }
-  const codeFrame = create$18(code, {
+  const codeFrame = create$19(code, {
     start: {
       line: rowIndex + 1,
       column: columnIndex + 1
@@ -4499,7 +4602,7 @@ const getFileNameIcon = file => {
   string(file);
   const {
     iconTheme
-  } = state$D;
+  } = state$E;
   const fileNameLower = file.toLowerCase();
   if (!iconTheme) {
     return '';
@@ -4539,7 +4642,7 @@ const getFileIcon$3 = file => {
   return getFileNameIcon(file.name);
 };
 const getFolderNameIcon = folderName => {
-  const iconTheme = state$D.iconTheme;
+  const iconTheme = state$E.iconTheme;
   // @ts-ignore
   if (!iconTheme || !iconTheme.folderNames || !iconTheme.iconDefinitions) {
     return '';
@@ -4556,7 +4659,7 @@ const getFolderIcon = folder => {
   return getFolderNameIcon(folder.name);
 };
 const getFolderIconExpanded = folder => {
-  const iconTheme = state$D.iconTheme;
+  const iconTheme = state$E.iconTheme;
   if (!iconTheme) {
     return '';
   }
@@ -4585,7 +4688,7 @@ const getIcon$2 = dirent => {
     case CharacterDevice:
     case BlockDevice:
     case Socket:
-      return getAbsoluteIconPath(state$D.iconTheme, File$7);
+      return getAbsoluteIconPath(state$E.iconTheme, File$7);
     default:
       warn$1(`unsupported type ${dirent.type}`);
       return None$k;
@@ -4595,8 +4698,8 @@ const getIcon$2 = dirent => {
 const setIconTheme = async iconThemeId => {
   try {
     const iconTheme = await getIconThemeJson(iconThemeId);
-    state$D.iconTheme = iconTheme.json;
-    state$D.extensionPath = iconTheme.extensionPath;
+    state$E.iconTheme = iconTheme.json;
+    state$E.extensionPath = iconTheme.extensionPath;
     const instances = getAllInstances();
     // TODO have one recalculate style and one paint
     // @ts-ignore
@@ -4650,7 +4753,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$K.ipc = ipc;
+  state$L.ipc = ipc;
 };
 
 const map$2 = Object.create(null);
@@ -5579,7 +5682,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getEvents(sessionId);
-  const originalIpc = state$M.ipc;
+  const originalIpc = state$N.ipc;
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalOnMessage = originalIpc.onmessage.bind(originalIpc);
   const wrappedSend = () => {};
@@ -5594,33 +5697,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$M.ipc.onmessage = originalOnMessage;
-          state$M.ipc.send = originalSend;
+          state$N.ipc.onmessage = originalOnMessage;
+          state$N.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$M.ipc.onmessage = wrappedOnMessage;
-          state$M.ipc.send = wrappedSend;
+          state$N.ipc.onmessage = wrappedOnMessage;
+          state$N.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$M.ipc.onmessage = originalOnMessage;
-          state$M.ipc.send = originalSend;
+          state$N.ipc.onmessage = originalOnMessage;
+          state$N.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$M.ipc.onmessage = wrappedOnMessage;
-          state$M.ipc.send = wrappedSend;
+          state$N.ipc.onmessage = wrappedOnMessage;
+          state$N.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$M.ipc.onmessage = originalOnMessage;
-          state$M.ipc.send = originalSend;
+          state$N.ipc.onmessage = originalOnMessage;
+          state$N.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$M.ipc.onmessage = wrappedOnMessage;
-          state$M.ipc.send = wrappedSend;
+          state$N.ipc.onmessage = wrappedOnMessage;
+          state$N.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$M.ipc.send = wrappedSend;
-  state$M.ipc.onmessage = wrappedOnMessage;
+  state$N.ipc.send = wrappedSend;
+  state$N.ipc.onmessage = wrappedOnMessage;
   const callbacks = Object.create(null);
   const invoke = event => {
     return new Promise((resolve, reject) => {
@@ -5701,8 +5804,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$M.ipc = wrapIpc(state$M.ipc, 'renderer-process', event => event.data);
-  state$K.ipc = wrapIpc(state$K.ipc, 'shared-process', event => event);
+  state$N.ipc = wrapIpc(state$N.ipc, 'renderer-process', event => event.data);
+  state$L.ipc = wrapIpc(state$L.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4( /* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -5804,7 +5907,7 @@ const startup = async () => {
     return;
   }
   if (initData.Location.href.startsWith('http://localhost:3001/tests/')) ;
-  set$g(initData.Layout.bounds.windowWidth, initData.Layout.bounds.windowHeight);
+  set$h(initData.Layout.bounds.windowWidth, initData.Layout.bounds.windowHeight);
   mark(WillLoadPreferences);
   await hydrate$b();
   mark(DidLoadPreferences);
@@ -5827,7 +5930,7 @@ const startup = async () => {
   mark$1(Four);
   mark(WillShowLayout);
   const layout = create$17(load$5, Layout, 0, '', 0, 0, 0, 0);
-  layout.uid = create$1a();
+  layout.uid = create$18();
   const layoutState = await getSavedViewletState(Layout);
   const commands = await load$7({
     getModule: load$5,
@@ -6071,9 +6174,9 @@ const getOrCreateWorker = fn => {
       const ipc = await getOrCreate$2(fn);
       return invoke$9(ipc, method, ...params);
     },
-    async invokeAndTransfer(transfer, method, ...params) {
+    async invokeAndTransfer(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invokeAndTransfer$8(ipc, transfer, method, ...params);
+      return invokeAndTransfer$8(ipc, method, ...params);
     },
     async dispose() {
       const promise = workers.get(fn);
@@ -6115,7 +6218,7 @@ const getStaticWebExtensions = () => {
 };
 const getWebExtensionsWeb = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
-  return [...staticWebExtensions, ...state$E.webExtensions];
+  return [...staticWebExtensions, ...state$F.webExtensions];
 };
 const isWebExtension = extension => {
   return extension && typeof extension.browser === 'string';
@@ -6124,7 +6227,7 @@ const getWebExtensionsDefault = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
   const sharedProcessExtensions = await getSharedProcessExtensions$1();
   const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
-  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$E.webExtensions];
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$F.webExtensions];
 };
 const getWebExtensions = async () => {
   try {
@@ -6135,7 +6238,7 @@ const getWebExtensions = async () => {
         return getWebExtensionsDefault();
     }
   } catch {
-    return state$E.webExtensions;
+    return state$F.webExtensions;
   }
 };
 
@@ -6179,7 +6282,7 @@ const addWebExtension = async path => {
     }
   }
   manifest.status = Resolved;
-  state$E.webExtensions.push(manifest);
+  state$F.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -6337,7 +6440,7 @@ const actuallyActivateByEvent = async event => {
   for (const extension of extensionsToActivate) {
     await actuallyActivateExtension(extension);
   }
-  const additionalExtensions = state$E.webExtensions;
+  const additionalExtensions = state$F.webExtensions;
   const additionalExtensionsToActivate = filterByMatchingEvent(additionalExtensions, event);
   for (const extension of additionalExtensionsToActivate) {
     await actuallyActivateExtension(extension);
@@ -7609,7 +7712,7 @@ const getLineAndColumn = (text, start, end) => {
   let index = -1;
   let line = 0;
   const column = 0;
-  while ((index = getNewLineIndex(text, index + 1)) !== -1) {
+  while ((index = getNewLineIndex$1(text, index + 1)) !== -1) {
     line++;
     if (index >= start) {
       break;
@@ -7895,7 +7998,7 @@ const getPort = async ipcId => {
     port2
   } = getPortTuple();
   // TODO call sendMessagePortToElectron function
-  const webContentsId = await invokeAndTransfer$7('IpcParent.create', [port1], {
+  const webContentsId = await invokeAndTransfer$7('IpcParent.create', {
     method: Electron,
     port: port1,
     ipcId
@@ -8249,6 +8352,26 @@ const create$11 = (url, args) => {
   return context;
 };
 
+const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise
+  };
+};
+
 const getFirstEvent = (eventTarget, eventMap) => {
   const {
     resolve,
@@ -8340,7 +8463,7 @@ const create$$ = async ({
     port1,
     port2
   } = getPortTuple(port);
-  await invokeAndTransfer$7('IpcParent.create', [port2], {
+  await invokeAndTransfer$7('IpcParent.create', {
     method: ModuleWorkerWithMessagePort,
     url,
     name,
@@ -8440,7 +8563,7 @@ const IpcParentWithNode = {
 const sendMessagePortToElectron = async (port, initialCommand, ipcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$6([port], initialCommand, ipcId);
+  await invokeAndTransfer$6(initialCommand, ipcId);
 };
 
 const create$Z = async options => {
@@ -8914,9 +9037,9 @@ const formatAboutDate = isoDate => {
   return `${isoDate} (${ago})`;
 };
 
-const version = '0.32.2';
-const commit = '93e00a3';
-const date = '2024-08-20T21:05:50.000Z';
+const version = '0.33.1';
+const commit = '2aa17eb';
+const date = '2024-08-24T19:49:47.000Z';
 const getPid = () => {
   return invoke$7('Process.getPid');
 };
@@ -9350,7 +9473,7 @@ const setResponse = async (key, value, contentType) => {
   }
   const cacheName = getCacheName();
   const cache = await caches.open(cacheName);
-  await cache.put(key, create$1b(value, {
+  await cache.put(key, create$1a(value, {
     headers: new Headers({
       'Content-Type': contentType,
       'Content-Length': `${value.length}`
@@ -9609,7 +9732,7 @@ const createColorThemeFromJson = (colorThemeId, colorThemeJson) => {
   border: 1px solid var(--ContrastBorder);
 }`);
   }
-  const colorThemeCss = `:root {\n${colorRules.join(NewLine)}\n}\n\n${tokenColorRules.join(NewLine)}\n\n${extraRules.join(NewLine)}`;
+  const colorThemeCss = `:root {\n${colorRules.join(NewLine$1)}\n}\n\n${tokenColorRules.join(NewLine$1)}\n\n${extraRules.join(NewLine$1)}`;
   return colorThemeCss;
 };
 
@@ -9802,9 +9925,9 @@ const getModule$5 = () => {
   return Promise.resolve().then(function () { return ContextMenuBrowser; });
 };
 const show$a = async (x, y, id, ...args) => {
-  number(x);
-  number(y);
-  number(id);
+  number$1(x);
+  number$1(y);
+  number$1(id);
   const module = await getModule$5();
   return module.show(x, y, id, ...args);
 };
@@ -9944,7 +10067,7 @@ const Debug_ipc = {
 };
 
 const attachDebugger = async pid => {
-  number(pid);
+  number$1(pid);
   await invoke$7('AttachDebugger.attachDebugger', pid);
 };
 
@@ -10693,9 +10816,9 @@ const EditorDiagnostics_ipc = {
 };
 
 const clamp = (num, min, max) => {
-  number(num);
-  number(min);
-  number(max);
+  number$1(num);
+  number$1(min);
+  number$1(max);
   return Math.min(Math.max(num, min), max);
 };
 
@@ -10747,11 +10870,11 @@ const getLetterSpacingString = letterSpacing => {
 };
 const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
   string(text);
-  number(fontWeight);
-  number(fontSize);
+  number$1(fontWeight);
+  number$1(fontSize);
   string(fontFamily);
   boolean(isMonoSpaceFont);
-  number(charWidth);
+  number$1(charWidth);
   if (isMonoSpaceFont) {
     return text.length * charWidth;
   }
@@ -10892,8 +11015,8 @@ const actualInvoke = invoke$5;
 
 const offsetAt = async (textDocument, positionRowIndex, positionColumnIndex) => {
   object(textDocument);
-  number(positionRowIndex);
-  number(positionColumnIndex);
+  number$1(positionRowIndex);
+  number$1(positionColumnIndex);
   return actualInvoke('Editor.offsetAt', textDocument, positionRowIndex, positionColumnIndex);
 };
 const positionAt = (textDocument, offset) => {
@@ -10941,8 +11064,8 @@ const open$5 = async () => {
   } = editor;
   const rowIndex = selections[0];
   const columnIndex = selections[1];
-  number(rowIndex);
-  number(columnIndex);
+  number$1(rowIndex);
+  number$1(columnIndex);
 
   // TODO handle error and add tests for handled error
   const prepareRenameResult = await prepareRename(editor, rowIndex, columnIndex);
@@ -11818,7 +11941,7 @@ const toElectronMenuItem = entry => {
 const toElectronMenuInternal = (commandMap, map, id, electronMenu) => {
   object(commandMap);
   object(map);
-  number(id);
+  number$1(id);
   array(electronMenu);
   const entries = map[id];
   array(entries);
@@ -12419,12 +12542,12 @@ const KeyBindingsInitial_ipc = {
 
 const state$d = Object.create(null);
 const register = listener => {
-  const id = create$1a();
+  const id = create$18();
   state$d[id] = listener;
   return id;
 };
 const execute$1 = (id, ...args) => {
-  number(id);
+  number$1(id);
   const listener = state$d[id];
   if (!listener) {
     warn$1(`listener with id ${id} not found`);
@@ -12529,7 +12652,7 @@ const getMenuEntries$j = async (id, ...args) => {
 };
 
 const addKeyBindings = menuEntries => {
-  const keyBindings = state$F.matchingKeyBindings;
+  const keyBindings = state$G.matchingKeyBindings;
   const newMenuEntries = [];
   for (const menuEntry of menuEntries) {
     const keyBinding = getCommandKeyBinding(keyBindings, menuEntry.command, menuEntry.args);
@@ -13078,7 +13201,7 @@ const Shift$1 = 1 << 10 >>> 0;
 const Alt$1 = 1 << 9 >>> 0;
 
 const parseKey = rawKey => {
-  number(rawKey);
+  number$1(rawKey);
   const isCtrl = Boolean(rawKey & CtrlCmd);
   const isShift = Boolean(rawKey & Shift$1);
   const keyCode = rawKey & 0x000000ff;
@@ -14472,20 +14595,35 @@ const {
   invokeAndTransfer: invokeAndTransfer$3
 } = getOrCreateWorker(launchTerminalWorker);
 
+const objects = Object.create(null);
+const transferToRendererProcess = async (objectId, transferable) => {
+  await invokeAndTransfer$7('Transferrable.transfer', [transferable], objectId, transferable);
+};
+const transfer = (objectId, transferable) => {
+  number$1(objectId);
+  object(transferable);
+  objects[objectId] = transferable;
+};
+const acquire = objectId => {
+  number$1(objectId);
+  const value = objects[objectId];
+  if (!value) {
+    throw new Error(`transferrable object not found`);
+  }
+  delete objects[objectId];
+  return value;
+};
+
 const create$X = async canvasId => {
-  number(canvasId);
-  const {
-    id,
-    promise
-  } = registerPromise();
+  number$1(canvasId);
+  const id = create$18();
   await invoke$8('OffscreenCanvas.create', canvasId, id);
-  const response = await promise;
-  const canvas = response.params[0];
+  const canvas = acquire(id);
   return canvas;
 };
 const createForTerminal = async (canvasId, callbackId) => {
   const canvas = await create$X(canvasId);
-  await invokeAndTransfer$3([canvas], 'OffscreenCanvas.handleResult', callbackId, canvas);
+  await invokeAndTransfer$3('OffscreenCanvas.handleResult', callbackId, canvas);
 };
 
 const name$18 = 'OffscreenCanvas';
@@ -14552,7 +14690,7 @@ const combineResults$b = results => {
 };
 const executeBraceCompletionProvider = (editor, offset, openingBrace) => {
   object(editor);
-  number(offset);
+  number$1(offset);
   string(openingBrace);
   return execute$2({
     event: OnBraceCompletion,
@@ -14707,7 +14845,7 @@ const ExtensionHostClosingTagCompletion_ipc = {
 const sendMessagePortToRendererProcess = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$7(initialCommand, [port], port);
+  await invokeAndTransfer$7(initialCommand, port);
 };
 
 const name$_ = 'SendMessagePortToRendererProcess';
@@ -14726,7 +14864,7 @@ const combineResults$5 = results => {
 };
 const executeHoverProvider = (editor, offset) => {
   object(editor);
-  number(offset);
+  number$1(offset);
   return execute$2({
     event: OnHover,
     editor,
@@ -14751,7 +14889,7 @@ const ExtensionHostHover_ipc = {
 const sendMessagePortToExtensionHostWorker = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$5([port], initialCommand, port);
+  await invokeAndTransfer$5(initialCommand, port);
 };
 
 const name$Y = 'SendMessagePortToExtensionHostWorker';
@@ -14809,7 +14947,7 @@ const {
 const sendMessagePortToSyntaxHighlightingWorker = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$2([port], initialCommand, port);
+  await invokeAndTransfer$2(initialCommand, port);
 };
 
 const name$W = 'SendMessagePortToSyntaxHighlightingWorker';
@@ -14823,24 +14961,11 @@ const SendMessagePortToSyntaxHighlightingWorker_ipc = {
   name: name$W
 };
 
-const transferToRendererProcess = (objectId, transferable) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  // TODO use invoke and transfer
-  sendAndTransfer({
-    jsonrpc: '2.0',
-    method: 'Transferrable.transfer',
-    params: [objectId, transferable],
-    id
-  }, [transferable]);
-  return promise;
-};
-
 const name$V = 'Transferrable';
 const Commands$L = {
-  transferToRendererProcess: transferToRendererProcess
+  transferToRendererProcess: transferToRendererProcess,
+  transfer: transfer,
+  acquire: acquire
 };
 
 const Transferrable_ipc = {
@@ -17059,7 +17184,7 @@ const handleTokenizeChange$1 = async () => {
       if (!isConnectedEditor(state.id)) {
         return;
       }
-      const tokenizerId = create$1a();
+      const tokenizerId = create$18();
       const tokenizer = getTokenizer(state.languageId);
       set$1(tokenizerId, tokenizer);
       const newState = {
@@ -17192,7 +17317,7 @@ const getListHeight$2 = (height, headerHeight) => {
 };
 const setDeltaY$4 = (state, deltaY) => {
   object(state);
-  number(deltaY);
+  number$1(deltaY);
   const {
     itemHeight,
     items,
@@ -17212,8 +17337,8 @@ const setDeltaY$4 = (state, deltaY) => {
   }
   const minLineY = Math.round(deltaY / itemHeight);
   const maxLineY = minLineY + Math.round(listHeight / itemHeight);
-  number(minLineY);
-  number(maxLineY);
+  number$1(minLineY);
+  number$1(maxLineY);
   return {
     ...state,
     deltaY,
@@ -17223,8 +17348,8 @@ const setDeltaY$4 = (state, deltaY) => {
 };
 const handleWheel$4 = (state, deltaMode, deltaY) => {
   object(state);
-  number(deltaMode);
-  number(deltaY);
+  number$1(deltaMode);
+  number$1(deltaY);
   return setDeltaY$4(state, state.deltaY + deltaY);
 };
 
@@ -17820,7 +17945,7 @@ const executeTest$1 = async state => {
   };
 };
 const handleLoad$1 = async state => {
-  const messagePortId = create$1a();
+  const messagePortId = create$18();
   const {
     port1,
     port2
@@ -18033,7 +18158,7 @@ const executeTest = async (state, index) => {
   };
 };
 const handleLoad = async state => {
-  const messagePortId = create$1a();
+  const messagePortId = create$18();
   const {
     port1,
     port2
@@ -18251,8 +18376,8 @@ const ViewletE2eTests_ipc = {
  */
 const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError) => {
   object(editor);
-  number(rowIndex);
-  number(columnIndex);
+  number$1(rowIndex);
+  number$1(columnIndex);
   string(message);
   const x$1 = x(editor, rowIndex, columnIndex);
   // @ts-ignore
@@ -18457,9 +18582,9 @@ const filterCompletionItems = (completionItems, word) => {
 };
 
 const getListHeight$1 = (itemsLength, itemHeight, maxHeight) => {
-  number(itemsLength);
-  number(itemHeight);
-  number(maxHeight);
+  number$1(itemsLength);
+  number$1(itemHeight);
+  number$1(maxHeight);
   if (itemsLength === 0) {
     return itemHeight;
   }
@@ -19165,8 +19290,8 @@ const dispose$q = async state => {
 };
 const handlePointerDown$1 = (state, pointerId, x, y) => {
   object(state);
-  number(x);
-  number(y);
+  number$1(x);
+  number$1(y);
   const {
     eventCache
   } = state;
@@ -19289,8 +19414,8 @@ const moveDown = state => {
 };
 const handlePointerMove = (state, pointerId, x, y) => {
   object(state);
-  number(x);
-  number(y);
+  number$1(x);
+  number$1(y);
   const {
     eventCache
   } = state;
@@ -19793,7 +19918,7 @@ const ViewletEditorSourceActions_ipc = {
 // TODO this should be in a separate scrolling module
 const setDeltaY$3 = (state, value) => {
   object(state);
-  number(value);
+  number$1(value);
   const {
     finalDeltaY,
     deltaY,
@@ -19834,12 +19959,12 @@ const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, l
     return 0;
   }
   string(line);
-  number(tabSize);
-  number(halfCursorWidth);
-  number(width);
+  number$1(tabSize);
+  number$1(halfCursorWidth);
+  number$1(width);
   boolean(isMonospaceFont);
-  number(averageCharWidth);
-  number(difference);
+  number$1(averageCharWidth);
+  number$1(difference);
   if (column === 0) {
     return 0;
   }
@@ -20121,7 +20246,7 @@ const handleTokenizeChange = () => {
   }
   const state = instance.state;
   const tokenizer = getTokenizer(state.languageId);
-  const tokenizerId = create$1a();
+  const tokenizerId = create$18();
   set$1(tokenizerId, tokenizer);
   const newState = {
     ...instance.state,
@@ -20194,7 +20319,7 @@ const loadContent$z = async (state, savedState, context) => {
   const content = await getContent(uri);
   const languageId = getLanguageId(state);
   const tokenizer = getTokenizer(languageId);
-  const tokenizerId = create$1a();
+  const tokenizerId = create$18();
   set$1(tokenizerId, tokenizer);
   let savedSelections = getSavedSelections(savedState);
   const savedDeltaY = getSavedDeltaY(savedState);
@@ -21074,7 +21199,7 @@ const getTopLevelDirents = (root, pathSeparator, excluded) => {
 // TODO instead of root string, there should be a root dirent
 
 const create$x = (id, uri, x, y, width, height, args, parentUid) => {
-  number(id);
+  number$1(id);
   return {
     uid: id,
     parentUid,
@@ -25061,8 +25186,8 @@ const manyResultsInManyFiles$1 = (resultCount, fileCount) => {
 };
 
 const getMessage$1 = (resultCount, fileCount) => {
-  number(resultCount);
-  number(fileCount);
+  number$1(resultCount);
+  number$1(fileCount);
   if (resultCount === 0) {
     return noResults$2();
   }
@@ -25762,7 +25887,7 @@ const loadContent$q = async (state, savedState) => {
     searchHeaderHeight,
     tableHeaderHeight
   } = state;
-  number(width);
+  number$1(width);
   const keyBindings = await getKeyBindings$l();
   const parsedKeyBindings = parseKeyBindings(keyBindings);
   const maxVisibleItems = getMaxVisibleItems(height, searchHeaderHeight, tableHeaderHeight, rowHeight);
@@ -26753,7 +26878,7 @@ const getPoints = (source, destination, sideBarLocation = Right$1) => {
   }
 };
 const create$p = id => {
-  number(id);
+  number$1(id);
   return {
     points: new Uint16Array(Total),
     sideBarViewletId: '',
@@ -26862,7 +26987,7 @@ const show$4 = async (state, module, currentViewletId) => {
   const width = newPoints[kWidth];
   const height = newPoints[kHeight];
   const uid = state.uid;
-  const childUid = create$1a();
+  const childUid = create$18();
   const commands = await load$7({
     getModule: load$5,
     id: moduleId,
@@ -27020,7 +27145,7 @@ const loadIfVisible = async (state, module) => {
     let commands = [];
     const parentUid = state.uid;
     if (visible) {
-      const childUid = create$1a();
+      const childUid = create$18();
       commands = await load$7({
         getModule: load$5,
         id: moduleId,
@@ -27182,10 +27307,10 @@ const getResizeCommands = (oldPoints, newPoints) => {
       const newLeft = newPoints[kLeft];
       const newWidth = newPoints[kWidth];
       const newHeight = newPoints[kHeight];
-      number(newTop);
-      number(newLeft);
-      number(newWidth);
-      number(newHeight);
+      number$1(newTop);
+      number$1(newLeft);
+      number$1(newWidth);
+      number$1(newHeight);
       const resizeCommands = resize$n(instanceUid, {
         x: newLeft,
         y: newTop,
@@ -27212,7 +27337,7 @@ const getFocusChangeCommands = isFocused => {
 };
 const showAsync = async (uid, points, module) => {
   try {
-    number(uid);
+    number$1(uid);
     const {
       moduleId,
       kTop,
@@ -27220,7 +27345,7 @@ const showAsync = async (uid, points, module) => {
       kWidth,
       kHeight
     } = module;
-    const viewletUid = create$1a();
+    const viewletUid = create$18();
     const commands = await load$7({
       getModule: load$5,
       id: moduleId,
@@ -27249,7 +27374,7 @@ const showAsync = async (uid, points, module) => {
   }
 };
 const showPlaceholder = (uid, points, module) => {
-  number(uid);
+  number$1(uid);
   const {
     moduleId,
     kTop,
@@ -28108,13 +28233,13 @@ const deserializeEditorGroups = (savedState, state) => {
     }
     const restoredEditors = group.editors.filter(canBeRestored);
     for (const editor of restoredEditors) {
-      editor.uid = create$1a();
+      editor.uid = create$18();
       const label = editor.label;
       editor.tabWidth = measureTabWidth(label, tabFontWeight, tabFontSize, tabFontFamily, tabLetterSpacing);
     }
     const restoredGroup = {
       ...group,
-      tabsUid: create$1a()
+      tabsUid: create$18()
     };
     restoredGroups.push(restoredGroup);
   }
@@ -28199,8 +28324,8 @@ const getSplitOverlayDimensions = (x, y, width, height, splitDirection) => {
 
 const getTabIndex = (tabs, x, eventX) => {
   array(tabs);
-  number(x);
-  number(eventX);
+  number$1(x);
+  number$1(eventX);
   const relativeX = eventX - x;
   let total = 0;
   for (let i = 0; i < tabs.length; i++) {
@@ -28353,7 +28478,7 @@ const ViewletMainCloseAllEditors = {
 
 const closeEditor = (state, index) => {
   object(state);
-  number(index);
+  number$1(index);
   const {
     groups,
     activeGroupIndex
@@ -28470,7 +28595,7 @@ const focusIndex$6 = async (state, index) => {
   // @ts-ignore
   getInstance(oldId);
   const previousUid = oldEditor.uid;
-  number(previousUid);
+  number$1(previousUid);
   const disposeCommands = disposeFunctional(previousUid);
   const maybeHiddenEditorInstance = getInstance(editor.uid);
   if (maybeHiddenEditorInstance) {
@@ -28481,7 +28606,7 @@ const focusIndex$6 = async (state, index) => {
       commands: allCommands
     };
   }
-  const instanceUid = create$1a();
+  const instanceUid = create$18();
   const instance = create$17(load$5, id, uid, editor.uri, x, y, width, contentHeight);
   instance.show = false;
   instance.setBounds = false;
@@ -28551,9 +28676,9 @@ const getIsCloseButton = (tabs, index, eventX, x) => {
   return -offset < closeButtonWidth;
 };
 const handleTabClick = (state, button, eventX, eventY) => {
-  number(button);
-  number(eventX);
-  number(eventY);
+  number$1(button);
+  number$1(eventX);
+  number$1(eventY);
   const {
     groups,
     activeGroupIndex
@@ -28615,11 +28740,11 @@ const openUri = async (state, uri, focus = true, {
   const moduleId = getModuleId(uri);
   let activeGroup = groups[activeGroupIndex];
   activeGroup ||= {
-    uid: create$1a(),
+    uid: create$18(),
     editors: [],
     activeIndex: -1,
     focusedIndex: -1,
-    tabsUid: create$1a(),
+    tabsUid: create$18(),
     x,
     y: 0,
     width,
@@ -28649,7 +28774,7 @@ const openUri = async (state, uri, focus = true, {
     const previousUid = previousEditor.uid;
     disposeCommands = hideFunctional(previousUid);
   }
-  const instanceUid = create$1a();
+  const instanceUid = create$18();
   const instance = create$17(load$5, moduleId, state.uid, uri, x, y, width, contentHeight);
   instance.uid = instanceUid;
   // const oldActiveIndex = state.activeIndex
@@ -28691,7 +28816,7 @@ const openUri = async (state, uri, focus = true, {
   commands.push(['Viewlet.setBounds', instanceUid, x, state.tabHeight, width, contentHeight]);
   let tabsUid = state.tabsUid;
   if (tabsUid === -1) {
-    tabsUid = create$1a();
+    tabsUid = create$18();
   }
   if (disposeCommands) {
     commands.push(...disposeCommands);
@@ -28810,7 +28935,7 @@ const getRestoredGroups = (savedState, state) => {
         height,
         editors: [],
         tabsUid: 0,
-        uid: create$1a()
+        uid: create$18()
       }],
       activeGroupIndex: 0
     };
@@ -28825,7 +28950,7 @@ const getRestoredGroups = (savedState, state) => {
         height,
         editors: [],
         tabsUid: 0,
-        uid: create$1a()
+        uid: create$18()
       }],
       activeGroupIndex: 0
     };
@@ -28840,7 +28965,7 @@ const getRestoredGroups = (savedState, state) => {
         height,
         editors: [],
         tabsUid: 0,
-        uid: create$1a()
+        uid: create$18()
       }],
       activeGroupIndex: 0
     };
@@ -29009,7 +29134,7 @@ const contentLoaded$5 = async state => {
     editor.title = tabTitle;
     const childUid = editor.uid;
     commands.push(['Viewlet.setBounds', childUid, editorX, state.tabHeight, editorWidth, editorHeight]);
-    const tabsUid = create$1a();
+    const tabsUid = create$18();
     state.tabsUid = tabsUid;
     // commands.push(['Viewlet.create', ViewletModuleId.MainTabs, tabsUid])
     // commands.push(['Viewlet.send', tabsUid, 'setTabs', state.editors])
@@ -29586,7 +29711,7 @@ const resize$f = (state, dimensions) => {
     const editor = editors[activeIndex];
     if (editor) {
       const editorUid = editor.uid;
-      number(editorUid);
+      number$1(editorUid);
       const resizeCommands = resize$n(editorUid, childDimensions);
       commands.push(...resizeCommands);
       commands.push(['Viewlet.setBounds', editorUid, dimensions.x, tabHeight, dimensions.width, contentHeight]);
@@ -29922,7 +30047,7 @@ const getId$1 = state => {
 };
 const handleClickAction = async (state, index, command) => {
   object(state);
-  number(index);
+  number$1(index);
   string(command);
   if (command === 'undefined') {
     throw new Error(`command is undefined`);
@@ -30053,7 +30178,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
   if (commands) {
     const currentViewletState = getState$1(currentViewletId);
     const currentViewletUid = currentViewletState.uid;
-    number(currentViewletUid);
+    number$1(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
     await invoke$8('Viewlet.sendMultiple', commands);
     if (commands.at(-1).includes(Error$2)) {
@@ -31077,7 +31202,7 @@ const getIcon = uri => {
 const getVisibleProblems = (problems, collapsedUris, focusedIndex, filterValue) => {
   array(problems);
   array(collapsedUris);
-  number(focusedIndex);
+  number$1(focusedIndex);
   string(filterValue);
   const visibleItems = [];
   const filterValueLength = filterValue.length;
@@ -31677,7 +31802,7 @@ const handleBlur$1 = async state => {
 };
 const getPick = (items, index) => {
   array(items);
-  number(index);
+  number$1(index);
   // if (index < state.recentPicks.length) {
   //   return state.recentPicks[index]
   // }
@@ -32046,12 +32171,12 @@ const getLineText = (content, startRowIndex, startColumnIndex, endRowIndex, endC
     if (rowIndex++ >= startRowIndex) {
       break;
     }
-    newLineIndex = getNewLineIndex(content, newLineIndex + 1);
+    newLineIndex = getNewLineIndex$1(content, newLineIndex + 1);
   }
-  if (content[newLineIndex] === NewLine) {
+  if (content[newLineIndex] === NewLine$1) {
     newLineIndex++;
   }
-  let nextIndex = getNewLineIndex(content, newLineIndex);
+  let nextIndex = getNewLineIndex$1(content, newLineIndex);
   if (nextIndex === -1) {
     nextIndex = content.length;
   }
@@ -32554,7 +32679,7 @@ const getScopeChain = (params, thisObject, scopeChain, knownProperties) => {
     // if(params.reason)
     if (scope.type === Local) {
       if (params.reason === Exception$2) {
-        const value = params.data.description.replaceAll(NewLine, Space$2);
+        const value = params.data.description.replaceAll(NewLine$1, Space$2);
         elements.push({
           type: Exception$1,
           key: 'Exception',
@@ -33738,12 +33863,12 @@ const getSources = async options => {
 };
 
 const getUserMedia = async (captureId, options) => {
-  number(captureId);
+  number$1(captureId);
   object(options);
   await invoke$8('ScreenCapture.start', captureId, options);
 };
 const dispose$9 = async captureId => {
-  number(captureId);
+  number$1(captureId);
   await invoke$8('ScreenCapture.dispose', captureId);
 };
 
@@ -33784,7 +33909,7 @@ const create$f = (id, uri) => {
   };
 };
 const loadContent$f = async state => {
-  const captureId = create$1a();
+  const captureId = create$18();
   await createScreenCaptureStream(captureId);
   return {
     ...state,
@@ -33961,8 +34086,8 @@ const confirmReplaceManyOccurrencesInOneFileNoValue = matchCount => {
   });
 };
 const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replacement) => {
-  number(matchCount);
-  number(fileCount);
+  number$1(matchCount);
+  number$1(fileCount);
   string(replacement);
   return i18nString(UiStrings$6.ConfirmReplaceManyOccurrencesInManyFiles, {
     PH1: matchCount,
@@ -33971,8 +34096,8 @@ const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replace
   });
 };
 const confirmReplaceManyOccurrencesInManyFilesNoValue = (matchCount, fileCount) => {
-  number(matchCount);
-  number(fileCount);
+  number$1(matchCount);
+  number$1(fileCount);
   return i18nString(UiStrings$6.ConfirmReplaceManyOccurrencesInManyFilesNoValue, {
     PH1: matchCount,
     PH2: fileCount
@@ -34025,8 +34150,8 @@ const collapseAll = () => {
 };
 
 const getStatusMessage = (resultCount, fileResultCount) => {
-  number(resultCount);
-  number(fileResultCount);
+  number$1(resultCount);
+  number$1(fileResultCount);
   if (resultCount === 0) {
     return noResults();
   }
@@ -35022,7 +35147,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
   if (commands) {
     const currentViewletState = getState$1(currentViewletId);
     const currentViewletUid = currentViewletState.uid;
-    number(currentViewletUid);
+    number$1(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
     const activityBar = getInstance(ActivityBar$5);
     if (activityBar) {
@@ -35371,7 +35496,7 @@ const backgroundLoadContent = async (state, savedState) => {
   const fallThroughKeyBindings = getFallThroughKeyBindings(keyBindings);
   const browserViewId = await createWebContentsView(0);
   await setFallthroughKeyBindings(fallThroughKeyBindings);
-  number(browserViewId);
+  number$1(browserViewId);
   await resizeWebContentsView(browserViewId, x, y + headerHeight, width, height - headerHeight);
   const {
     newTitle
@@ -35430,7 +35555,7 @@ const loadContent$c = async (state, savedState) => {
   const browserViewId = await createWebContentsView( /* restoreId */0, uid);
   await setFallthroughKeyBindings(fallThroughKeyBindings);
   await resizeWebContentsView(browserViewId, browserViewX, browserViewY, browserViewWidth, browserViewHeight);
-  number(browserViewId);
+  number$1(browserViewId);
   await setIframeSrc(browserViewId, iframeSrc);
   const {
     title,
@@ -36910,7 +37035,7 @@ const getTerminalSpawnOptions = () => {
 // TODO implement a functional terminal component, maybe using offscreencanvas
 
 const create$8 = id => {
-  number(id);
+  number$1(id);
   const separateConnection = true;
   return {
     disposed: false,
@@ -36931,8 +37056,8 @@ const loadContent$8 = async state => {
     command,
     args
   } = await getTerminalSpawnOptions();
-  const canvasTextId = create$1a();
-  const canvasCursorId = create$1a();
+  const canvasTextId = create$18();
+  const canvasCursorId = create$18();
   await invoke$4('Terminal.create', canvasTextId, canvasCursorId, uid, state$B.workspacePath, command, args);
   const terminal = {
     handleBlur() {
@@ -36950,7 +37075,7 @@ const loadContent$8 = async state => {
   };
   return {
     ...state,
-    id: create$1a(),
+    id: create$18(),
     command,
     args,
     canvasCursorId,
@@ -37088,7 +37213,7 @@ const ViewletTerminal_ipc = {
 };
 
 const create$7 = (id, uri, x, y, width, height) => {
-  number(id);
+  number$1(id);
   return {
     disposed: false,
     uid: id,
@@ -37127,7 +37252,7 @@ const loadContent$7 = async state => {
     tabs: [{
       label: 'tab 1',
       icon: 'Terminal',
-      uid: create$1a()
+      uid: create$18()
     }],
     selectedIndex: 0,
     terminalTabsEnabled
@@ -37143,7 +37268,7 @@ const addTerminal = async state => {
     uid,
     selectedIndex
   } = state;
-  const childUid = create$1a();
+  const childUid = create$18();
   const newTab = {
     label: `tab ${tabs.length + 1}`,
     icon: 'Terminal',
@@ -37179,7 +37304,7 @@ const addTerminal = async state => {
 };
 const focusIndex$4 = async (state, index) => {
   object(state);
-  number(index);
+  number$1(index);
   const {
     tabs,
     x,
@@ -37189,7 +37314,7 @@ const focusIndex$4 = async (state, index) => {
     uid,
     selectedIndex
   } = state;
-  const childUid = create$1a();
+  const childUid = create$18();
   const newTab = tabs[index];
   newTab.uid = childUid;
   const commands = await load$7({
@@ -37261,11 +37386,11 @@ const createTabDom = (tab, isSelected) => {
   }, 0), text(label)];
 };
 const getTerminalTabsDom = (tabs, x, y, width, height, selectedIndex) => {
-  number(x);
-  number(y);
-  number(width);
-  number(height);
-  number(selectedIndex);
+  number$1(x);
+  number$1(y);
+  number$1(width);
+  number$1(height);
+  number$1(selectedIndex);
   const dom = [div({
     className: TerminalTabs,
     left: x,
@@ -37921,7 +38046,7 @@ const getTitleBarMenuBarVirtualDom = visibleItems => {
 
 const getVisibleTitleBarEntries = (entries, width, focusedIndex, isMenuOpen) => {
   array(entries);
-  number(width);
+  number$1(width);
   let total = 0;
   const visible = [];
   for (let i = 0; i < entries.length; i++) {
@@ -38294,7 +38419,7 @@ const loadContent = async state => {
     port1,
     port2
   } = getPortTuple();
-  const portId = create$1a();
+  const portId = create$18();
   await transferToRendererProcess(portId, port1);
   // TODO figure out order for events, e.g.
   // 1. activate extension, create webview and ports in parallel
@@ -38302,7 +38427,7 @@ const loadContent = async state => {
   // 3. setup extension host worker rpc
   // 4. create webview in extension host worker and load content
 
-  invokeAndTransfer$5([port2], 'ExtensionHostWebView.create', webViewId, port2);
+  invokeAndTransfer$5('ExtensionHostWebView.create', webViewId, port2);
   let origin = '';
   if (platform === Remote) {
     // TODO apply something similar for electron
@@ -39270,7 +39395,7 @@ const ViewletActivityBarHandleContextMenu = {
 
 const setDeltaY = (state, value) => {
   object(state);
-  number(value);
+  number$1(value);
   const {
     itemHeight,
     finalDeltaY,
@@ -39300,8 +39425,8 @@ const VirtualListSetDeltaY = {
 };
 
 const handleWheel = (state, deltaMode, deltaY) => {
-  number(deltaMode);
-  number(deltaY);
+  number$1(deltaMode);
+  number$1(deltaY);
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
@@ -39351,7 +39476,7 @@ const focusIndex$3 = (state, index) => {
   if (itemsLength === 0) {
     return state;
   }
-  number(itemHeight);
+  number$1(itemHeight);
   if (index === -1) {
     return {
       ...state,
@@ -39524,7 +39649,7 @@ const VirtualListHandleTouchEnd = {
 };
 
 const handleTouchMove = (state, timeStamp, touches) => {
-  number(timeStamp);
+  number$1(timeStamp);
   array(touches);
   if (touches.length === 0) {
     return state;
@@ -39537,7 +39662,7 @@ const handleTouchMove = (state, timeStamp, touches) => {
   const {
     y
   } = touch;
-  number(y);
+  number$1(y);
   const newTouchOffsetY = y;
   const touchDifference = newTouchOffsetY - touchOffsetY;
   const newDeltaY = deltaY - touchDifference;
@@ -39554,7 +39679,7 @@ const VirtualListHandleTouchMove = {
 };
 
 const handleTouchStart = (state, timeStamp, touches) => {
-  number(timeStamp);
+  number$1(timeStamp);
   array(touches);
   if (touches.length === 0) {
     return state;
@@ -39563,7 +39688,7 @@ const handleTouchStart = (state, timeStamp, touches) => {
   const {
     y
   } = touch;
-  number(y);
+  number$1(y);
   return {
     ...state,
     touchOffsetY: y
@@ -39936,8 +40061,8 @@ const ViewletExplorerHandleContextMenuKeyboard = {
 };
 
 const handleContextMenuMouseAt$1 = async (state, x, y) => {
-  number(x);
-  number(y);
+  number$1(x);
+  number$1(y);
   const focusedIndex = getIndexFromPosition(state, x, y);
   await show$a(x, y, Explorer$2);
   return {
@@ -40007,8 +40132,8 @@ const getNewDropTargets = (state, x, y) => {
   return newDropTargets;
 };
 const handleDragOver = (state, x, y) => {
-  number(x);
-  number(y);
+  number$1(x);
+  number$1(y);
   const {
     dropTargets
   } = state;
@@ -40692,8 +40817,8 @@ const replaceAllAndPrompt = async (workspacePath, items, replacement, matchCount
   string(workspacePath);
   array(items);
   string(replacement);
-  number(matchCount);
-  number(fileCount);
+  number$1(matchCount);
+  number$1(fileCount);
   const confirmTitle = replaceAll$2();
   const confirmAccept = replace();
   const confirmText = getReplaceAllConfirmText(matchCount, fileCount, replacement);
@@ -40875,7 +41000,7 @@ const closeOthers = async state => {
     newActiveIndex = 0;
     const disposeCommands = disposeFunctional(activeEditor.uid);
     commands.push(...disposeCommands);
-    const instanceUid = create$1a();
+    const instanceUid = create$18();
     const moduleId = getModuleId(activeEditor.uri);
     // @ts-ignore
     const x = state.x;
@@ -41161,9 +41286,9 @@ const handleDropFilePathSplit = async (state, eventX, eventY, filePath, splitDir
   }];
   const uri = filePath;
   const id = EditorText;
-  create$1a();
+  create$18();
   // @ts-ignore
-  create$1a();
+  create$18();
   create$17(load$5, id, state.uid, uri, overlayX, overlayY, overlayWidth, overlayHeight);
   // const sashGridItem = {
   //   x: sashX,
@@ -41195,12 +41320,12 @@ const handleDropFilePathSplit = async (state, eventX, eventY, filePath, splitDir
         label: pathBaseName(filePath),
         tabWidth: 100,
         title: pathBaseName(filePath),
-        uid: create$1a(),
+        uid: create$18(),
         uri: filePath
       }],
       height: 530,
-      tabsUid: create$1a(),
-      uid: create$1a(),
+      tabsUid: create$18(),
+      uid: create$18(),
       width: oldGroup.width / 2,
       x: oldGroup.width / 2,
       y: 0
@@ -41263,8 +41388,8 @@ const handleDropFilePath = async (state, eventX, eventY, filePath) => {
     filePath
   });
   object(state);
-  number(eventX);
-  number(eventY);
+  number$1(eventX);
+  number$1(eventY);
   string(filePath);
   const {
     x,
@@ -41356,7 +41481,7 @@ const splitRight = state => {
   const contentHeight = height - tabHeight;
   if (editor) {
     const editorUid = editor.uid;
-    number(editorUid);
+    number$1(editorUid);
     const resizeCommands = resize$n(editorUid, dimensions);
     commands.push(...resizeCommands);
     commands.push(['Viewlet.setBounds', editorUid, dimensions.x, tabHeight, dimensions.width, contentHeight]);
@@ -41403,8 +41528,8 @@ const getNewTabsDeltaX = (width, tabs, tabsDeltaX, deltaX) => {
   return newDeltaX;
 };
 const handleTabsWheel = (state, deltaX, deltaY) => {
-  number(deltaX);
-  number(deltaY);
+  number$1(deltaX);
+  number$1(deltaY);
   const {
     groups,
     activeGroupIndex,
@@ -41436,8 +41561,8 @@ const ViewletMainHandleTabsWheel = {
 };
 
 const handleTabsPointerOver = (state, eventX, eventY) => {
-  number(eventX);
-  number(eventY);
+  number$1(eventX);
+  number$1(eventY);
   const {
     groups,
     activeGroupIndex
@@ -41477,8 +41602,8 @@ const ViewletMainHandleTabsPointerOver = {
 };
 
 const handleTabsPointerOut = (state, eventX, eventY) => {
-  number(eventX);
-  number(eventY);
+  number$1(eventX);
+  number$1(eventY);
   return {
     ...state
   };
@@ -41490,8 +41615,8 @@ const ViewletMainHandleTabsPointerOut = {
 };
 
 const handleContextMenu$4 = async (state, x, y) => {
-  number(x);
-  number(y);
+  number$1(x);
+  number$1(y);
   await show$a(x, y, Main$2);
   return state;
 };
@@ -42484,8 +42609,8 @@ const getNewValue = (value, inputType, data, selectionStart, selectionEnd) => {
 
 const handleBeforeInput = (state, inputType, data, selectionStart, selectionEnd) => {
   string(inputType);
-  number(selectionStart);
-  number(selectionEnd);
+  number$1(selectionStart);
+  number$1(selectionEnd);
   const {
     value
   } = state;
@@ -43363,7 +43488,7 @@ const handleClickFile = async (state, item) => {
   const absolutePath = `${root}/${item.file}`;
   // TODO handle error
   const [fileBefore] = await Promise.all([getFileBefore(providerId, item.file), readFile$e(absolutePath)]);
-  if (get$g().width < inlineDiffEditorBreakpoint) {
+  if (get$h().width < inlineDiffEditorBreakpoint) {
     await execute$4('Main.openUri', `inline-diff://data://${fileBefore}<->${absolutePath}`);
   } else {
     await execute$4('Main.openUri', `diff://data://${fileBefore}<->${absolutePath}`);
@@ -43607,7 +43732,7 @@ const openMenuAtIndex = async (state, index, shouldBeFocused) => {
 
 const focusIndex = (state, index) => {
   object(state);
-  number(index);
+  number$1(index);
   const {
     isMenuOpen
   } = state;
@@ -44028,8 +44153,8 @@ const ViewletTitleBarMenuBarHandleMenuClick = {
 
 const handleMenuMouseOver = async (state, level, index) => {
   object(state);
-  number(level);
-  number(index);
+  number$1(level);
+  number$1(index);
   const {
     menus
   } = state;