@lvce-editor/cache-worker 0.1.3 → 0.2.0

package/cacheWorkerMain.js

@@ -1,27 +1,20 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// node_modules/@lvce-editor/ipc/dist/index.js
-var isMessagePort = (value) => {
+const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
-var isMessagePortMain = (value) => {
-  return value && value.constructor && value.constructor.name === "MessagePortMain";
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-var isOffscreenCanvas = (value) => {
-  return typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas;
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-var isInstanceOf = (value, constructorName) => {
+const isInstanceOf = (value, constructorName) => {
   return value?.constructor?.name === constructorName;
 };
-var isSocket = (value) => {
-  return isInstanceOf(value, "Socket");
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
 };
-var transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-var isTransferrable = (value) => {
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
   for (const fn of transferrables) {
     if (fn(value)) {
       return true;
@@ -29,64 +22,64 @@ var isTransferrable = (value) => {
   }
   return false;
 };
-var walkValue = (value, transferrables2, isTransferrable2) => {
+const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
   }
-  if (isTransferrable2(value)) {
-    transferrables2.push(value);
+  if (isTransferrable(value)) {
+    transferrables.push(value);
     return;
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue(item, transferrables2, isTransferrable2);
+      walkValue(item, transferrables, isTransferrable);
     }
     return;
   }
-  if (typeof value === "object") {
+  if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue(property, transferrables2, isTransferrable2);
+      walkValue(property, transferrables, isTransferrable);
     }
   }
 };
-var getTransferrables = (value) => {
-  const transferrables2 = [];
-  walkValue(value, transferrables2, isTransferrable);
-  return transferrables2;
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
 };
-var attachEvents = (that) => {
-  const handleMessage2 = (...args) => {
+const attachEvents = that => {
+  const handleMessage = (...args) => {
     const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent("message", {
+    that.dispatchEvent(new MessageEvent('message', {
       data
     }));
   };
-  that.onMessage(handleMessage2);
-  const handleClose = (event) => {
-    that.dispatchEvent(new Event("close"));
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
   };
   that.onClose(handleClose);
 };
-var Ipc = class extends EventTarget {
+class Ipc extends EventTarget {
   constructor(rawIpc) {
     super();
     this._rawIpc = rawIpc;
     attachEvents(this);
   }
-};
-var readyMessage = "ready";
-var getData$2 = (event) => {
+}
+const readyMessage = 'ready';
+const getData$2 = event => {
   return event.data;
 };
-var listen$8 = ({
+const listen$8 = ({
   port
 }) => {
   return port;
 };
-var signal$9 = (port) => {
+const signal$9 = port => {
   port.postMessage(readyMessage);
 };
-var IpcChildWithMessagePort = class extends Ipc {
+class IpcChildWithMessagePort extends Ipc {
   getData(event) {
     return getData$2(event);
   }
@@ -98,76 +91,82 @@ var IpcChildWithMessagePort = class extends Ipc {
     this._rawIpc.postMessage(message, transfer);
   }
   dispose() {
+    // ignore
   }
   onClose(callback) {
+    // ignore
   }
   onMessage(callback) {
-    this._rawIpc.addEventListener("message", callback);
+    this._rawIpc.addEventListener('message', callback);
     this._rawIpc.start();
   }
-};
-var wrap$g = (port) => {
+}
+const wrap$g = port => {
   return new IpcChildWithMessagePort(port);
 };
-var IpcChildWithMessagePort$1 = {
+const IpcChildWithMessagePort$1 = {
   __proto__: null,
   listen: listen$8,
   signal: signal$9,
   wrap: wrap$g
 };
-var listen$7 = () => {
-  if (typeof WorkerGlobalScope === "undefined") {
-    throw new TypeError("module is not in web worker scope");
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-var signal$8 = (global) => {
+const signal$8 = global => {
   global.postMessage(readyMessage);
 };
-var IpcChildWithModuleWorker = class extends Ipc {
+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);
+    this._rawIpc.addEventListener('message', callback);
   }
-};
-var wrap$f = (global) => {
+}
+const wrap$f = global => {
   return new IpcChildWithModuleWorker(global);
 };
-var IpcChildWithModuleWorker$1 = {
+const IpcChildWithModuleWorker$1 = {
   __proto__: null,
   listen: listen$7,
   signal: signal$8,
   wrap: wrap$f
 };
 
-// node_modules/@lvce-editor/command/dist/index.js
-var CommandNotFoundError = class extends Error {
+class CommandNotFoundError extends Error {
   constructor(command) {
     super(`Command not found ${command}`);
-    this.name = "CommandNotFoundError";
+    this.name = 'CommandNotFoundError';
   }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
 };
-var commands = /* @__PURE__ */ Object.create(null);
-var register = (commandMap2) => {
-  Object.assign(commands, commandMap2);
-};
-var getCommand = (key) => {
+const getCommand = key => {
   return commands[key];
 };
-var execute = (command, ...args) => {
+const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -175,27 +174,26 @@ var execute = (command, ...args) => {
   return fn(...args);
 };
 
-// node_modules/@lvce-editor/json-rpc/dist/index.js
-var Two = "2.0";
-var callbacks = /* @__PURE__ */ Object.create(null);
-var get = (id2) => {
-  return callbacks[id2];
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
+const get = id => {
+  return callbacks[id];
 };
-var remove = (id2) => {
-  delete callbacks[id2];
+const remove = id => {
+  delete callbacks[id];
 };
-var JsonRpcError = class extends Error {
+class JsonRpcError extends Error {
   constructor(message) {
     super(message);
-    this.name = "JsonRpcError";
-  }
-};
-var NewLine = "\n";
-var DomException = "DOMException";
-var ReferenceError$1 = "ReferenceError";
-var SyntaxError$1 = "SyntaxError";
-var TypeError$1 = "TypeError";
-var getErrorConstructor = (message, type) => {
+    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:
@@ -210,26 +208,26 @@ var getErrorConstructor = (message, type) => {
         return Error;
     }
   }
-  if (message.startsWith("TypeError: ")) {
+  if (message.startsWith('TypeError: ')) {
     return TypeError;
   }
-  if (message.startsWith("SyntaxError: ")) {
+  if (message.startsWith('SyntaxError: ')) {
     return SyntaxError;
   }
-  if (message.startsWith("ReferenceError: ")) {
+  if (message.startsWith('ReferenceError: ')) {
     return ReferenceError;
   }
   return Error;
 };
-var constructError = (message, type, name) => {
+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") {
-      Object.defineProperty(error, "name", {
+    if (name && name !== 'VError') {
+      Object.defineProperty(error, 'name', {
         configurable: true,
         value: name
       });
@@ -238,33 +236,33 @@ var constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-var joinLines = (lines) => {
+const joinLines = lines => {
   return lines.join(NewLine);
 };
-var splitLines = (lines) => {
+const splitLines = lines => {
   return lines.split(NewLine);
 };
-var getCurrentStack = () => {
+const getCurrentStack = () => {
   const stackLinesToSkip = 3;
-  const currentStack = joinLines(splitLines(new Error().stack || "").slice(stackLinesToSkip));
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-var getNewLineIndex = (string2, startIndex) => {
+const getNewLineIndex = (string, startIndex) => {
   {
-    return string2.indexOf(NewLine);
+    return string.indexOf(NewLine);
   }
 };
-var getParentStack = (error) => {
-  let parentStack = error.stack || error.data || error.message || "";
-  if (parentStack.startsWith("    at")) {
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
     parentStack = error.message + NewLine + parentStack;
   }
   return parentStack;
 };
-var MethodNotFound = -32601;
-var Custom = -32001;
-var setStack = (error, stack) => {
-  const descriptor = Object.getOwnPropertyDescriptor(error, "stack");
+const MethodNotFound = -32601;
+const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
   if (descriptor) {
     if (!descriptor.configurable && !descriptor.writable) {
       return;
@@ -274,19 +272,19 @@ var setStack = (error, stack) => {
       return;
     }
   }
-  Object.defineProperty(error, "stack", {
+  Object.defineProperty(error, 'stack', {
     configurable: true,
     value: stack,
     writable: true
   });
 };
-var restoreExistingError = (error, currentStack) => {
-  if (typeof error.stack === "string") {
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
     setStack(error, `${error.stack}${NewLine}${currentStack}`);
   }
   return error;
 };
-var restoreMethodNotFoundError = (error, currentStack) => {
+const restoreMethodNotFoundError = (error, currentStack) => {
   const restoredError = new JsonRpcError(error.message);
   Object.assign(restoredError, {
     code: error.code
@@ -295,7 +293,7 @@ var restoreMethodNotFoundError = (error, currentStack) => {
   setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
   return restoredError;
 };
-var restoreStackFromData = (restoredError, error, currentStack) => {
+const restoreStackFromData = (restoredError, error, currentStack) => {
   if (error.data.stack && error.data.type && error.message) {
     setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
     return;
@@ -304,37 +302,42 @@ var restoreStackFromData = (restoredError, error, currentStack) => {
     setStack(restoredError, error.data.stack);
   }
 };
-var applyDataProperties = (restoredError, error) => {
+const applyDataProperties = (restoredError, error) => {
   restoreStackFromData(restoredError, error, getCurrentStack());
   if (error.data.codeFrame) {
+    // @ts-ignore
     restoredError.codeFrame = error.data.codeFrame;
   }
-  if (typeof error.data.code === "string" || typeof error.data.code === "number") {
-    Object.defineProperty(restoredError, "code", {
+  if (typeof error.data.code === 'string' || typeof error.data.code === 'number') {
+    // @ts-ignore
+    Object.defineProperty(restoredError, 'code', {
       configurable: true,
       value: error.data.code,
       writable: true
     });
   }
   if (error.data.type) {
+    // @ts-ignore
     restoredError.name = error.data.type;
   }
 };
-var applyDirectProperties = (restoredError, error) => {
+const applyDirectProperties = (restoredError, error) => {
   if (error.stack) {
-    const lowerStack = restoredError.stack || "";
+    const lowerStack = restoredError.stack || '';
     const indexNewLine = getNewLineIndex(lowerStack);
     const parentStack = getParentStack(error);
+    // @ts-ignore
     setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
   }
   if (error.codeFrame) {
+    // @ts-ignore
     restoredError.codeFrame = error.codeFrame;
   }
 };
-var restoreMessageError = (error, _currentStack) => {
+const restoreMessageError = (error, _currentStack) => {
   const restoredError = constructError(error.message, error.type || error.data?.type, error.name);
-  if (typeof error.code === "string" || typeof error.code === "number") {
-    Object.defineProperty(restoredError, "code", {
+  if (typeof error.code === 'string' || typeof error.code === 'number') {
+    Object.defineProperty(restoredError, 'code', {
       configurable: true,
       value: error.code,
       writable: true
@@ -347,15 +350,15 @@ var restoreMessageError = (error, _currentStack) => {
   }
   return restoredError;
 };
-var getFallbackMessage = (error) => {
-  if (error && typeof error.message === "string" && error.message) {
+const getFallbackMessage = error => {
+  if (error && typeof error.message === 'string' && error.message) {
     return error.message;
   }
   if (error && error.data) {
     return getFallbackMessage(error.data);
   }
   const stringified = String(error);
-  if (stringified !== "[object Object]") {
+  if (stringified !== '[object Object]') {
     return stringified;
   }
   try {
@@ -364,7 +367,7 @@ var getFallbackMessage = (error) => {
     return stringified;
   }
 };
-var restoreJsonRpcError = (error) => {
+const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
     return restoreExistingError(error, currentStack);
@@ -380,51 +383,51 @@ var restoreJsonRpcError = (error) => {
   }
   return new Error(`JsonRpc Error: ${getFallbackMessage(error)}`);
 };
-var unwrapJsonRpcResult = (responseMessage) => {
-  if ("error" in responseMessage) {
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
     const restoredError = restoreJsonRpcError(responseMessage.error);
     throw restoredError;
   }
-  if ("result" in responseMessage) {
+  if ('result' in responseMessage) {
     return responseMessage.result;
   }
-  throw new JsonRpcError("unexpected response message");
+  throw new JsonRpcError('unexpected response message');
 };
-var warn = (...args) => {
+const warn = (...args) => {
   console.warn(...args);
 };
-var resolve = (id2, response) => {
-  const fn = get(id2);
+const resolve = (id, response) => {
+  const fn = get(id);
   if (!fn) {
     console.log(response);
-    warn(`callback ${id2} may already be disposed`);
+    warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove(id2);
+  remove(id);
 };
-var E_COMMAND_NOT_FOUND = "E_COMMAND_NOT_FOUND";
-var getErrorType = (prettyError) => {
+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 void 0;
+  return undefined;
 };
-var isAlreadyStack = (line) => {
-  return line.trim().startsWith("at ");
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
 };
-var getStack = (prettyError) => {
-  const stackString = prettyError.stack || "";
-  const newLineIndex = stackString.indexOf("\n");
+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;
 };
-var getErrorProperty = (error, prettyError) => {
+const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
@@ -444,68 +447,71 @@ var getErrorProperty = (error, prettyError) => {
     message: prettyError.message
   };
 };
-var create$1 = (id2, error) => {
+const create$1$1 = (id, error) => {
   return {
     error,
-    id: id2,
-    jsonrpc: Two
+    id,
+    jsonrpc: Two$1
   };
 };
-var getErrorResponse = (id2, error, preparePrettyError2, logError2) => {
-  const prettyError = preparePrettyError2(error);
-  logError2(error, prettyError);
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(id2, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-var create = (message, result) => {
+const create$5 = (message, result) => {
   return {
     id: message.id,
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
-var getSuccessResponse = (message, result) => {
+const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create(message, resultProperty);
+  return create$5(message, resultProperty);
 };
-var getErrorResponseSimple = (id2, error) => {
+const getErrorResponseSimple = (id, error) => {
   return {
     error: {
       code: Custom,
       data: error instanceof Error ? {
         ...error,
-        code: "code" in error ? error.code : void 0,
+        code: 'code' in error ? error.code : undefined,
         stack: error.stack,
         type: error.name
       } : error,
       // @ts-ignore
       message: error.message
     },
-    id: id2,
-    jsonrpc: Two
+    id,
+    jsonrpc: Two$1
   };
 };
-var getResponse = async (message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2) => {
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
-    const result = requiresSocket2(message.method) ? await execute2(message.method, ipc, ...message.params) : await execute2(message.method, ...message.params);
+    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, preparePrettyError2, logError2);
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
-var defaultPreparePrettyError = (error) => {
+const defaultPreparePrettyError = error => {
   return error;
 };
-var defaultLogError = () => {
+const defaultLogError = () => {
+  // ignore
 };
-var defaultRequiresSocket = () => {
+const defaultRequiresSocket = () => {
   return false;
 };
-var defaultResolve = resolve;
-var normalizeParams = (args) => {
+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 {
@@ -528,79 +534,82 @@ var normalizeParams = (args) => {
     resolve: args[3]
   };
 };
-var handleJsonRpcMessage = async (...args) => {
+const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    execute: execute2,
+    execute,
     ipc,
-    logError: logError2,
+    logError,
     message,
-    preparePrettyError: preparePrettyError2,
-    requiresSocket: requiresSocket2,
-    resolve: resolve2
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
-  if ("id" in message) {
-    if ("method" in message) {
-      const response = await getResponse(message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2);
+  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, preparePrettyError2, logError2);
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
     }
-    resolve2(message.id, message);
+    resolve(message.id, message);
     return;
   }
-  if ("method" in message) {
-    await getResponse(message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2);
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
     return;
   }
-  throw new JsonRpcError("unexpected message");
+  throw new JsonRpcError('unexpected message');
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcVersion/JsonRpcVersion.js
-var Two2 = "2.0";
+const Two = '2.0';
 
-// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcEvent/JsonRpcEvent.js
-var create2 = (method, params) => {
+const create$4 = (method, params) => {
   return {
-    jsonrpc: Two2,
+    jsonrpc: Two,
     method,
     params
   };
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcRequest/JsonRpcRequest.js
-var create3 = (id2, method, params) => {
+const create$3 = (id, method, params) => {
   const message = {
-    id: id2,
-    jsonrpc: Two2,
+    id,
+    jsonrpc: Two,
     method,
     params
   };
   return message;
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/Id/Id.js
-var id = 0;
-var create4 = () => {
+let id = 0;
+const create$2 = () => {
   return ++id;
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/RegisterPromise/RegisterPromise.js
-var registerPromise = (map) => {
-  const id2 = create4();
-  const { promise, resolve: resolve2 } = Promise.withResolvers();
-  map[id2] = resolve2;
-  return { id: id2, promise };
+const registerPromise = map => {
+  const id = create$2();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/CreateRpc/CreateRpc.js
-var invokeHelper = async (callbacks2, ipc, method, params, useSendAndTransfer) => {
-  const { id: id2, promise } = registerPromise(callbacks2);
-  const message = create3(id2, method, params);
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$3(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -609,26 +618,26 @@ var invokeHelper = async (callbacks2, ipc, method, params, useSendAndTransfer) =
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-var createRpc = (ipc) => {
-  const callbacks2 = /* @__PURE__ */ Object.create(null);
-  ipc._resolve = (id2, response) => {
-    const fn = callbacks2[id2];
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
     if (!fn) {
-      console.warn(`callback ${id2} may already be disposed`);
+      console.warn(`callback ${id} may already be disposed`);
       return;
     }
     fn(response);
-    delete callbacks2[id2];
+    delete callbacks[id];
   };
   const rpc = {
     async dispose() {
       await ipc?.dispose();
     },
     invoke(method, ...params) {
-      return invokeHelper(callbacks2, ipc, method, params, false);
+      return invokeHelper(callbacks, ipc, method, params, false);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeHelper(callbacks2, ipc, method, params, true);
+      return invokeHelper(callbacks, ipc, method, params, true);
     },
     // @ts-ignore
     ipc,
@@ -636,24 +645,24 @@ var createRpc = (ipc) => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create2(method, params);
+      const message = create$4(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/HandleMessage/HandleMessage.js
-var requiresSocket = () => {
+const requiresSocket = () => {
   return false;
 };
-var preparePrettyError = (error) => {
+const preparePrettyError = error => {
   return error;
 };
-var logError = () => {
+const logError = () => {
+  // handled by renderer worker
 };
-var handleMessage = (event) => {
-  if (event.data === "ready") {
+const handleMessage = event => {
+  if (event.data === 'ready') {
     return Promise.resolve();
   }
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
@@ -661,17 +670,16 @@ var handleMessage = (event) => {
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/HandleIpc/HandleIpc.js
-var handleIpc = (ipc) => {
-  if ("addEventListener" in ipc) {
-    ipc.addEventListener("message", handleMessage);
-  } else if ("on" in ipc) {
-    ipc.on("message", handleMessage);
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
   }
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/IpcChildNode/IpcChildNode.js
-var listen = async (module, options) => {
+const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
     module.signal(rawIpc);
@@ -680,51 +688,51 @@ var listen = async (module, options) => {
   return ipc;
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/MessagePortRpcClient/MessagePortRpcClient.js
-var MessagePortRpcClient_exports = {};
-__export(MessagePortRpcClient_exports, {
-  create: () => create5
-});
-var create5 = async ({ commandMap: commandMap2, messagePort }) => {
-  register(commandMap2);
-  const ipc = await listen(IpcChildWithMessagePort$1, { port: messagePort });
+const create$1 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithMessagePort$1, {
+    port: messagePort
+  });
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 
-// node_modules/@lvce-editor/rpc/dist/parts/WebWorkerRpcClient2/WebWorkerRpcClient2.js
-var WebWorkerRpcClient2_exports = {};
-__export(WebWorkerRpcClient2_exports, {
-  create: () => create6
-});
-var create6 = async ({ commandMap: commandMap2 }) => {
-  register(commandMap2);
-  const ipc = await listen(IpcChildWithModuleWorker$1);
+const create = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorker$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 
-// packages/cache-worker/src/parts/Cache/Cache.ts
-var getCache = async (cacheName, bucketName, bucketOptions) => {
+const getCache = async (cacheName, bucketName, bucketOptions) => {
   if (bucketName) {
-    if (typeof navigator === "undefined") {
-      throw new Error("Storage Buckets are not available in this context");
+    if (typeof navigator === 'undefined') {
+      throw new Error('Storage Buckets are not available in this context');
     }
-    const { storageBuckets } = navigator;
+    const {
+      storageBuckets
+    } = navigator;
     if (!storageBuckets) {
-      throw new Error("Storage Buckets are not available in this context");
+      throw new Error('Storage Buckets are not available in this context');
     }
     const bucket = await storageBuckets.open(bucketName, bucketOptions);
     return bucket.caches.open(cacheName);
   }
-  if (typeof caches === "undefined") {
-    throw new Error("Cache Storage is not available in this context");
+  if (typeof caches === 'undefined') {
+    throw new Error('Cache Storage is not available in this context');
   }
   return caches.open(cacheName);
 };
-var getCacheStorageItem = async (request, cacheName = "lvce-cache", bucketName = "", bucketOptions = {}) => {
+const getCacheStorageItem = async (request, cacheName = 'lvce-cache', bucketName = '', bucketOptions = {}) => {
   const cache = await getCache(cacheName, bucketName, bucketOptions);
   const response = await cache.match(request);
   if (!response) {
@@ -737,117 +745,421 @@ var getCacheStorageItem = async (request, cacheName = "lvce-cache", bucketName =
     statusText: response.statusText
   };
 };
-var setCacheStorageItem = async (request, value, cacheName = "lvce-cache", headers = {}, bucketName = "", bucketOptions = {}) => {
+const setCacheStorageItem = async (request, value, cacheName = 'lvce-cache', headers = {}, bucketName = '', bucketOptions = {}) => {
   try {
     const cache = await getCache(cacheName, bucketName, bucketOptions);
-    const response = new Response(value, { headers: new Headers(headers) });
+    const response = new Response(value, {
+      headers: new Headers(headers)
+    });
     await cache.put(request, response);
-    return { success: true };
+    return {
+      success: true
+    };
   } catch (error) {
     return {
-      errorCode: "CACHE_STORAGE_WRITE_FAILED",
+      errorCode: 'CACHE_STORAGE_WRITE_FAILED',
       errorMessage: error instanceof Error ? error.message : String(error),
       success: false
     };
   }
 };
-var removeCacheStorageItem = async (request, cacheName = "lvce-cache", bucketName = "", bucketOptions = {}) => {
+const removeCacheStorageItem = async (request, cacheName = 'lvce-cache', bucketName = '', bucketOptions = {}) => {
   const cache = await getCache(cacheName, bucketName, bucketOptions);
   return cache.delete(request);
 };
 
-// packages/cache-worker/src/parts/IndexedDb/IndexedDb.ts
-var cloneDatabaseKey = (key) => structuredClone(key);
-var requestResult = (request) => new Promise((resolve2, reject) => {
-  request.addEventListener("success", () => resolve2(request.result), { once: true });
-  request.addEventListener("error", () => reject(request.error ?? new Error("IndexedDB request failed")), { once: true });
-});
-var transactionDone = (transaction) => new Promise((resolve2, reject) => {
-  transaction.addEventListener("complete", () => resolve2(void 0), { once: true });
-  transaction.addEventListener("abort", () => reject(transaction.error ?? new Error("IndexedDB transaction aborted")), { once: true });
-  transaction.addEventListener("error", () => reject(transaction.error ?? new Error("IndexedDB transaction failed")), { once: true });
-});
-var openDatabase = (name) => {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB is not available in this context");
-  }
-  return new Promise((resolve2, reject) => {
-    const request = indexedDB.open(name, 1);
-    request.onupgradeneeded = () => {
-      if (!request.result.objectStoreNames.contains("file-handles")) {
-        request.result.createObjectStore("file-handles");
-      }
+const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);
+}
+const transactionDoneMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener('success', success);
+      request.removeEventListener('error', error);
     };
-    request.onsuccess = () => {
-      request.result.onversionchange = () => request.result.close();
-      resolve2(request.result);
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
     };
-    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB database"));
-    request.onblocked = () => reject(new Error(`Opening IndexedDB database "${name}" was blocked`));
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener('success', success);
+    request.addEventListener('error', error);
+  });
+  // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This
+  // is because we create many promises from a single IDBRequest.
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  // Early bail if we've already created a done promise for this transaction.
+  if (transactionDoneMap.has(tx)) return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener('complete', complete);
+      tx.removeEventListener('error', error);
+      tx.removeEventListener('abort', error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException('AbortError', 'AbortError'));
+      unlisten();
+    };
+    tx.addEventListener('complete', complete);
+    tx.addEventListener('error', error);
+    tx.addEventListener('abort', error);
+  });
+  // Cache it for later retrieval.
+  transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      // Special handling for transaction.done.
+      if (prop === 'done') return transactionDoneMap.get(target);
+      // Make tx.store return the only store in the transaction, or undefined if there are many.
+      if (prop === 'store') {
+        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    // Else transform whatever we get back.
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {
+      return true;
+    }
+    return prop in target;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  // Due to expected object equality (which is enforced by the caching in `wrap`), we
+  // only create one new func per func.
+  // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+  // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+  // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+  // with real promises, so each advance methods returns a new promise for the cursor object, or
+  // undefined if the end of the cursor has been reached.
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function (...args) {
+      // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+      // the original object.
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function (...args) {
+    // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+    // the original object.
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === 'function') return wrapFunction(value);
+  // This doesn't return, it just creates a 'done' promise for the transaction,
+  // which is later returned for transaction.done (see idbObjectHandler).
+  if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
+  // Return the same value back if we're not going to transform it.
+  return value;
+}
+function wrap(value) {
+  // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+  // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+  if (value instanceof IDBRequest) return promisifyRequest(value);
+  // If we've already transformed this value before, reuse the transformed value.
+  // This is faster, but it also provides object equality.
+  if (transformCache.has(value)) return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  // Not all types are transformed.
+  // These may be primitive types, so they can't be WeakMap keys.
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+const unwrap = value => reverseTransformCache.get(value);
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, {
+  blocked,
+  upgrade,
+  blocking,
+  terminated
+} = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener('upgradeneeded', event => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener('blocked', event => blocked(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    event.oldVersion, event.newVersion, event));
+  }
+  openPromise.then(db => {
+    if (terminated) db.addEventListener('close', () => terminated());
+    if (blocking) {
+      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {});
+  return openPromise;
+}
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {
+    return;
+  }
+  if (cachedMethods.get(prop)) return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, '');
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+    return;
+  }
+  const method = async function (storeName, ...args) {
+    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+    let target = tx.store;
+    if (useIndex) target = target.index(args.shift());
+    // Must reject if op rejects.
+    // If it's a write operation, must reject if tx.done rejects.
+    // Must reject with op rejection first.
+    // Must resolve with op value.
+    // Must handle both promises (no unhandled rejections)
+    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop)) return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function (...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  // tslint:disable-next-line:no-this-assignment
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor) return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  // Map this double-proxy back to the original, so other cursor methods work.
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    // If one of the advancing methods was not called, call continue().
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop)) return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+const cloneDatabaseKey = key => structuredClone(key);
+const closeDatabaseWhenOpened = async opening => {
+  try {
+    const openedDatabase = await opening;
+    openedDatabase.close();
+  } catch {
+    // The open request can also fail after reporting that it was blocked.
+  }
+};
+const openDatabase = async name => {
+  if (typeof indexedDB === 'undefined') {
+    throw new Error('IndexedDB is not available in this context');
+  }
+  let database;
+  const {
+    promise: blocked,
+    reject: rejectBlocked
+  } = Promise.withResolvers();
+  const opening = openDB(name, 1, {
+    blocked() {
+      rejectBlocked(new Error(`Opening IndexedDB database "${name}" was blocked`));
+    },
+    blocking() {
+      database?.close();
+    },
+    upgrade(database) {
+      if (!database.objectStoreNames.contains('file-handles')) {
+        database.createObjectStore('file-handles');
+      }
+    }
   });
+  try {
+    const openedDatabase = await Promise.race([opening, blocked]);
+    database = openedDatabase;
+    return openedDatabase;
+  } catch (error) {
+    void closeDatabaseWhenOpened(opening);
+    throw error;
+  }
 };
-var addIndexedDbFileHandle = async (key, handle, databaseName = "lvce-cache-worker") => {
+const addIndexedDbFileHandle = async (key, handle, databaseName = 'lvce-cache-worker') => {
   const database = await openDatabase(databaseName);
-  const transaction = database.transaction("file-handles", "readwrite");
-  const done = transactionDone(transaction);
-  const request = transaction.objectStore("file-handles").put(handle, cloneDatabaseKey(key));
+  const transaction = database.transaction('file-handles', 'readwrite');
   try {
-    await Promise.all([requestResult(request), done]);
+    await transaction.store.put(handle, cloneDatabaseKey(key));
+    await transaction.done;
+  } catch (error) {
+    try {
+      transaction.abort();
+    } catch {
+      // The transaction may already have completed or aborted.
+    }
+    try {
+      await transaction.done;
+    } catch {
+      // The transaction has already aborted.
+    }
+    throw error;
   } finally {
     database.close();
   }
 };
-var getIndexedDbFileHandle = async (key, databaseName = "lvce-cache-worker") => {
+const getIndexedDbFileHandle = async (key, databaseName = 'lvce-cache-worker') => {
   const database = await openDatabase(databaseName);
-  const transaction = database.transaction("file-handles", "readonly");
-  const done = transactionDone(transaction);
+  const transaction = database.transaction('file-handles', 'readonly');
   try {
-    const value = await requestResult(transaction.objectStore("file-handles").get(cloneDatabaseKey(key)));
-    await done;
+    const value = await transaction.store.get(cloneDatabaseKey(key));
+    await transaction.done;
     return value;
+  } catch (error) {
+    try {
+      transaction.abort();
+    } catch {
+      // The transaction may already have completed or aborted.
+    }
+    try {
+      await transaction.done;
+    } catch {
+      // The transaction has already aborted.
+    }
+    throw error;
   } finally {
     database.close();
   }
 };
-var removeIndexedDbFileHandle = async (key, databaseName = "lvce-cache-worker") => {
+const removeIndexedDbFileHandle = async (key, databaseName = 'lvce-cache-worker') => {
   const database = await openDatabase(databaseName);
-  const transaction = database.transaction("file-handles", "readwrite");
-  const done = transactionDone(transaction);
-  const request = transaction.objectStore("file-handles").delete(cloneDatabaseKey(key));
+  const transaction = database.transaction('file-handles', 'readwrite');
   try {
-    await Promise.all([requestResult(request), done]);
+    await transaction.store.delete(cloneDatabaseKey(key));
+    await transaction.done;
+  } catch (error) {
+    try {
+      transaction.abort();
+    } catch {
+      // The transaction may already have completed or aborted.
+    }
+    try {
+      await transaction.done;
+    } catch {
+      // The transaction has already aborted.
+    }
+    throw error;
   } finally {
     database.close();
   }
 };
 
-// packages/cache-worker/src/parts/Opfs/Opfs.ts
-var getRoot = async () => {
-  if (typeof navigator === "undefined") {
-    throw new TypeError("Origin Private File System is not available in this context");
+const getRoot = async () => {
+  if (typeof navigator === 'undefined') {
+    throw new TypeError('Origin Private File System is not available in this context');
   }
-  const { storage } = navigator;
-  if (typeof storage.getDirectory !== "function") {
-    throw new TypeError("Origin Private File System is not available in this context");
+  const {
+    storage
+  } = navigator;
+  if (typeof storage.getDirectory !== 'function') {
+    throw new TypeError('Origin Private File System is not available in this context');
   }
   return storage.getDirectory();
 };
-var validateName = (name) => {
-  if (typeof name !== "string" || name.length === 0 || name === "." || name === ".." || /[/\\]/.test(name)) {
-    throw new TypeError("OPFS filename must be a non-empty single path component");
+const validateName = name => {
+  if (typeof name !== 'string' || name.length === 0 || name === '.' || name === '..' || /[/\\]/.test(name)) {
+    throw new TypeError('OPFS filename must be a non-empty single path component');
   }
 };
-var readFile = async (name) => {
+const readFile = async name => {
   validateName(name);
   const root = await getRoot();
   const handle = await root.getFileHandle(name);
   const file = await handle.getFile();
   return file.text();
 };
-var writeFile = async (name, content) => {
+const writeFile = async (name, content) => {
   validateName(name);
   const root = await getRoot();
-  const handle = await root.getFileHandle(name, { create: true });
+  const handle = await root.getFileHandle(name, {
+    create: true
+  });
   const writable = await handle.createWritable();
   try {
     await writable.write(content);
@@ -857,36 +1169,36 @@ var writeFile = async (name, content) => {
   }
   await writable.close();
 };
-var removeFile = async (name) => {
+const removeFile = async name => {
   validateName(name);
   const root = await getRoot();
   await root.removeEntry(name);
 };
 
-// packages/cache-worker/src/parts/CommandMap/CommandMap.ts
-var commandMap = {
-  "Cache.getCacheStorageItem": getCacheStorageItem,
-  "Cache.removeCacheStorageItem": removeCacheStorageItem,
-  "Cache.setCacheStorageItem": setCacheStorageItem,
-  "CacheWorker.handleMessagePort": handleMessagePort,
-  "IndexedDb.addIndexedDbFileHandle": addIndexedDbFileHandle,
-  "IndexedDb.getIndexedDbFileHandle": getIndexedDbFileHandle,
-  "IndexedDb.removeIndexedDbFileHandle": removeIndexedDbFileHandle,
-  "Opfs.readFile": readFile,
-  "Opfs.removeFile": removeFile,
-  "Opfs.writeFile": writeFile
+const handleMessagePort$1 = messagePort => handleMessagePort(messagePort);
+const commandMap = {
+  'Cache.getCacheStorageItem': getCacheStorageItem,
+  'Cache.removeCacheStorageItem': removeCacheStorageItem,
+  'Cache.setCacheStorageItem': setCacheStorageItem,
+  'CacheWorker.handleMessagePort': handleMessagePort$1,
+  'IndexedDb.addIndexedDbFileHandle': addIndexedDbFileHandle,
+  'IndexedDb.getIndexedDbFileHandle': getIndexedDbFileHandle,
+  'IndexedDb.removeIndexedDbFileHandle': removeIndexedDbFileHandle,
+  'Opfs.readFile': readFile,
+  'Opfs.removeFile': removeFile,
+  'Opfs.writeFile': writeFile
 };
 
-// packages/cache-worker/src/parts/Listen/Listen.ts
-var listen2 = async () => {
-  await WebWorkerRpcClient2_exports.create({ commandMap });
+const listen = async () => {
+  await create({
+    commandMap: commandMap
+  });
 };
-var handleMessagePort = async (messagePort) => {
-  await MessagePortRpcClient_exports.create({
-    commandMap,
+const handleMessagePort = async messagePort => {
+  await create$1({
+    commandMap: commandMap,
     messagePort
   });
 };
 
-// packages/cache-worker/src/cacheWorkerMain.ts
-await listen2();
+await listen();