@lvce-editor/static-server 0.117.15 → 0.117.16

package/static/{5eb36bd → e84ca34}/packages/file-system-worker/dist/fileSystemWorkerMain.js

@@ -155,17 +155,6 @@ function binaryStringToArrayBuffer(binary) {
   return buf;
 }
 
-const normalizeBlobError = error => {
-  const ProgressEventConstructor = ProgressEvent;
-  if (error && ProgressEventConstructor && error instanceof ProgressEventConstructor && error.target &&
-  // @ts-expect-error - target.error may not be in the type definition
-  error.target.error) {
-    // @ts-expect-error - target.error may not be in the type definition
-    return error.target.error;
-  }
-  return error;
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -222,23 +211,6 @@ class VError extends Error {
   }
 }
 
-const binaryStringToBlob = async (string, type) => {
-  try {
-    return binaryStringToBlob$1(string, type);
-  } catch (error) {
-    const normalizedError = normalizeBlobError(error);
-    throw new VError(normalizedError, 'Failed to convert binary string to blob');
-  }
-};
-const blobToBinaryString = async blob => {
-  try {
-    return await blobToBinaryString$1(blob);
-  } catch (error) {
-    const normalizedError = normalizeBlobError(error);
-    throw new VError(normalizedError, 'Failed to convert blob to binary string');
-  }
-};
-
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -773,7 +745,7 @@ const register$1 = commandMap => {
 const getCommand = key => {
   return commands[key];
 };
-const execute = (command, ...args) => {
+const execute$1 = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -1234,7 +1206,7 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
+  const actualExecute = event?.target?.execute || execute$1;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 
@@ -1379,7 +1351,7 @@ const waitForReconnect = async () => {
     setTimeout(resolve, reconnectDelay);
   });
 };
-const connect = async ({
+const connect$1 = async ({
   commandMap,
   wsUrl
 }) => {
@@ -1408,13 +1380,13 @@ const create$2 = async ({
   const wsUrl = getWebSocketUrl(type, host, protocol);
   let connection;
   try {
-    connection = await connect({
+    connection = await connect$1({
       commandMap,
       wsUrl
     });
   } catch {
     await waitForReconnect();
-    connection = await connect({
+    connection = await connect$1({
       commandMap,
       wsUrl
     });
@@ -1517,7 +1489,6 @@ const RendererProcess = 1670;
 const RendererWorker = 1;
 
 const {
-  invoke: invoke$4,
   set: set$4
 } = create(ExtensionHostWorker);
 
@@ -1689,83 +1660,6 @@ const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 
-const remove$3 = async dirent => {
-  throw new Error('not implemented');
-};
-const readFile$3 = async uri => {
-  const response = await fetch(uri);
-  if (!response.ok) {
-    throw new Error(response.statusText);
-  }
-  const result = await response.text();
-  return result;
-};
-const readFileAsBlob$2 = async uri => {
-  const response = await fetch(uri);
-  if (!response.ok) {
-    throw new Error(response.statusText);
-  }
-  const result = await response.blob();
-  return result;
-};
-const exists$3 = async uri => {
-  const response = await fetch(uri);
-  return response.ok;
-};
-const readDirWithFileTypes$3 = async uri => {
-  throw new Error('not implemented');
-};
-const readJson$3 = async uri => {
-  const response = await fetch(uri);
-  if (!response.ok) {
-    throw new Error(response.statusText);
-  }
-  const json = await response.json();
-  return json;
-};
-const getRealPath$3 = async path => {
-  throw new Error('not implemented');
-};
-const stat$3 = async dirent => {
-  throw new Error('not implemented');
-};
-const createFile$2 = async uri => {
-  throw new Error('not implemented');
-};
-const writeFile$3 = async (uri, content) => {
-  throw new Error('not implemented');
-};
-const mkdir$3 = async uri => {
-  throw new Error('not implemented');
-};
-const rename$3 = async (oldUri, newUri) => {
-  throw new Error('not implemented');
-};
-const copy$3 = async (oldUri, newUri) => {
-  throw new Error('not implemented');
-};
-const getFolderSize$3 = async uri => {
-  throw new Error('not implemented');
-};
-
-const FileSystemFetch = {
-   __proto__: null,
-   copy: copy$3,
-   createFile: createFile$2,
-   exists: exists$3,
-   getFolderSize: getFolderSize$3,
-   getRealPath: getRealPath$3,
-   mkdir: mkdir$3,
-   readDirWithFileTypes: readDirWithFileTypes$3,
-   readFile: readFile$3,
-   readFileAsBlob: readFileAsBlob$2,
-   readJson: readJson$3,
-   remove: remove$3,
-   rename: rename$3,
-   stat: stat$3,
-   writeFile: writeFile$3
-};
-
 const RE_PROTOCOL = /^([a-z-]+):\/\//;
 const assertUri = uri => {
   const protocolMatch = uri.match(RE_PROTOCOL);
@@ -1782,20 +1676,20 @@ const getFileHashes$1 = async uris => {
 };
 const {
   appendFile: appendFile$1,
-  copy: copy$2,
-  exists: exists$2,
-  getFolderSize: getFolderSize$2,
-  getRealPath: getRealPath$2,
+  copy: copy$3,
+  exists: exists$3,
+  getFolderSize: getFolderSize$3,
+  getRealPath: getRealPath$3,
   invoke: invoke$1,
-  mkdir: mkdir$2,
-  readDirWithFileTypes: readDirWithFileTypes$2,
-  readFile: readFile$2,
-  readJson: readJson$2,
-  remove: remove$2,
-  rename: rename$2,
+  mkdir: mkdir$3,
+  readDirWithFileTypes: readDirWithFileTypes$3,
+  readFile: readFile$3,
+  readJson: readJson$3,
+  remove: remove$3,
+  rename: rename$3,
   set,
-  stat: stat$2,
-  writeFile: writeFile$2
+  stat: stat$3,
+  writeFile: writeFile$3
 } = FileSystemProcess;
 
 const Http = 'http:';
@@ -1881,53 +1775,251 @@ const getFileExtension = uri => {
   return uri.slice(lastDot + 1);
 };
 
+// These numeric types are the filesystem wire protocol consumed by explorer.
+const directory = 3;
+const file = 7;
+const files = new Map();
+const getPath = uri => (uri.startsWith('memfs://') ? uri.slice('memfs://'.length) : uri).replace(/\/$/, '');
+const getEntry = uri => files.get(getPath(uri));
+const ensureParentDirs = path => {
+  let end = path.indexOf('/');
+  while (end >= 0) {
+    const parent = path.slice(0, end);
+    if (!files.has(parent)) files.set(parent, {
+      content: new Blob(),
+      type: directory
+    });
+    end = path.indexOf('/', end + 1);
+  }
+};
 const getBlobType = uri => {
-  const extension = getFileExtension(uri).toLowerCase();
-  switch (extension) {
-    case 'css':
-      return 'text/css';
-    case 'html':
-      return 'text/html';
-    case 'js':
-      return 'text/javascript';
-    case 'json':
-      return 'application/json';
-    case 'svg':
-      return 'image/svg+xml';
-    case 'txt':
-      return 'text/plain';
-    case 'xml':
-      return 'application/xml';
-    default:
-      return '';
+  const types = {
+    css: 'text/css',
+    html: 'text/html',
+    js: 'text/javascript',
+    json: 'application/json',
+    svg: 'image/svg+xml',
+    txt: 'text/plain',
+    xml: 'application/xml'
+  };
+  return types[getFileExtension(uri).toLowerCase()] || '';
+};
+const readFileAsBlob$2 = async uri => {
+  const entry = getEntry(uri);
+  if (!entry) throw new Error(`File not found: ${uri}`);
+  if (entry.type !== file) throw new Error(`File is a directory: ${uri}`);
+  return entry.content;
+};
+const readFile$2 = async uri => {
+  const blob = await readFileAsBlob$2(uri);
+  return blob.text();
+};
+const writeFile$2 = async (uri, content) => {
+  const path = getPath(uri);
+  ensureParentDirs(path);
+  files.set(path, {
+    content: new Blob([content], {
+      type: getBlobType(uri)
+    }),
+    type: file
+  });
+  await triggerMemfsFileWatcher(uri);
+};
+const exists$2 = async uri => !!getEntry(uri);
+const createFile$2 = async uri => writeFile$2(uri, '');
+const mkdir$2 = async uri => {
+  const path = getPath(uri);
+  ensureParentDirs(path);
+  files.set(path, {
+    content: new Blob(),
+    type: directory
+  });
+  await triggerMemfsFileWatcher(uri);
+};
+const remove$2 = async uri => {
+  const path = getPath(uri);
+  for (const key of files.keys()) {
+    if (key === path || key.startsWith(`${path}/`)) files.delete(key);
   }
+  await triggerMemfsFileWatcher(uri);
 };
+const readDirWithFileTypes$2 = async uri => {
+  const path = `${getPath(uri)}/`;
+  const entries = new Map();
+  for (const [key, value] of files) {
+    if (!key.startsWith(path) || key === path) continue;
+    const rest = key.slice(path.length);
+    const slash = rest.indexOf('/');
+    entries.set(slash === -1 ? rest : rest.slice(0, slash), slash === -1 ? value.type : directory);
+  }
+  return Array.from(entries, ([name, type]) => ({
+    name,
+    type
+  }));
+};
+const rename$2 = async (oldUri, newUri) => {
+  const oldPath = getPath(oldUri);
+  const newPath = getPath(newUri);
+  const entry = getEntry(oldUri);
+  if (!entry) throw new Error(`File not found: ${oldUri}`);
+  if (oldPath === newPath) return;
+  if (newPath.startsWith(`${oldPath}/`)) throw new Error('Cannot move a directory into itself');
+  ensureParentDirs(newPath);
+  // Snapshot before mutating the map so newly inserted keys are not visited.
+  const entries = [...files];
+  for (const [key, value] of entries) {
+    if (!(key === oldPath || key.startsWith(`${oldPath}/`))) {
+      continue;
+    }
+    files.set(`${newPath}${key.slice(oldPath.length)}`, value);
+    files.delete(key);
+  }
+  await triggerMemfsFileWatcher(oldUri);
+  await triggerMemfsFileWatcher(newUri);
+};
+const copy$2 = async (oldUri, newUri) => writeFile$2(newUri, await readFile$2(oldUri));
+const stat$2 = async uri => {
+  const entry = getEntry(uri);
+  return entry ? {
+    exists: true,
+    size: entry.content.size,
+    type: entry.type
+  } : {
+    exists: false,
+    size: 0
+  };
+};
+const readJson$2 = async uri => JSON.parse(await readFile$2(uri));
+const getPathSeparator$1 = async _root => '/';
+const getRealPath$2 = async uri => uri;
+const getFolderSize$2 = async uri => {
+  const path = `${getPath(uri)}/`;
+  let size = 0;
+  for (const [key, entry] of files) if (key.startsWith(path)) size += entry.content.size;
+  return size;
+};
+const getFiles = async () => {
+  const entries = await Promise.all(Array.from(files, async ([path, entry]) => [path, {
+    content: await entry.content.text(),
+    type: entry.type
+  }]));
+  return Object.fromEntries(entries);
+};
+
+const FileSystemMemory = {
+   __proto__: null,
+   copy: copy$2,
+   createFile: createFile$2,
+   exists: exists$2,
+   getFiles,
+   getFolderSize: getFolderSize$2,
+   getPathSeparator: getPathSeparator$1,
+   getRealPath: getRealPath$2,
+   mkdir: mkdir$2,
+   readDirWithFileTypes: readDirWithFileTypes$2,
+   readFile: readFile$2,
+   readFileAsBlob: readFileAsBlob$2,
+   readJson: readJson$2,
+   remove: remove$2,
+   rename: rename$2,
+   stat: stat$2,
+   writeFile: writeFile$2
+};
+
+const memoryRoot = id => `memfs:///applications/${encodeURIComponent(id)}`;
+const memoryUri = (id, uri) => `${memoryRoot(id)}/${uri.slice('memfs://'.length).replace(/^\/+/, '')}`;
+const execute = async (id, method, ...args) => {
+  const [uri] = args;
+  if (typeof uri !== 'string') throw new TypeError('Application filesystem requires a URI');
+  if (uri.startsWith('memfs://')) {
+    if (method === 'isReadonly') return false;
+    const fn = FileSystemMemory[method === 'getBlob' ? 'readFileAsBlob' : method];
+    if (typeof fn !== 'function') throw new Error(`Unsupported application memory operation: ${method}`);
+    const mapped = [...args];
+    mapped[0] = memoryUri(id, uri);
+    if (method === 'rename' || method === 'copy') {
+      if (typeof args[1] !== 'string' || !args[1].startsWith('memfs://')) throw new Error('Cross-filesystem operation is not supported');
+      mapped[1] = memoryUri(id, args[1]);
+    }
+    return fn(...mapped);
+  }
+  // Provider activation and component-state access need application context.
+  // This callback handles only non-memory URIs, never file contents storage.
+  return invoke$2('Application.execute', id, `FileSystem.${method}`, ...args);
+};
+const dispose = async id => remove$2(memoryRoot(id));
+
+const normalizeBlobError = error => {
+  const ProgressEventConstructor = ProgressEvent;
+  if (error && ProgressEventConstructor && error instanceof ProgressEventConstructor && error.target &&
+  // @ts-expect-error - target.error may not be in the type definition
+  error.target.error) {
+    // @ts-expect-error - target.error may not be in the type definition
+    return error.target.error;
+  }
+  return error;
+};
+
+const binaryStringToBlob = async (string, type) => {
+  try {
+    return binaryStringToBlob$1(string, type);
+  } catch (error) {
+    const normalizedError = normalizeBlobError(error);
+    throw new VError(normalizedError, 'Failed to convert binary string to blob');
+  }
+};
+const blobToBinaryString = async blob => {
+  try {
+    return await blobToBinaryString$1(blob);
+  } catch (error) {
+    const normalizedError = normalizeBlobError(error);
+    throw new VError(normalizedError, 'Failed to convert blob to binary string');
+  }
+};
+
+const connect = async port => {
+  const {
+    commandMap
+  } = await Promise.resolve().then(function () { return CommandMap; });
+  await create$6({
+    commandMap,
+    messagePort: port
+  });
+};
+
 const remove$1 = async dirent => {
-  await invoke$4('FileSystemMemory.remove', dirent);
-  // Trigger file watchers for memfs files
-  await triggerMemfsFileWatcher(dirent);
+  throw new Error('not implemented');
 };
 const readFile$1 = async uri => {
-  return invoke$4('FileSystemMemory.readFile', uri);
+  const response = await fetch(uri);
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+  const result = await response.text();
+  return result;
 };
 const readFileAsBlob$1 = async uri => {
-  const content = await readFile$1(uri);
-  const type = getBlobType(uri);
-  if (type) {
-    return new Blob([content], {
-      type
-    });
+  const response = await fetch(uri);
+  if (!response.ok) {
+    throw new Error(response.statusText);
   }
-  return new Blob([content]);
+  const result = await response.blob();
+  return result;
 };
 const exists$1 = async uri => {
-  throw new Error('not implemented');
+  const response = await fetch(uri);
+  return response.ok;
 };
 const readDirWithFileTypes$1 = async uri => {
   throw new Error('not implemented');
 };
 const readJson$1 = async uri => {
-  throw new Error('not implemented');
+  const response = await fetch(uri);
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+  const json = await response.json();
+  return json;
 };
 const getRealPath$1 = async path => {
   throw new Error('not implemented');
@@ -1936,23 +2028,16 @@ const stat$1 = async dirent => {
   throw new Error('not implemented');
 };
 const createFile$1 = async uri => {
-  await invoke$4('FileSystemMemory.createFile', uri);
-  // Trigger file watchers for memfs files
-  await triggerMemfsFileWatcher(uri);
+  throw new Error('not implemented');
 };
 const writeFile$1 = async (uri, content) => {
-  await invoke$4('FileSystemMemory.writeFile', uri, content);
-  // Trigger file watchers for memfs files
-  await triggerMemfsFileWatcher(uri);
+  throw new Error('not implemented');
 };
 const mkdir$1 = async uri => {
   throw new Error('not implemented');
 };
 const rename$1 = async (oldUri, newUri) => {
-  await invoke$4('FileSystemMemory.rename', oldUri, newUri);
-  // Trigger file watchers for both old and new URIs
-  await triggerMemfsFileWatcher(oldUri);
-  await triggerMemfsFileWatcher(newUri);
+  throw new Error('not implemented');
 };
 const copy$1 = async (oldUri, newUri) => {
   throw new Error('not implemented');
@@ -1961,7 +2046,7 @@ const getFolderSize$1 = async uri => {
   throw new Error('not implemented');
 };
 
-const FileSystemMemory = {
+const FileSystemFetch = {
    __proto__: null,
    copy: copy$1,
    createFile: createFile$1,
@@ -2003,24 +2088,28 @@ const isProviderUri = uri => {
 
 const remove = async dirent => {
   if (isMemory(dirent)) {
-    return remove$1(dirent);
+    return remove$2(dirent);
   }
   if (isProviderUri(dirent)) {
     return invoke$2('FileSystem.remove', dirent);
   }
-  return remove$2(dirent);
+  return remove$3(dirent);
 };
 const readFile = async uri => {
+  if (uri.startsWith('untitled:')) return '';
   if (isFetch(uri) || isHtml(uri)) {
     return invoke$2('FileSystem.readFile', uri);
   }
   if (isHttp(uri)) {
-    return readFile$3(uri);
+    return readFile$1(uri);
   }
-  if (isMemory(uri) || isProviderUri(uri)) {
+  if (isMemory(uri)) {
+    return readFile$2(uri);
+  }
+  if (isProviderUri(uri)) {
     return invoke$2('FileSystem.readFile', uri);
   }
-  return readFile$2(uri);
+  return readFile$3(uri);
 };
 const getFileHash = async uri => {
   return getFileHash$1(uri);
@@ -2035,25 +2124,29 @@ const readDirWithFileTypes = async uri => {
   if (isFetch(uri) || isHtml(uri)) {
     return invoke$2('FileSystem.readDirWithFileTypes', uri);
   }
-  if (isMemory(uri) || isProviderUri(uri)) {
+  if (isMemory(uri)) {
+    return readDirWithFileTypes$2(uri);
+  }
+  if (isProviderUri(uri)) {
     return invoke$2('FileSystem.readDirWithFileTypes', uri);
   }
-  return readDirWithFileTypes$2(uri);
+  return readDirWithFileTypes$3(uri);
 };
 const isReadonly = async uri => {
   return invoke$1('FileSystem.isReadonly', uri);
 };
 const readJson = async uri => {
   if (isHttp(uri)) {
-    return readJson$3(uri);
+    return readJson$1(uri);
   }
   if (isMemory(uri)) {
-    return readJson$1();
+    return readJson$2(uri);
   }
-  return readJson$2(uri);
+  return readJson$3(uri);
 };
 const getRealPath = async path => {
-  return getRealPath$2(path);
+  if (isMemory(path)) return getRealPath$2(path);
+  return getRealPath$3(path);
 };
 const getFileSize = async uri => {
   if (isHttp(uri) || isMemory(uri)) {
@@ -2063,10 +2156,10 @@ const getFileSize = async uri => {
 };
 const readFileAsBlob = async uri => {
   if (isHttp(uri)) {
-    return readFileAsBlob$2(uri);
+    return readFileAsBlob$1(uri);
   }
   if (isMemory(uri)) {
-    return readFileAsBlob$1(uri);
+    return readFileAsBlob$2(uri);
   }
   if (uri.startsWith('file:///')) {
     const rest = uri.slice('file:///'.length);
@@ -2081,31 +2174,35 @@ const readFileAsBlob = async uri => {
   throw new Error('uri not supported');
 };
 const stat = async dirent => {
-  return stat$2(dirent);
+  if (isMemory(dirent)) return stat$2(dirent);
+  return stat$3(dirent);
 };
 const exists = async uri => {
   if (isFetch(uri) || isHtml(uri)) {
     return invoke$2('FileSystem.exists', uri);
   }
   if (isHttp(uri)) {
-    return exists$3(uri);
+    return exists$1(uri);
   }
   if (isMemory(uri)) {
-    return invoke$2('FileSystem.exists', uri);
+    return exists$2(uri);
   }
-  return exists$2(uri);
+  return exists$3(uri);
 };
 const createFile = async uri => {
   if (isMemory(uri)) {
-    return createFile$1(uri);
+    return createFile$2(uri);
   }
-  return writeFile$2(uri, '');
+  return writeFile$3(uri, '');
 };
 const writeFile = async (uri, content) => {
-  if (isMemory(uri) || isProviderUri(uri)) {
+  if (isMemory(uri)) {
+    return writeFile$2(uri, content);
+  }
+  if (isProviderUri(uri)) {
     return invoke$2('FileSystem.writeFile', uri, content);
   }
-  return writeFile$2(uri, content);
+  return writeFile$3(uri, content);
 };
 const getBytes = async blob => {
   if (blob.bytes) {
@@ -2122,22 +2219,27 @@ const writeBlob = async (uri, blob) => {
 };
 const mkdir = async uri => {
   if (isMemory(uri)) {
-    await invoke$2('FileSystem.mkdir', uri);
+    await mkdir$2(uri);
     return;
   }
-  return mkdir$2(uri);
+  return mkdir$3(uri);
 };
 const rename = async (oldUri, newUri) => {
   if (isMemory(oldUri) || isMemory(newUri)) {
-    return rename$1(oldUri, newUri);
+    return rename$2(oldUri, newUri);
   }
-  return rename$2(oldUri, newUri);
+  return rename$3(oldUri, newUri);
 };
 const copy = async (oldUri, newUri) => {
-  return copy$2(oldUri, newUri);
+  if (isMemory(oldUri) && isMemory(newUri)) return copy$2(oldUri, newUri);
+  return copy$3(oldUri, newUri);
 };
 const getFolderSize = async uri => {
-  return getFolderSize$2(uri);
+  return getFolderSize$3(uri);
+};
+const getPathSeparator = async uri => {
+  if (isMemory(uri)) return getPathSeparator$1();
+  return invoke$1('FileSystem.getPathSeparator', uri);
 };
 
 const FileSystemDisk = {
@@ -2150,6 +2252,7 @@ const FileSystemDisk = {
    getFileHashes,
    getFileSize,
    getFolderSize,
+   getPathSeparator,
    getRealPath,
    isReadonly,
    mkdir,
@@ -2596,10 +2699,13 @@ const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) =
 };
 
 const commandMap = {
+  'ApplicationFileSystem.dispose': dispose,
+  'ApplicationFileSystem.execute': execute,
   'Blob.base64StringToBlob': base64StringToBlob,
   'Blob.binaryStringToBlob': binaryStringToBlob,
   'Blob.blobToBinaryString': blobToBinaryString,
   'FileSystem.appendFile': appendFile,
+  'FileSystem.connect': connect,
   'FileSystem.copy': copy,
   'FileSystem.createFile': createFile,
   'FileSystem.executeWatchCallback': executeWatchCallback,
@@ -2608,6 +2714,7 @@ const commandMap = {
   'FileSystem.getFileHashes': getFileHashes,
   'FileSystem.getFileSize': getFileSize,
   'FileSystem.getFolderSize': getFolderSize,
+  'FileSystem.getPathSeparator': getPathSeparator,
   'FileSystem.getRealPath': getRealPath,
   'FileSystem.glob': glob,
   'FileSystem.handleMessagePort': handleMessagePort,
@@ -2625,9 +2732,15 @@ const commandMap = {
   'FileSystem.watchFile': watchFile,
   'FileSystem.writeBlob': writeBlob,
   'FileSystem.writeFile': writeFile,
+  'FileSystemMemory.getFiles': getFiles,
   'Initialize.initialize': initialize
 };
 
+const CommandMap = {
+   __proto__: null,
+   commandMap
+};
+
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
 const state = Object.create(null);