adnbn 0.0.49 → 0.0.50

package/dist/browser/index.cjs

@@ -29,14 +29,10 @@ function handleListener(target, callback) {
 
 // src/browser/runtime.ts
 var runtime = () => browser().runtime;
-var backgroundPaths = [
-  "/_generated_background_page.view"
-];
-var getId = () => runtime().id;
-var getUrl = (path) => runtime().getURL(path);
-var getManifest = () => runtime().getManifest();
-var getManifestVersion = () => getManifest().manifest_version;
-var getRuntimeContexts = (filter) => new Promise((resolve, reject) => {
+var backgroundPaths = ["/_generated_background_page.view"];
+var connect = (extensionId, connectInfo) => runtime().connect(extensionId, connectInfo);
+var connectNative = (application) => runtime().connectNative(application);
+var getContexts = (filter) => new Promise((resolve, reject) => {
   runtime().getContexts(filter, (contexts) => {
     try {
       throwRuntimeError();
@@ -46,6 +42,17 @@ var getRuntimeContexts = (filter) => new Promise((resolve, reject) => {
     }
   });
 });
+var getManifest = () => runtime().getManifest();
+var getPackageDirectoryEntry = () => new Promise((resolve, reject) => {
+  runtime().getPackageDirectoryEntry((directoryEntry) => {
+    try {
+      throwRuntimeError();
+      resolve(directoryEntry);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
 var getPlatformInfo = () => new Promise((resolve, reject) => {
   runtime().getPlatformInfo((platformInfo) => {
     try {
@@ -56,6 +63,61 @@ var getPlatformInfo = () => new Promise((resolve, reject) => {
     }
   });
 });
+var getUrl = (path) => runtime().getURL(path);
+var openOptionsPage = () => new Promise((resolve, reject) => {
+  runtime().openOptionsPage(() => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var reload = () => runtime().reload();
+var requestUpdateCheck = () => new Promise((resolve, reject) => {
+  runtime().requestUpdateCheck((status, details) => {
+    try {
+      throwRuntimeError();
+      resolve({ status, details });
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var restart = () => runtime().restart();
+var restartAfterDelay = (seconds) => new Promise((resolve, reject) => {
+  runtime().restartAfterDelay(seconds, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var sendMessage = (message) => new Promise((resolve, reject) => {
+  runtime().sendMessage(message, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setUninstallURL = (url) => new Promise((resolve, reject) => {
+  runtime().setUninstallURL(url, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getId = () => runtime().id;
+var getManifestVersion = () => getManifest().manifest_version;
 var isManifestVersion3 = () => getManifestVersion() === 3;
 var isBackground = () => {
   if (!getId()) {
@@ -76,28 +138,125 @@ var throwRuntimeError = () => {
     throw new Error(error.message);
   }
 };
-var sendMessage = (message) => new Promise((resolve, reject) => {
-  runtime().sendMessage(message, (response) => {
+var onConnect = (callback) => {
+  return handleListener(runtime().onConnect, callback);
+};
+var onConnectExternal = (callback) => {
+  return handleListener(runtime().onConnectExternal, callback);
+};
+var onInstalled = (callback) => {
+  return handleListener(runtime().onInstalled, callback);
+};
+var onMessage = (callback) => {
+  return handleListener(runtime().onMessage, callback);
+};
+var onMessageExternal = (callback) => {
+  return handleListener(runtime().onMessageExternal, callback);
+};
+var onRestartRequired = (callback) => {
+  return handleListener(runtime().onRestartRequired, callback);
+};
+var onStartup = (callback) => {
+  return handleListener(runtime().onStartup, callback);
+};
+var onSuspend = (callback) => {
+  return handleListener(runtime().onSuspend, callback);
+};
+var onSuspendCanceled = (callback) => {
+  return handleListener(runtime().onSuspendCanceled, callback);
+};
+var onUpdateAvailable = (callback) => {
+  return handleListener(runtime().onUpdateAvailable, callback);
+};
+var onUserScriptConnect = (callback) => {
+  return handleListener(runtime().onUserScriptConnect, callback);
+};
+var onUserScriptMessage = (callback) => {
+  return handleListener(runtime().onUserScriptMessage, callback);
+};
+
+// src/main/env.ts
+var getEnv = (key, defaults) => {
+  const env = process.env;
+  return env[key] ?? defaults;
+};
+var getBrowser = () => {
+  const browser2 = getEnv("BROWSER");
+  if (browser2 === void 0) {
+    throw new Error("Browser is not defined");
+  }
+  return browser2;
+};
+var isBrowser = (browser2) => {
+  return getBrowser() === browser2;
+};
+
+// src/browser/sidebar.ts
+var sidePanel = () => browser().sidePanel;
+var getSidebarOptions = (tabId) => new Promise((resolve, reject) => {
+  sidePanel().getOptions({ tabId }, (options) => {
     try {
       throwRuntimeError();
-      resolve(response);
+      resolve(options);
     } catch (e) {
       reject(e);
     }
   });
 });
-var onRuntimeInstalled = (callback) => {
-  return handleListener(runtime().onInstalled, callback);
+var getSidebarBehavior = () => new Promise((resolve, reject) => {
+  sidePanel().getPanelBehavior((behavior) => {
+    try {
+      throwRuntimeError();
+      resolve(behavior);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var openSidebar = (options) => new Promise((resolve, reject) => {
+  sidePanel().open(options, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setSidebarOptions = (options) => new Promise((resolve, reject) => {
+  sidePanel().setOptions(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setSidebarBehavior = (behavior) => new Promise((resolve, reject) => {
+  sidePanel().setPanelBehavior(behavior || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var isSidebarAvailable = () => {
+  return isBrowser("opera" /* Opera */) && opr.sidebarAction;
 };
-var onMessage = (callback) => {
-  return handleListener(runtime().onMessage, callback);
+var setSidebarBadgeText = (details) => {
+  isSidebarAvailable() && opr.sidebarAction.setBadgeText(details);
+};
+var setSidebarBadgeBgColor = (details) => {
+  isSidebarAvailable() && opr.sidebarAction.setBadgeBackgroundColor(details);
 };
 
 // src/browser/action.ts
 var action = () => isManifestVersion3() ? browser().action : browser().browserAction;
-var setActionBadgeText = (tabId, text) => new Promise((resolve, reject) => {
-  const details = { text: text.toString(), tabId };
-  action().setBadgeText(details, () => {
+var disableAction = (tabId) => new Promise((resolve, reject) => {
+  action().disable(tabId, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -106,10 +265,8 @@ var setActionBadgeText = (tabId, text) => new Promise((resolve, reject) => {
     }
   });
 });
-var clearActionBadgeText = (tabId) => setActionBadgeText(tabId, "");
-var setActionBadgeBgColor = (tabId, color) => new Promise((resolve, reject) => {
-  const details = { color, tabId };
-  action().setBadgeBackgroundColor(details, () => {
+var enableAction = (tabId) => new Promise((resolve, reject) => {
+  action().enable(tabId, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -118,97 +275,117 @@ var setActionBadgeBgColor = (tabId, color) => new Promise((resolve, reject) => {
     }
   });
 });
-var setActionBadgeTextColor = async (tabId, color) => {
-  if (!isManifestVersion3()) {
-    return;
-  }
-  const root = action();
-  await root.setBadgeTextColor({ color, tabId });
-};
-var setActionIcon = (tabId, icon) => new Promise((resolve, reject) => {
-  action().setIcon({ tabId, path: icon }, () => {
+var getBadgeBgColor = (tabId) => new Promise((resolve, reject) => {
+  action().getBadgeBackgroundColor({ tabId }, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getBadgeText = (tabId) => new Promise((resolve, reject) => {
+  action().getBadgeText({ tabId }, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getBadgeTextColor = (tabId) => new Promise((resolve, reject) => {
+  action().getBadgeTextColor({ tabId }, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getActionPopup = (tabId) => new Promise((resolve, reject) => {
+  action().getPopup({ tabId }, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getActionTitle = (tabId) => new Promise((resolve, reject) => {
+  action().getTitle({ tabId }, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getActionUserSetting = () => new Promise((resolve, reject) => {
+  action().getUserSettings((result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var isActionEnabled = (tabId) => new Promise((resolve, reject) => {
+  action().isEnabled(tabId, (isEnabled) => {
+    try {
+      throwRuntimeError();
+      resolve(isEnabled);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var openActionPopup = (windowId) => action().openPopup({ windowId });
+var setBadgeBgColor = (color, tabId) => new Promise((resolve, reject) => {
+  action().setBadgeBackgroundColor({ color, tabId }, () => {
     try {
       throwRuntimeError();
+      setSidebarBadgeBgColor({ color, tabId });
       resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-var getActionDefaultPopup = () => {
-  const manifest = getManifest();
-  return isManifestVersion3() ? manifest.action.default_popup : manifest.browser_action.default_popup;
-};
-var onActionClicked = (callback) => {
-  return handleListener(action().onClicked, callback);
-};
-
-// src/browser/command.ts
-var commands = () => browser().commands;
-var isSupportCommands = () => !!commands;
-var getAllCommands = () => new Promise((resolve, reject) => {
-  commands().getAll((commands2) => {
+var setBadgeText = (text, tabId) => new Promise((resolve, reject) => {
+  action().setBadgeText({ tabId, text: text.toString() }, () => {
     try {
       throwRuntimeError();
-      resolve(commands2);
+      setSidebarBadgeText({ tabId, text: text.toString() });
+      resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-var onCommand = (callback) => {
-  return handleListener(commands().onCommand, callback);
-};
-
-// src/main/env.ts
-var getEnv = (key, defaults) => {
-  const env = process.env;
-  return env[key] ?? defaults;
-};
-var getBrowser = () => {
-  const browser2 = getEnv("BROWSER");
-  if (browser2 === void 0) {
-    throw new Error("Browser is not defined");
+var setBadgeTextColor = async (color, tabId) => {
+  if (!isManifestVersion3()) {
+    return;
   }
-  return browser2;
-};
-var isBrowser = (browser2) => {
-  return getBrowser() === browser2;
+  return action().setBadgeTextColor({ color, tabId });
 };
-
-// src/browser/download.ts
-var downloads = () => browser().downloads;
-var BlockDownloadError = class extends Error {
-};
-var download = (options) => new Promise((resolve, reject) => {
-  downloads().download({ conflictAction: "uniquify", ...options }, (downloadId) => {
+var setActionIcon = (details) => new Promise((resolve, reject) => {
+  action().setIcon(details, () => {
     try {
       throwRuntimeError();
-      if (typeof downloadId !== "number") {
-        throw new Error("Download id not created");
-      }
-      setTimeout(() => {
-        findDownload(downloadId).then((item) => {
-          if (!item) {
-            throw new BlockDownloadError("Download item not found after created");
-          }
-          const { error, state } = item;
-          if (state === "interrupted") {
-            if (error === "USER_CANCELED") {
-              throw new BlockDownloadError("Requires user permission to upload");
-            }
-            throw new Error(`Download error: ${error}`);
-          }
-          resolve(downloadId);
-        }).catch(reject);
-      }, 100);
+      resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-var cancelDownload = (downloadId) => new Promise((resolve, reject) => {
-  downloads().cancel(downloadId, () => {
+var setActionPopup = (popup, tabId) => new Promise((resolve, reject) => {
+  action().setPopup({ popup, tabId }, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -217,31 +394,645 @@ var cancelDownload = (downloadId) => new Promise((resolve, reject) => {
     }
   });
 });
-var queryDownloads = (query) => new Promise((resolve, reject) => {
-  downloads().search(query, (downloadItems) => {
+var setActionTitle = (title, tabId) => new Promise((resolve, reject) => {
+  action().setTitle({ title, tabId }, () => {
     try {
       throwRuntimeError();
-      resolve(downloadItems);
+      resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-var findDownload = async (downloadId) => {
-  const items = await queryDownloads({ id: downloadId });
-  return items[0];
+var getDefaultPopup = () => {
+  const manifest = getManifest();
+  return isManifestVersion3() ? manifest.action.default_popup : manifest.browser_action.default_popup;
 };
-var isDownloadExists = async (downloadId) => {
-  const item = await findDownload(downloadId);
-  return item == null ? void 0 : item.exists;
+var clearBadgeText = (tabId) => setBadgeText("", tabId);
+var onActionClicked = (callback) => {
+  return handleListener(action().onClicked, callback);
 };
-var getDownloadState = async (downloadId) => {
-  if (downloadId === void 0) {
-    return;
-  }
-  const item = await findDownload(downloadId);
-  return item == null ? void 0 : item.state;
+var onActionUserSettingsChanged = (callback) => {
+  return handleListener(action().onUserSettingsChanged, callback);
+};
+
+// src/browser/alarms.ts
+var alarms = () => browser().alarms;
+var clearAlarm = (name) => new Promise((resolve, reject) => {
+  alarms().clear(name || "", (wasCleared) => {
+    try {
+      throwRuntimeError();
+      resolve(wasCleared);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var clearAllAlarm = () => new Promise((resolve, reject) => {
+  alarms().clearAll((wasCleared) => {
+    try {
+      throwRuntimeError();
+      resolve(wasCleared);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var createAlarm = (alarmInfo) => new Promise((resolve, reject) => {
+  const { name = "", ...options } = alarmInfo;
+  alarms().create(name, options, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getAlarm = (name) => new Promise((resolve, reject) => {
+  alarms().get(name || "", (alarm) => {
+    try {
+      throwRuntimeError();
+      resolve(alarm);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getAllAlarm = () => new Promise((resolve, reject) => {
+  alarms().getAll((alarms2) => {
+    try {
+      throwRuntimeError();
+      resolve(alarms2);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var onAlarm = (callback) => {
+  return handleListener(alarms().onAlarm, callback);
 };
+
+// src/browser/audio.ts
+var audio = () => browser().audio;
+var getAudioDevices = (filter) => new Promise((resolve, reject) => {
+  audio().getDevices(filter || {}, (devices) => {
+    try {
+      throwRuntimeError();
+      resolve(devices);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getAudioMute = (streamType) => new Promise((resolve, reject) => {
+  audio().getMute(streamType, (value) => {
+    try {
+      throwRuntimeError();
+      resolve(value);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setAudioActiveDevices = (ids) => new Promise((resolve, reject) => {
+  audio().setActiveDevices(ids || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setAudioMute = (streamType, isMuted) => new Promise((resolve, reject) => {
+  audio().setMute(streamType, isMuted, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setAudioProperties = (id, properties) => new Promise((resolve, reject) => {
+  audio().setProperties(id, properties || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var onAudioDeviceListChanged = (callback) => {
+  return handleListener(audio().onDeviceListChanged, callback);
+};
+var onAudioLevelChanged = (callback) => {
+  return handleListener(audio().onLevelChanged, callback);
+};
+var onAudioMuteChanged = (callback) => {
+  return handleListener(audio().onMuteChanged, callback);
+};
+
+// src/browser/browsingData.ts
+var browsingData = () => browser().browsingData;
+var removeBrowsingData = (options, dataToRemove) => new Promise((resolve, reject) => {
+  browsingData().remove(options, dataToRemove, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeAppcacheData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeAppcache(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeCacheData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeCache(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeCacheStorageData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeCacheStorage(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeCookiesData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeCookies(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeDownloadsData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeDownloads(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeFileSystemsData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeFileSystems(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeFormDataData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeFormData(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeHistoryData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeHistory(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeIndexedDBData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeIndexedDB(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeLocalStorageData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeLocalStorage(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removePasswordsData = (options) => new Promise((resolve, reject) => {
+  browsingData().removePasswords(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeServiceWorkersData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeServiceWorkers(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeWebSQLData = (options) => new Promise((resolve, reject) => {
+  browsingData().removeAppcache(options || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getBrowsingDataSettings = () => new Promise((resolve, reject) => {
+  browsingData().settings((result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+
+// src/browser/commands.ts
+var commands = () => browser().commands;
+var getAllCommands = () => new Promise((resolve, reject) => {
+  commands().getAll((commands2) => {
+    try {
+      throwRuntimeError();
+      resolve(commands2);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var isSupportCommands = () => !!commands();
+var onCommand = (callback) => {
+  return handleListener(commands().onCommand, callback);
+};
+
+// src/browser/contextMenus.ts
+var contextMenus = () => browser().contextMenus;
+var createContextMenu = (createProperties) => new Promise((resolve, reject) => {
+  contextMenus().create(createProperties || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeContextMenu = (menuItemId) => new Promise((resolve, reject) => {
+  contextMenus().remove(menuItemId, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeAllContextMenu = () => new Promise((resolve, reject) => {
+  contextMenus().removeAll(() => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var updateContextMenu = (id, updateProperties) => new Promise((resolve, reject) => {
+  contextMenus().update(id, updateProperties || {}, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var onContextMenuClicked = (callback) => {
+  return handleListener(contextMenus().onClicked, callback);
+};
+
+// src/browser/cookies.ts
+var cookies = () => browser().cookies;
+var getCookie = (details) => new Promise((resolve, reject) => {
+  cookies().get(details, (cookie) => {
+    try {
+      throwRuntimeError();
+      resolve(cookie);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getAllCookie = (details) => new Promise((resolve, reject) => {
+  cookies().getAll(details || {}, (cookies2) => {
+    try {
+      throwRuntimeError();
+      resolve(cookies2);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getAllCookieStores = () => new Promise((resolve, reject) => {
+  cookies().getAllCookieStores((cookieStores) => {
+    try {
+      throwRuntimeError();
+      resolve(cookieStores);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getCookiePartitionKey = (details) => new Promise((resolve, reject) => {
+  cookies().getPartitionKey(details, (details2) => {
+    try {
+      throwRuntimeError();
+      resolve(details2.partitionKey);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeCookie = (details) => new Promise((resolve, reject) => {
+  cookies().remove(details, (details2) => {
+    try {
+      throwRuntimeError();
+      resolve(details2);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setCookie = (details) => new Promise((resolve, reject) => {
+  cookies().set(details, (cookie) => {
+    try {
+      throwRuntimeError();
+      resolve(cookie);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var onCookieChanged = (callback) => {
+  return handleListener(cookies().onChanged, callback);
+};
+
+// src/browser/documentScan.ts
+var documentScan = () => browser().documentScan;
+var cancelDocScanning = (job) => new Promise((resolve, reject) => {
+  documentScan().cancelScan(job, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var closeDocScanner = (scannerHandle) => new Promise((resolve, reject) => {
+  documentScan().closeScanner(scannerHandle, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getDocScannerOptionGroups = (scannerHandle) => new Promise((resolve, reject) => {
+  documentScan().getOptionGroups(scannerHandle, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getDocScannerList = (filter) => new Promise((resolve, reject) => {
+  documentScan().getScannerList(filter, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var openDocScanner = (scannerId) => new Promise((resolve, reject) => {
+  documentScan().openScanner(scannerId, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var readDocScanningData = (job) => new Promise((resolve, reject) => {
+  documentScan().readScanData(job, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var docScanning = (options) => new Promise((resolve, reject) => {
+  documentScan().scan(options, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setDocScannerOptions = (scannerHandle, options) => new Promise((resolve, reject) => {
+  documentScan().setOptions(scannerHandle, options, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var startDocScanning = (scannerHandle, options) => new Promise((resolve, reject) => {
+  documentScan().startScan(scannerHandle, options, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+
+// src/browser/downloads.ts
+var downloads = () => browser().downloads;
+var BlockDownloadError = class extends Error {
+};
+var acceptDownloadDanger = (downloadId) => new Promise((resolve, reject) => {
+  downloads().acceptDanger(downloadId, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var cancelDownload = (downloadId) => new Promise((resolve, reject) => {
+  downloads().cancel(downloadId, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var download = (options) => new Promise((resolve, reject) => {
+  downloads().download({ conflictAction: "uniquify", ...options }, (downloadId) => {
+    try {
+      throwRuntimeError();
+      if (typeof downloadId !== "number") {
+        throw new Error("Download id not created");
+      }
+      setTimeout(() => {
+        findDownload(downloadId).then((item) => {
+          if (!item) {
+            throw new BlockDownloadError("Download item not found after created");
+          }
+          const { error, state } = item;
+          if (state === "interrupted") {
+            if (error === "USER_CANCELED") {
+              throw new BlockDownloadError("Requires user permission to upload");
+            }
+            throw new Error(`Download error: ${error}`);
+          }
+          resolve(downloadId);
+        }).catch(reject);
+      }, 100);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var eraseDownload = (query) => new Promise((resolve, reject) => {
+  downloads().erase(query, (erasedIds) => {
+    try {
+      throwRuntimeError();
+      resolve(erasedIds);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getDownloadFileIcon = (downloadId, options) => new Promise((resolve, reject) => {
+  downloads().getFileIcon(downloadId, options, (iconURL) => {
+    try {
+      throwRuntimeError();
+      resolve(iconURL);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var openDownload = (downloadId) => downloads().open(downloadId);
+var pauseDownload = (downloadId) => new Promise((resolve, reject) => {
+  downloads().pause(downloadId, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeDownloadFile = (downloadId) => new Promise((resolve, reject) => {
+  downloads().removeFile(downloadId, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var resumeDownload = (downloadId) => new Promise((resolve, reject) => {
+  downloads().resume(downloadId, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var searchDownloads = (query) => new Promise((resolve, reject) => {
+  downloads().search(query, (downloadItems) => {
+    try {
+      throwRuntimeError();
+      resolve(downloadItems);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setDownloadsUiOptions = (enabled) => new Promise((resolve, reject) => {
+  downloads().setUiOptions({ enabled }, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var showDownloadFolder = () => downloads().showDefaultFolder();
 var showDownload = async (downloadId) => {
   if (!await isDownloadExists(downloadId)) {
     return false;
@@ -249,7 +1040,21 @@ var showDownload = async (downloadId) => {
   downloads().show(downloadId);
   return true;
 };
-var showDownloadFolder = () => downloads().showDefaultFolder();
+var findDownload = async (downloadId) => {
+  const items = await searchDownloads({ id: downloadId });
+  return items[0];
+};
+var isDownloadExists = async (downloadId) => {
+  const item = await findDownload(downloadId);
+  return item == null ? void 0 : item.exists;
+};
+var getDownloadState = async (downloadId) => {
+  if (downloadId === void 0) {
+    return;
+  }
+  const item = await findDownload(downloadId);
+  return item == null ? void 0 : item.state;
+};
 var getSettingsDownloadsUrl = () => {
   switch (getBrowser()) {
     case "firefox" /* Firefox */:
@@ -263,54 +1068,295 @@ var getSettingsDownloadsUrl = () => {
       return "chrome://settings/downloads";
   }
 };
+var onDownloadsChanged = (callback) => {
+  return handleListener(downloads().onChanged, callback);
+};
 var onDownloadsCreated = (callback) => {
   return handleListener(downloads().onCreated, callback);
 };
-var onDownloadsChanged = (callback) => {
-  return handleListener(downloads().onChanged, callback);
+var onDownloadsDeterminingFilename = (callback) => {
+  return handleListener(downloads().onDeterminingFilename, callback);
+};
+
+// src/browser/extension.ts
+var extension = () => browser().extension;
+var getBackgroundPage = () => extension().getBackgroundPage();
+var getViews = (properties) => extension().getViews(properties);
+var isAllowedFileSchemeAccess = () => new Promise((resolve, reject) => {
+  extension().isAllowedFileSchemeAccess((isAllowedAccess) => {
+    try {
+      throwRuntimeError();
+      resolve(isAllowedAccess);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var isAllowedIncognitoAccess = () => new Promise((resolve, reject) => {
+  extension().isAllowedIncognitoAccess((isAllowedAccess) => {
+    try {
+      throwRuntimeError();
+      resolve(isAllowedAccess);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setUpdateUrlData = (data) => extension().setUpdateUrlData(data);
+
+// src/browser/fileBrowserHandler.ts
+var fileBrowserHandler = () => browser().fileBrowserHandler;
+var onExecute = (callback) => {
+  return handleListener(fileBrowserHandler().onExecute, callback);
+};
+
+// src/browser/history.ts
+var history = () => browser().history;
+var addHistoryUrl = (url) => new Promise((resolve, reject) => {
+  history().addUrl({ url }, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var deleteAllHistory = () => new Promise((resolve, reject) => {
+  history().deleteAll(() => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var deleteRangeHistory = (range) => new Promise((resolve, reject) => {
+  history().deleteRange(range, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var deleteHistoryUrl = (details) => new Promise((resolve, reject) => {
+  history().deleteUrl(details, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getHistoryVisits = (url) => new Promise((resolve, reject) => {
+  history().getVisits({ url }, (results) => {
+    try {
+      throwRuntimeError();
+      resolve(results);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var searchHistory = (query) => new Promise((resolve, reject) => {
+  history().search(query, (results) => {
+    try {
+      throwRuntimeError();
+      resolve(results);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var onVisited = (callback) => {
+  return handleListener(history().onVisited, callback);
+};
+var onVisitRemoved = (callback) => {
+  return handleListener(history().onVisitRemoved, callback);
 };
 
 // src/browser/i18n.ts
 var i18n = () => browser().i18n;
-var canUseNativeI18nMessage = () => typeof i18n().getMessage !== "undefined";
+var detectI18Language = (text) => new Promise((resolve, reject) => {
+  i18n().detectLanguage(text, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getI18nAcceptLanguages = () => new Promise((resolve, reject) => {
+  i18n().getAcceptLanguages((locales) => {
+    try {
+      throwRuntimeError();
+      resolve(locales);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
 var getI18nMessage = (key) => {
   if (!canUseNativeI18nMessage()) {
     return;
   }
   return i18n().getMessage(key);
 };
-var getI18nAcceptLanguages = () => new Promise((resolve, reject) => {
-  i18n().getAcceptLanguages((locales) => {
+var canUseNativeI18nMessage = () => typeof i18n().getMessage !== "undefined";
+var getI18nUILanguage = () => {
+  const i18n2 = browser().i18n;
+  if (!i18n2["getUILanguage"]) {
+    return;
+  }
+  return i18n2.getUILanguage();
+};
+
+// src/browser/idle.ts
+var idle = () => browser().idle;
+var getIdleAutoLockDelay = () => new Promise((resolve, reject) => {
+  idle().getAutoLockDelay((delay) => {
     try {
       throwRuntimeError();
-      resolve(locales);
+      resolve(delay);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var queryIdleState = (detectionIntervalInSeconds) => new Promise((resolve, reject) => {
+  idle().queryState(detectionIntervalInSeconds, (newState) => {
+    try {
+      throwRuntimeError();
+      resolve(newState);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setIdleDetectionInterval = (intervalInSeconds) => idle().setDetectionInterval(intervalInSeconds);
+var onIdleStateChanged = (callback) => {
+  return handleListener(idle().onStateChanged, callback);
+};
+
+// src/browser/management.ts
+var management = () => browser().management;
+var createAppShortcut = async (id) => new Promise((resolve, reject) => {
+  management().createAppShortcut(id, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var generateAppForLink = async (url, title) => new Promise((resolve, reject) => {
+  management().generateAppForLink(url, title, (extensionInfo) => {
+    try {
+      throwRuntimeError();
+      resolve(extensionInfo);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getExtensionInfo = async (id) => new Promise((resolve, reject) => {
+  management().get(id, (extensionInfo) => {
+    try {
+      throwRuntimeError();
+      resolve(extensionInfo);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getAllExtensionInfo = async () => new Promise((resolve, reject) => {
+  management().getAll((extensionsInfo) => {
+    try {
+      throwRuntimeError();
+      resolve(extensionsInfo);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getPermissionWarningsById = async (id) => new Promise((resolve, reject) => {
+  management().getPermissionWarningsById(id, (permissionWarnings) => {
+    try {
+      throwRuntimeError();
+      resolve(permissionWarnings);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getPermissionWarningsByManifest = async (manifestStr) => new Promise((resolve, reject) => {
+  management().getPermissionWarningsByManifest(manifestStr, (permissionWarnings) => {
+    try {
+      throwRuntimeError();
+      resolve(permissionWarnings);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getCurrentExtension = async () => new Promise((resolve, reject) => {
+  management().getSelf((extensionInfo) => {
+    try {
+      throwRuntimeError();
+      resolve(extensionInfo);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var launchExtensionApp = async (id) => new Promise((resolve, reject) => {
+  management().launchApp(id, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setExtensionEnabled = async (id, enabled) => new Promise((resolve, reject) => {
+  management().setEnabled(id, enabled, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var setExtensionLaunchType = async (id, launchType) => new Promise((resolve, reject) => {
+  management().setLaunchType(id, launchType, () => {
+    try {
+      throwRuntimeError();
+      resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-var getI18nUILanguage = () => {
-  const i18n2 = browser().i18n;
-  if (!i18n2["getUILanguage"]) {
-    return;
-  }
-  return i18n2.getUILanguage();
-};
-var detectI18Language = (text) => new Promise((resolve, reject) => {
-  i18n().detectLanguage(text, (result) => {
+var uninstallExtension = async (id, showConfirmDialog) => new Promise((resolve, reject) => {
+  management().uninstall(id, { showConfirmDialog }, () => {
     try {
       throwRuntimeError();
-      resolve(result);
+      resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-
-// src/browser/management.ts
-var management = () => browser().management;
-var uninstallManagementSelf = async (options) => new Promise((resolve, reject) => {
-  management().uninstallSelf(options || {}, () => {
+var uninstallCurrentExtension = async (showConfirmDialog) => new Promise((resolve, reject) => {
+  management().uninstallSelf({ showConfirmDialog }, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -319,10 +1365,31 @@ var uninstallManagementSelf = async (options) => new Promise((resolve, reject) =
     }
   });
 });
+var onExtensionDisabled = (callback) => {
+  return handleListener(management().onDisabled, callback);
+};
+var onExtensionEnabled = (callback) => {
+  return handleListener(management().onEnabled, callback);
+};
+var onExtensionInstalled = (callback) => {
+  return handleListener(management().onInstalled, callback);
+};
+var onExtensionUninstalled = (callback) => {
+  return handleListener(management().onUninstalled, callback);
+};
 
-// src/browser/notification.ts
+// src/browser/notifications.ts
 var notifications = () => browser().notifications;
-var isSupportNotifications = () => !!notifications;
+var clearNotification = (notificationId) => new Promise((resolve, reject) => {
+  notifications().clear(notificationId, (wasCleared) => {
+    try {
+      throwRuntimeError();
+      resolve(wasCleared);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
 var createNotification = (options, notificationId) => new Promise((resolve, reject) => {
   const defaultOptions = {
     type: "basic",
@@ -343,70 +1410,93 @@ var createNotification = (options, notificationId) => new Promise((resolve, reje
     }
   });
 });
-var updateNotification = (options, notificationId) => new Promise((resolve, reject) => {
-  notifications().update(notificationId, options, (wasUpdated) => {
+var getAllNotification = () => new Promise((resolve, reject) => {
+  notifications().getAll((notifications2) => {
     try {
       throwRuntimeError();
-      resolve(wasUpdated);
+      resolve(notifications2);
     } catch (e) {
       reject(e);
     }
   });
 });
-var clearNotification = (notificationId) => new Promise((resolve, reject) => {
-  notifications().clear(notificationId, (wasCleared) => {
+var getNotificationPermissionLevel = () => new Promise((resolve, reject) => {
+  notifications().getPermissionLevel((level) => {
     try {
       throwRuntimeError();
-      resolve(wasCleared);
+      resolve(level);
     } catch (e) {
       reject(e);
     }
   });
 });
-var getAllNotification = () => new Promise((resolve, reject) => {
-  notifications().getAll((notifications2) => {
+var updateNotification = (options, notificationId) => new Promise((resolve, reject) => {
+  notifications().update(notificationId, options, (wasUpdated) => {
     try {
       throwRuntimeError();
-      resolve(notifications2);
+      resolve(wasUpdated);
     } catch (e) {
       reject(e);
     }
   });
 });
+var isSupportNotifications = () => !!notifications();
 var clearAllNotification = async () => {
   const allNotificationIds = Object.keys(await getAllNotification());
   allNotificationIds.forEach((id) => clearNotification(id));
 };
-var getNotificationPermissionLevel = () => new Promise((resolve, reject) => {
-  notifications().getPermissionLevel((level) => {
-    try {
-      throwRuntimeError();
-      resolve(level);
-    } catch (e) {
-      reject(e);
-    }
-  });
-});
+var onNotificationsButtonClicked = (callback) => {
+  if (!isSupportNotifications()) {
+    console.warn("chrome.notifications API is not supported");
+    return () => ({});
+  }
+  return handleListener(notifications().onButtonClicked, callback);
+};
 var onNotificationsClicked = (callback) => {
-  if (!isSupportNotifications()) return () => ({});
+  if (!isSupportNotifications()) {
+    console.warn("chrome.notifications API is not supported");
+    return () => ({});
+  }
   return handleListener(notifications().onClicked, callback);
 };
 var onNotificationsClosed = (callback) => {
-  if (!isSupportNotifications()) return () => ({});
+  if (!isSupportNotifications()) {
+    console.warn("chrome.notifications API is not supported");
+    return () => ({});
+  }
   return handleListener(notifications().onClosed, callback);
 };
-var onNotificationsButtonClicked = (callback) => {
-  if (!isSupportNotifications()) return () => ({});
-  return handleListener(notifications().onButtonClicked, callback);
-};
 var onNotificationsPermissionLevelChanged = (callback) => {
-  if (!isSupportNotifications()) return () => ({});
+  if (!isSupportNotifications()) {
+    console.warn("chrome.notifications API is not supported");
+    return () => ({});
+  }
   return handleListener(notifications().onPermissionLevelChanged, callback);
 };
 
 // src/browser/offscreen.ts
 var offscreen = () => browser().offscreen;
-var hasOffscreenDocument = () => new Promise((resolve, reject) => {
+var closeOffscreen = () => new Promise((resolve, reject) => {
+  offscreen().closeDocument(() => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var createOffscreen = (parameters) => new Promise((resolve, reject) => {
+  offscreen().createDocument(parameters, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var hasOffscreen = () => new Promise((resolve, reject) => {
   offscreen().hasDocument((hasDocument) => {
     try {
       throwRuntimeError();
@@ -416,8 +1506,11 @@ var hasOffscreenDocument = () => new Promise((resolve, reject) => {
     }
   });
 });
-var createOffscreenDocument = (createParameters) => new Promise((resolve, reject) => {
-  offscreen().createDocument(createParameters, () => {
+
+// src/browser/permissions.ts
+var permissions = () => browser().permissions;
+var addHostAccessRequest = (request) => new Promise((resolve, reject) => {
+  permissions().addHostAccessRequest(request || {}, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -426,8 +1519,38 @@ var createOffscreenDocument = (createParameters) => new Promise((resolve, reject
     }
   });
 });
-var removeOffscreenDocument = () => new Promise((resolve, reject) => {
-  offscreen().closeDocument(() => {
+var containsPermissions = (permission) => new Promise((resolve, reject) => {
+  permissions().contains(permission, (result) => {
+    try {
+      throwRuntimeError();
+      resolve(result);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getAllPermissions = () => new Promise((resolve, reject) => {
+  permissions().getAll((permissions2) => {
+    try {
+      throwRuntimeError();
+      resolve(permissions2);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removePermissions = (permission) => new Promise((resolve, reject) => {
+  permissions().remove(permission, (removed) => {
+    try {
+      throwRuntimeError();
+      resolve(removed);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var removeHostAccessRequest = (request) => new Promise((resolve, reject) => {
+  permissions().removeHostAccessRequest(request || {}, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -436,10 +1559,25 @@ var removeOffscreenDocument = () => new Promise((resolve, reject) => {
     }
   });
 });
+var requestPermissions = (permission) => new Promise((resolve, reject) => {
+  permissions().request(permission, (granted) => {
+    try {
+      throwRuntimeError();
+      resolve(granted);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var onPermissionsAdded = (callback) => {
+  return handleListener(permissions().onAdded, callback);
+};
+var onPermissionsRemoved = (callback) => {
+  return handleListener(permissions().onRemoved, callback);
+};
 
 // src/browser/scripting.ts
 var scripting = () => browser().scripting;
-var isAvailableScripting = () => !!scripting();
 var executeScript = (injection) => new Promise((resolve, reject) => {
   scripting().executeScript(injection, (result) => {
     try {
@@ -450,18 +1588,18 @@ var executeScript = (injection) => new Promise((resolve, reject) => {
     }
   });
 });
-var registerContentScripts = (scripts) => new Promise((resolve, reject) => {
-  scripting().registerContentScripts(scripts, () => {
+var getRegisteredContentScripts = (filter) => new Promise((resolve, reject) => {
+  scripting().getRegisteredContentScripts(filter || {}, (scripts) => {
     try {
       throwRuntimeError();
-      resolve();
+      resolve(scripts);
     } catch (e) {
       reject(e);
     }
   });
 });
-var unregisterContentScripts = (filter) => new Promise((resolve, reject) => {
-  scripting().unregisterContentScripts(filter || {}, () => {
+var insertScriptingCSS = (injection) => new Promise((resolve, reject) => {
+  scripting().insertCSS(injection, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -470,8 +1608,8 @@ var unregisterContentScripts = (filter) => new Promise((resolve, reject) => {
     }
   });
 });
-var updateContentScripts = (scripts) => new Promise((resolve, reject) => {
-  scripting().updateContentScripts(scripts, () => {
+var registerContentScripts = (scripts) => new Promise((resolve, reject) => {
+  scripting().registerContentScripts(scripts, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -480,18 +1618,18 @@ var updateContentScripts = (scripts) => new Promise((resolve, reject) => {
     }
   });
 });
-var getRegisteredContentScripts = (filter) => new Promise((resolve, reject) => {
-  scripting().getRegisteredContentScripts(filter || {}, (scripts) => {
+var removeScriptingCSS = (injection) => new Promise((resolve, reject) => {
+  scripting().removeCSS(injection, () => {
     try {
       throwRuntimeError();
-      resolve(scripts);
+      resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-var insertScriptingCSS = (injection) => new Promise((resolve, reject) => {
-  scripting().insertCSS(injection, () => {
+var unregisterContentScripts = (filter) => new Promise((resolve, reject) => {
+  scripting().unregisterContentScripts(filter || {}, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -500,8 +1638,8 @@ var insertScriptingCSS = (injection) => new Promise((resolve, reject) => {
     }
   });
 });
-var removeScriptingCSS = (injection) => new Promise((resolve, reject) => {
-  scripting().removeCSS(injection, () => {
+var updateContentScripts = (scripts) => new Promise((resolve, reject) => {
+  scripting().updateContentScripts(scripts, () => {
     try {
       throwRuntimeError();
       resolve();
@@ -510,6 +1648,7 @@ var removeScriptingCSS = (injection) => new Promise((resolve, reject) => {
     }
   });
 });
+var isAvailableScripting = () => !!scripting();
 
 // src/browser/tabCapture.ts
 var tabCapture = () => browser().tabCapture;
@@ -547,7 +1686,7 @@ var onCaptureStatusChanged = (callback) => {
   return handleListener(tabCapture().onStatusChanged, callback);
 };
 
-// src/browser/tab.ts
+// src/browser/tabs.ts
 var tabs = () => browser().tabs;
 var captureVisibleTab = (windowId, options) => new Promise((resolve, reject) => {
   tabs().captureVisibleTab(windowId, options, (dataUrl) => {
@@ -559,6 +1698,7 @@ var captureVisibleTab = (windowId, options) => new Promise((resolve, reject) =>
     }
   });
 });
+var connectTab = (tabId, connectInfo) => tabs().connect(tabId, connectInfo);
 var createTab = (properties) => new Promise((resolve, reject) => {
   tabs().create(properties, (tab) => {
     try {
@@ -729,6 +1869,16 @@ var removeTab = (tabId) => new Promise((resolve, reject) => {
     }
   });
 });
+var sendTabMessage = (tabId, message, options = {}) => new Promise((resolve, reject) => {
+  tabs().sendMessage(tabId, message, options, (response) => {
+    try {
+      throwRuntimeError();
+      resolve(response);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
 var setTabZoom = (tabId, zoomFactor) => new Promise((resolve, reject) => {
   tabs().setZoom(tabId, zoomFactor, () => {
     try {
@@ -779,16 +1929,6 @@ var executeScriptTab = (tabId, details) => new Promise((resolve, reject) => {
     }
   });
 });
-var sendTabMessage = (tabId, message, options = {}) => new Promise((resolve, reject) => {
-  tabs().sendMessage(tabId, message, options, (response) => {
-    try {
-      throwRuntimeError();
-      resolve(response);
-    } catch (e) {
-      reject(e);
-    }
-  });
-});
 var getTabUrl = async (tabId) => {
   const tab = await findTabById(tabId);
   if (!tab) {
@@ -859,23 +1999,83 @@ var onTabZoomChange = (callback) => {
   return handleListener(tabs().onZoomChange, callback);
 };
 
-// src/browser/webNavigation.ts
-var webNavigation = () => browser().webNavigation;
-var getWebNavigationFrame = (details) => new Promise((resolve, reject) => {
-  webNavigation().getFrame(details, (frame) => {
+// src/browser/userScripts.ts
+var userScripts = () => browser().userScripts;
+var configureUserScriptsWorld = (properties) => new Promise((resolve, reject) => {
+  userScripts().configureWorld(properties || {}, () => {
     try {
       throwRuntimeError();
-      if (!frame) {
-        throw new Error("No frame found for the specified tabId");
-      }
-      resolve(frame);
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getUserScripts = (ids) => new Promise((resolve, reject) => {
+  userScripts().getScripts({ ids }, (scripts) => {
+    try {
+      throwRuntimeError();
+      resolve(scripts);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var getUserScriptsWorldConfigs = () => new Promise((resolve, reject) => {
+  userScripts().getWorldConfigurations((worlds) => {
+    try {
+      throwRuntimeError();
+      resolve(worlds);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var registerUserScripts = (scripts) => new Promise((resolve, reject) => {
+  userScripts().register(scripts, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var resetUserScriptsWorldConfigs = (worldId) => new Promise((resolve, reject) => {
+  userScripts().resetWorldConfiguration(worldId, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var unregisterUserScripts = (ids) => new Promise((resolve, reject) => {
+  userScripts().unregister({ ids }, () => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
+var updateUserScripts = (scripts) => new Promise((resolve, reject) => {
+  userScripts().update(scripts, () => {
+    try {
+      throwRuntimeError();
+      resolve();
     } catch (e) {
       reject(e);
     }
   });
 });
-var getWebNavigationAllFrames = (details) => new Promise((resolve, reject) => {
-  webNavigation().getAllFrames(details, (frames) => {
+
+// src/browser/webNavigation.ts
+var webNavigation = () => browser().webNavigation;
+var getAllFrames = (tabId) => new Promise((resolve, reject) => {
+  webNavigation().getAllFrames({ tabId }, (frames) => {
     try {
       throwRuntimeError();
       if (!frames) {
@@ -887,6 +2087,19 @@ var getWebNavigationAllFrames = (details) => new Promise((resolve, reject) => {
     }
   });
 });
+var getFrame = (details) => new Promise((resolve, reject) => {
+  webNavigation().getFrame(details, (frame) => {
+    try {
+      throwRuntimeError();
+      if (!frame) {
+        throw new Error("No frame found for the specified tabId");
+      }
+      resolve(frame);
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
 var onWebNavigationBeforeNavigate = (callback, filters) => {
   const listener = safeListener(callback);
   webNavigation().onBeforeNavigate.addListener(listener, filters);
@@ -946,6 +2159,16 @@ var hasSymbols = (str) => {
 
 // src/browser/webRequest.ts
 var webRequest = () => browser().webRequest;
+var handlerWebRequestBehaviorChanged = () => new Promise((resolve, reject) => {
+  webRequest().handlerBehaviorChanged(() => {
+    try {
+      throwRuntimeError();
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+});
 var getWebRequestInitiatorUrl = async (request) => {
   const { tabId } = request;
   let initiatorUrl;
@@ -964,16 +2187,6 @@ var getWebRequestInitiatorUrl = async (request) => {
   }
   return initiatorUrl;
 };
-var handlerWebRequestBehaviorChanged = () => new Promise((resolve, reject) => {
-  webRequest().handlerBehaviorChanged(() => {
-    try {
-      throwRuntimeError();
-      resolve();
-    } catch (e) {
-      reject(e);
-    }
-  });
-});
 var onWebRequestAuthRequired = (callback, filter, extraInfoSpec) => {
   const listener = safeListener(callback);
   webRequest().onAuthRequired.addListener(listener, filter, extraInfoSpec);
@@ -1021,80 +2234,165 @@ var onWebRequestSendHeaders = (callback, filter, extraInfoSpec) => {
 };
 
 exports.BlockDownloadError = BlockDownloadError;
+exports.acceptDownloadDanger = acceptDownloadDanger;
+exports.addHistoryUrl = addHistoryUrl;
+exports.addHostAccessRequest = addHostAccessRequest;
 exports.browser = browser;
 exports.canUseNativeI18nMessage = canUseNativeI18nMessage;
+exports.cancelDocScanning = cancelDocScanning;
 exports.cancelDownload = cancelDownload;
 exports.captureVisibleTab = captureVisibleTab;
-exports.clearActionBadgeText = clearActionBadgeText;
+exports.clearAlarm = clearAlarm;
+exports.clearAllAlarm = clearAllAlarm;
 exports.clearAllNotification = clearAllNotification;
+exports.clearBadgeText = clearBadgeText;
 exports.clearNotification = clearNotification;
+exports.closeDocScanner = closeDocScanner;
+exports.closeOffscreen = closeOffscreen;
+exports.configureUserScriptsWorld = configureUserScriptsWorld;
+exports.connect = connect;
+exports.connectNative = connectNative;
+exports.connectTab = connectTab;
+exports.containsPermissions = containsPermissions;
+exports.createAlarm = createAlarm;
+exports.createAppShortcut = createAppShortcut;
+exports.createContextMenu = createContextMenu;
 exports.createNotification = createNotification;
-exports.createOffscreenDocument = createOffscreenDocument;
+exports.createOffscreen = createOffscreen;
 exports.createTab = createTab;
 exports.createTabCapture = createTabCapture;
+exports.deleteAllHistory = deleteAllHistory;
+exports.deleteHistoryUrl = deleteHistoryUrl;
+exports.deleteRangeHistory = deleteRangeHistory;
 exports.detectI18Language = detectI18Language;
 exports.detectTabLanguage = detectTabLanguage;
+exports.disableAction = disableAction;
 exports.discardTab = discardTab;
+exports.docScanning = docScanning;
 exports.download = download;
 exports.duplicateTab = duplicateTab;
+exports.enableAction = enableAction;
+exports.eraseDownload = eraseDownload;
 exports.executeScript = executeScript;
 exports.executeScriptTab = executeScriptTab;
 exports.findDownload = findDownload;
 exports.findTab = findTab;
 exports.findTabById = findTabById;
-exports.getActionDefaultPopup = getActionDefaultPopup;
+exports.generateAppForLink = generateAppForLink;
+exports.getActionPopup = getActionPopup;
+exports.getActionTitle = getActionTitle;
+exports.getActionUserSetting = getActionUserSetting;
 exports.getActiveTab = getActiveTab;
+exports.getAlarm = getAlarm;
+exports.getAllAlarm = getAllAlarm;
 exports.getAllCommands = getAllCommands;
+exports.getAllCookie = getAllCookie;
+exports.getAllCookieStores = getAllCookieStores;
+exports.getAllExtensionInfo = getAllExtensionInfo;
+exports.getAllFrames = getAllFrames;
 exports.getAllNotification = getAllNotification;
+exports.getAllPermissions = getAllPermissions;
+exports.getAudioDevices = getAudioDevices;
+exports.getAudioMute = getAudioMute;
+exports.getBackgroundPage = getBackgroundPage;
+exports.getBadgeBgColor = getBadgeBgColor;
+exports.getBadgeText = getBadgeText;
+exports.getBadgeTextColor = getBadgeTextColor;
+exports.getBrowsingDataSettings = getBrowsingDataSettings;
 exports.getCaptureMediaStreamId = getCaptureMediaStreamId;
 exports.getCapturedTabs = getCapturedTabs;
+exports.getContexts = getContexts;
+exports.getCookie = getCookie;
+exports.getCookiePartitionKey = getCookiePartitionKey;
+exports.getCurrentExtension = getCurrentExtension;
 exports.getCurrentTab = getCurrentTab;
+exports.getDefaultPopup = getDefaultPopup;
+exports.getDocScannerList = getDocScannerList;
+exports.getDocScannerOptionGroups = getDocScannerOptionGroups;
+exports.getDownloadFileIcon = getDownloadFileIcon;
 exports.getDownloadState = getDownloadState;
+exports.getExtensionInfo = getExtensionInfo;
+exports.getFrame = getFrame;
+exports.getHistoryVisits = getHistoryVisits;
 exports.getI18nAcceptLanguages = getI18nAcceptLanguages;
 exports.getI18nMessage = getI18nMessage;
 exports.getI18nUILanguage = getI18nUILanguage;
 exports.getId = getId;
+exports.getIdleAutoLockDelay = getIdleAutoLockDelay;
 exports.getManifest = getManifest;
 exports.getManifestVersion = getManifestVersion;
 exports.getNotificationPermissionLevel = getNotificationPermissionLevel;
+exports.getPackageDirectoryEntry = getPackageDirectoryEntry;
+exports.getPermissionWarningsById = getPermissionWarningsById;
+exports.getPermissionWarningsByManifest = getPermissionWarningsByManifest;
 exports.getPlatformInfo = getPlatformInfo;
 exports.getRegisteredContentScripts = getRegisteredContentScripts;
-exports.getRuntimeContexts = getRuntimeContexts;
 exports.getSettingsDownloadsUrl = getSettingsDownloadsUrl;
+exports.getSidebarBehavior = getSidebarBehavior;
+exports.getSidebarOptions = getSidebarOptions;
 exports.getTab = getTab;
 exports.getTabUrl = getTabUrl;
 exports.getTabZoom = getTabZoom;
 exports.getTabZoomSettings = getTabZoomSettings;
 exports.getUrl = getUrl;
-exports.getWebNavigationAllFrames = getWebNavigationAllFrames;
-exports.getWebNavigationFrame = getWebNavigationFrame;
+exports.getUserScripts = getUserScripts;
+exports.getUserScriptsWorldConfigs = getUserScriptsWorldConfigs;
+exports.getViews = getViews;
 exports.getWebRequestInitiatorUrl = getWebRequestInitiatorUrl;
 exports.goTabBack = goTabBack;
 exports.goTabForward = goTabForward;
 exports.groupTabs = groupTabs;
 exports.handlerWebRequestBehaviorChanged = handlerWebRequestBehaviorChanged;
-exports.hasOffscreenDocument = hasOffscreenDocument;
+exports.hasOffscreen = hasOffscreen;
 exports.highlightTab = highlightTab;
 exports.insertScriptingCSS = insertScriptingCSS;
+exports.isActionEnabled = isActionEnabled;
+exports.isAllowedFileSchemeAccess = isAllowedFileSchemeAccess;
+exports.isAllowedIncognitoAccess = isAllowedIncognitoAccess;
 exports.isAvailableScripting = isAvailableScripting;
 exports.isBackground = isBackground;
 exports.isDownloadExists = isDownloadExists;
 exports.isManifestVersion3 = isManifestVersion3;
+exports.isSidebarAvailable = isSidebarAvailable;
 exports.isSupportCommands = isSupportCommands;
 exports.isSupportNotifications = isSupportNotifications;
+exports.launchExtensionApp = launchExtensionApp;
 exports.moveTab = moveTab;
 exports.moveTabs = moveTabs;
 exports.onActionClicked = onActionClicked;
+exports.onActionUserSettingsChanged = onActionUserSettingsChanged;
+exports.onAlarm = onAlarm;
+exports.onAudioDeviceListChanged = onAudioDeviceListChanged;
+exports.onAudioLevelChanged = onAudioLevelChanged;
+exports.onAudioMuteChanged = onAudioMuteChanged;
 exports.onCaptureStatusChanged = onCaptureStatusChanged;
 exports.onCommand = onCommand;
+exports.onConnect = onConnect;
+exports.onConnectExternal = onConnectExternal;
+exports.onContextMenuClicked = onContextMenuClicked;
+exports.onCookieChanged = onCookieChanged;
 exports.onDownloadsChanged = onDownloadsChanged;
 exports.onDownloadsCreated = onDownloadsCreated;
+exports.onDownloadsDeterminingFilename = onDownloadsDeterminingFilename;
+exports.onExecute = onExecute;
+exports.onExtensionDisabled = onExtensionDisabled;
+exports.onExtensionEnabled = onExtensionEnabled;
+exports.onExtensionInstalled = onExtensionInstalled;
+exports.onExtensionUninstalled = onExtensionUninstalled;
+exports.onIdleStateChanged = onIdleStateChanged;
+exports.onInstalled = onInstalled;
 exports.onMessage = onMessage;
+exports.onMessageExternal = onMessageExternal;
 exports.onNotificationsButtonClicked = onNotificationsButtonClicked;
 exports.onNotificationsClicked = onNotificationsClicked;
 exports.onNotificationsClosed = onNotificationsClosed;
 exports.onNotificationsPermissionLevelChanged = onNotificationsPermissionLevelChanged;
-exports.onRuntimeInstalled = onRuntimeInstalled;
+exports.onPermissionsAdded = onPermissionsAdded;
+exports.onPermissionsRemoved = onPermissionsRemoved;
+exports.onRestartRequired = onRestartRequired;
+exports.onStartup = onStartup;
+exports.onSuspend = onSuspend;
+exports.onSuspendCanceled = onSuspendCanceled;
 exports.onTabActivated = onTabActivated;
 exports.onTabAttached = onTabAttached;
 exports.onTabCreated = onTabCreated;
@@ -1105,6 +2403,11 @@ exports.onTabRemoved = onTabRemoved;
 exports.onTabReplaced = onTabReplaced;
 exports.onTabUpdated = onTabUpdated;
 exports.onTabZoomChange = onTabZoomChange;
+exports.onUpdateAvailable = onUpdateAvailable;
+exports.onUserScriptConnect = onUserScriptConnect;
+exports.onUserScriptMessage = onUserScriptMessage;
+exports.onVisitRemoved = onVisitRemoved;
+exports.onVisited = onVisited;
 exports.onWebNavigationBeforeNavigate = onWebNavigationBeforeNavigate;
 exports.onWebNavigationCommitted = onWebNavigationCommitted;
 exports.onWebNavigationCompleted = onWebNavigationCompleted;
@@ -1123,34 +2426,92 @@ exports.onWebRequestErrorOccurred = onWebRequestErrorOccurred;
 exports.onWebRequestHeadersReceived = onWebRequestHeadersReceived;
 exports.onWebRequestResponseStarted = onWebRequestResponseStarted;
 exports.onWebRequestSendHeaders = onWebRequestSendHeaders;
+exports.openActionPopup = openActionPopup;
+exports.openDocScanner = openDocScanner;
+exports.openDownload = openDownload;
+exports.openOptionsPage = openOptionsPage;
 exports.openOrCreateTab = openOrCreateTab;
-exports.queryDownloads = queryDownloads;
+exports.openSidebar = openSidebar;
+exports.pauseDownload = pauseDownload;
+exports.queryIdleState = queryIdleState;
 exports.queryTabIds = queryTabIds;
 exports.queryTabs = queryTabs;
+exports.readDocScanningData = readDocScanningData;
 exports.registerContentScripts = registerContentScripts;
+exports.registerUserScripts = registerUserScripts;
+exports.reload = reload;
 exports.reloadTab = reloadTab;
-exports.removeOffscreenDocument = removeOffscreenDocument;
+exports.removeAllContextMenu = removeAllContextMenu;
+exports.removeAppcacheData = removeAppcacheData;
+exports.removeBrowsingData = removeBrowsingData;
+exports.removeCacheData = removeCacheData;
+exports.removeCacheStorageData = removeCacheStorageData;
+exports.removeContextMenu = removeContextMenu;
+exports.removeCookie = removeCookie;
+exports.removeCookiesData = removeCookiesData;
+exports.removeDownloadFile = removeDownloadFile;
+exports.removeDownloadsData = removeDownloadsData;
+exports.removeFileSystemsData = removeFileSystemsData;
+exports.removeFormDataData = removeFormDataData;
+exports.removeHistoryData = removeHistoryData;
+exports.removeHostAccessRequest = removeHostAccessRequest;
+exports.removeIndexedDBData = removeIndexedDBData;
+exports.removeLocalStorageData = removeLocalStorageData;
+exports.removePasswordsData = removePasswordsData;
+exports.removePermissions = removePermissions;
 exports.removeScriptingCSS = removeScriptingCSS;
+exports.removeServiceWorkersData = removeServiceWorkersData;
 exports.removeTab = removeTab;
+exports.removeWebSQLData = removeWebSQLData;
+exports.requestPermissions = requestPermissions;
+exports.requestUpdateCheck = requestUpdateCheck;
+exports.resetUserScriptsWorldConfigs = resetUserScriptsWorldConfigs;
+exports.restart = restart;
+exports.restartAfterDelay = restartAfterDelay;
+exports.resumeDownload = resumeDownload;
 exports.scripting = scripting;
+exports.searchDownloads = searchDownloads;
+exports.searchHistory = searchHistory;
 exports.sendMessage = sendMessage;
 exports.sendTabMessage = sendTabMessage;
-exports.setActionBadgeBgColor = setActionBadgeBgColor;
-exports.setActionBadgeText = setActionBadgeText;
-exports.setActionBadgeTextColor = setActionBadgeTextColor;
 exports.setActionIcon = setActionIcon;
+exports.setActionPopup = setActionPopup;
+exports.setActionTitle = setActionTitle;
+exports.setAudioActiveDevices = setAudioActiveDevices;
+exports.setAudioMute = setAudioMute;
+exports.setAudioProperties = setAudioProperties;
+exports.setBadgeBgColor = setBadgeBgColor;
+exports.setBadgeText = setBadgeText;
+exports.setBadgeTextColor = setBadgeTextColor;
+exports.setCookie = setCookie;
+exports.setDocScannerOptions = setDocScannerOptions;
+exports.setDownloadsUiOptions = setDownloadsUiOptions;
+exports.setExtensionEnabled = setExtensionEnabled;
+exports.setExtensionLaunchType = setExtensionLaunchType;
+exports.setIdleDetectionInterval = setIdleDetectionInterval;
+exports.setSidebarBadgeBgColor = setSidebarBadgeBgColor;
+exports.setSidebarBadgeText = setSidebarBadgeText;
+exports.setSidebarBehavior = setSidebarBehavior;
+exports.setSidebarOptions = setSidebarOptions;
 exports.setTabZoom = setTabZoom;
 exports.setTabZoomSettings = setTabZoomSettings;
+exports.setUninstallURL = setUninstallURL;
+exports.setUpdateUrlData = setUpdateUrlData;
 exports.showDownload = showDownload;
 exports.showDownloadFolder = showDownloadFolder;
+exports.startDocScanning = startDocScanning;
 exports.throwRuntimeError = throwRuntimeError;
 exports.ungroupTab = ungroupTab;
-exports.uninstallManagementSelf = uninstallManagementSelf;
+exports.uninstallCurrentExtension = uninstallCurrentExtension;
+exports.uninstallExtension = uninstallExtension;
 exports.unregisterContentScripts = unregisterContentScripts;
+exports.unregisterUserScripts = unregisterUserScripts;
 exports.updateContentScripts = updateContentScripts;
+exports.updateContextMenu = updateContextMenu;
 exports.updateNotification = updateNotification;
 exports.updateTab = updateTab;
 exports.updateTabAsActive = updateTabAsActive;
 exports.updateTabAsSelected = updateTabAsSelected;
+exports.updateUserScripts = updateUserScripts;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map