solomonkinard.chrome-extension-api

"use strict";
var ji = Object.create;
var ye = Object.defineProperty;
var qi = Object.getOwnPropertyDescriptor;
var Fi = Object.getOwnPropertyNames;
var Oi = Object.getPrototypeOf,
  Bi = Object.prototype.hasOwnProperty;
var Ni = (i, t) =>
  {
    for (var m in t) ye(i, m,
    {
      get: t[m],
      enumerable: !0
    })
  },
  Re = (i, t, m, r) =>
  {
    if (t && typeof t == "object" || typeof t == "function")
      for (let n of Fi(t)) !Bi.call(i, n) && n !== m && ye(i, n,
      {
        get: () => t[n],
        enumerable: !(r = qi(t, n)) || r.enumerable
      });
    return i
  };
var s = (i, t, m) => (m = i != null ? ji(Oi(i)) :
  {}, Re(t || !i || !i.__esModule ? ye(m, "default",
  {
    value: i,
    enumerable: !0
  }) : m, i)),
  Li = i => Re(ye(
  {}, "__esModule",
  {
    value: !0
  }), i);
var Hc = {};
Ni(Hc,
{
  activate: () => Lc,
  deactivate: () => _c
});
module.exports = Li(Hc);
var me = s(require("vscode"));
var Ae = s(require("vscode"));
var Ee = [
{
  name: "spokenFeedback"
},
{
  name: "largeCursor"
},
{
  name: "stickyKeys"
},
{
  name: "highContrast"
},
{
  name: "screenMagnifier"
},
{
  name: "autoclick"
},
{
  name: "virtualKeyboard"
},
{
  name: "caretHighlight"
},
{
  name: "cursorHighlight"
},
{
  name: "focusHighlight"
},
{
  name: "selectToSpeak"
},
{
  name: "switchAccess"
},
{
  name: "animationPolicy"
}];
var Hi = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.accessibilityFeatures.") ? [...Ee.map(n => new Ae.CompletionItem(n.name, Ae.CompletionItemKind.Property))] : void 0
    }
  },
  Ue = Hi;
var g = s(require("vscode"));
var We = [
{
  name: "disable",
  description: "`chrome.action.disable(number tabId, function callback)`"
},
{
  name: "enable",
  description: "`chrome.action.enable(number tabId, function callback)`"
},
{
  name: "getBadgeBackgroundColor",
  description: "`chrome.action.getBadgeBackgroundColor(TabDetails details, function callback)`"
},
{
  name: "getBadgeText",
  description: "`chrome.action.getBadgeText(TabDetails details, function callback)`"
},
{
  name: "getPopup",
  description: "`chrome.action.getPopup(TabDetails details, function callback)`"
},
{
  name: "getTitle",
  description: "`chrome.action.getTitle(TabDetails details, function callback)`"
},
{
  name: "getUserSettings",
  description: "`chrome.action.getUserSettings(function callback)`"
},
{
  name: "openPopup",
  description: "`chrome.action.openPopup(OpenPopupOptions options, function callback)`"
},
{
  name: "setBadgeBackgroundColor",
  description: "`chrome.action.setBadgeBackgroundColor(object details, function callback)`"
},
{
  name: "setBadgeText",
  description: "`chrome.action.setBadgeText(object details, function callback)`"
},
{
  name: "setIcon",
  description: "`chrome.action.setIcon(object details, function callback)`"
},
{
  name: "setPopup",
  description: "`chrome.action.setPopup(object details, function callback)`"
},
{
  name: "setTitle",
  description: "`chrome.action.setTitle(object details, function callback)`"
}];
var je = [
{
  name: "onClicked"
}];
var Gi = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.action.")) return;
      let r = We.map(e =>
        {
          let o = new g.CompletionItem(e.name, g.CompletionItemKind.Method);
          return o.documentation = new g.MarkdownString(e.description), o
        }),
        n = je.map(e => new g.CompletionItem(e.name, g.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  qe = Gi;
var C = s(require("vscode"));
var Fe = [
{
  name: "create",
  description: "`chrome.alarms.create(string name, object alarmInfo)`"
},
{
  name: "get",
  description: "`chrome.alarms.get(string name, function callback)`"
},
{
  name: "getAll",
  description: "`chrome.alarms.getAll(function callback)`"
},
{
  name: "clear",
  description: "`chrome.alarms.clear(string name, function callback)`"
},
{
  name: "clearAll",
  description: "`chrome.alarms.clearAll(function callback)`"
}];
var Oe = [
{
  name: "onAlarm"
}];
var Yi = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.alarms.")) return;
      let r = Fe.map(e =>
        {
          let o = new C.CompletionItem(e.name, C.CompletionItemKind.Method);
          return o.documentation = new C.MarkdownString(e.description), o
        }),
        n = Oe.map(e => new C.CompletionItem(e.name, C.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Be = Yi;
var b = s(require("vscode"));
var Ne = [
{
  name: "getDevices",
  description: "`chrome.audio.getDevices(filter?: DeviceFilter, callback?: function)`"
},
{
  name: "getMute",
  description: "`chrome.audio.getMute(streamType: StreamType, callback?: function)`"
},
{
  name: "setActiveDevices",
  description: "`chrome.audio.setActiveDevices(ids: DeviceIdLists, callback?: function)`"
},
{
  name: "setMute",
  description: "`chrome.audio.setMute(streamType: StreamType, isMuted: boolean, callback?: function)`"
},
{
  name: "setProperties",
  description: "`chrome.audio.setProperties(id: string, properties: DeviceProperties, callback?: function)`"
}];
var Le = [
{
  name: "onDeviceListChanged"
},
{
  name: "onLevelChanged"
},
{
  name: "onMuteChanged"
}];
var $i = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.audio.")) return;
      let r = Ne.map(e =>
        {
          let o = new b.CompletionItem(e.name, b.CompletionItemKind.Method);
          return o.documentation = new b.MarkdownString(e.description), o
        }),
        n = Le.map(e => new b.CompletionItem(e.name, b.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  _e = $i;
var a = s(require("vscode"));
var He = [
{
  name: "MAX_WRITE_OPERATIONS_PER_HOUR"
},
{
  name: "MAX_SUSTAINED_WRITE_OPERATIONS_PER_MINUTE"
}];
var ze = [
{
  name: "get",
  description: "`chrome.bookmarks.get(string or array of string idOrIdList, function callback)`"
},
{
  name: "getChildren",
  description: "`chrome.bookmarks.getChildren(string id, function callback)`"
},
{
  name: "getRecent",
  description: "`chrome.bookmarks.getRecent(integer numberOfItems, function callback)`"
},
{
  name: "getTree",
  description: "`chrome.bookmarks.getTree(function callback)`"
},
{
  name: "getSubTree",
  description: "`chrome.bookmarks.getSubTree(string id, function callback)`"
},
{
  name: "search",
  description: "`chrome.bookmarks.search(string or object query, function callback)`"
},
{
  name: "create",
  description: "`chrome.bookmarks.create(object bookmark, function callback)`"
},
{
  name: "move",
  description: "`chrome.bookmarks.move(string id, object destination, function callback)`"
},
{
  name: "update",
  description: "`chrome.bookmarks.update(string id, object changes, function callback)`"
},
{
  name: "remove",
  description: "`chrome.bookmarks.remove(string id, function callback)`"
},
{
  name: "removeTree",
  description: "`chrome.bookmarks.removeTree(string id, function callback)`"
}];
var Ve = [
{
  name: "onCreated"
},
{
  name: "onRemoved"
},
{
  name: "onChanged"
},
{
  name: "onMoved"
},
{
  name: "onChildrenReordered"
},
{
  name: "onImportBegan"
},
{
  name: "onImportEnded"
}];
var nr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.bookmarks.")) return;
      let r = He.map(o => new a.CompletionItem(o.name, a.CompletionItemKind.Property)),
        n = ze.map(o =>
        {
          let c = new a.CompletionItem(o.name, a.CompletionItemKind.Method);
          return c.documentation = new a.MarkdownString(o.description), c
        }),
        e = Ve.map(o => new a.CompletionItem(o.name, a.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  Ge = nr;
var P = s(require("vscode"));
var Ze = [
{
  name: "setTitle",
  description: "`chrome.browserAction.setTitle(object details, function callback)`"
},
{
  name: "getTitle",
  description: "`chrome.browserAction.getTitle(object details, function callback)`"
},
{
  name: "setIcon",
  description: "`chrome.browserAction.setIcon(object details, function callback)`"
},
{
  name: "setPopup",
  description: "`chrome.browserAction.setPopup(object details, function callback)`"
},
{
  name: "getPopup",
  description: "`chrome.browserAction.getPopup(object details, function callback)`"
},
{
  name: "setBadgeText",
  description: "`chrome.browserAction.setBadgeText(object details, function callback)`"
},
{
  name: "getBadgeText",
  description: "`chrome.browserAction.getBadgeText(object details, function callback)`"
},
{
  name: "setBadgeBackgroundColor",
  description: "`chrome.browserAction.setBadgeBackgroundColor(object details, function callback)`"
},
{
  name: "getBadgeBackgroundColor",
  description: "`chrome.browserAction.getBadgeBackgroundColor(object details, function callback)`"
},
{
  name: "enable",
  description: "`chrome.browserAction.enable(integer tabId, function callback)`"
},
{
  name: "disable",
  description: "`chrome.browserAction.disable(integer tabId, function callback)`"
}];
var Xe = [
{
  name: "onClicked"
}];
var mr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.browserAction.")) return;
      let r = Ze.map(e =>
        {
          let o = new P.CompletionItem(e.name, P.CompletionItemKind.Method);
          return o.documentation = new P.MarkdownString(e.description), o
        }),
        n = Xe.map(e => new P.CompletionItem(e.name, P.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Ye = mr;
var se = s(require("vscode"));
var Je = [
{
  name: "settings",
  description: "`chrome.browsingData.settings(function callback)`"
},
{
  name: "remove",
  description: "`chrome.browsingData.remove( RemovalOptions options, DataTypeSet dataToRemove, function callback)`"
},
{
  name: "removeAppcache",
  description: "`chrome.browsingData.removeAppcache( RemovalOptions options, function callback)`"
},
{
  name: "removeCache",
  description: "`chrome.browsingData.removeCache( RemovalOptions options, function callback)`"
},
{
  name: "removeCacheStorage",
  description: "`chrome.browsingData.removeCacheStorage( RemovalOptions options, function callback)`"
},
{
  name: "removeCookies",
  description: "`chrome.browsingData.removeCookies( RemovalOptions options, function callback)`"
},
{
  name: "removeDownloads",
  description: "`chrome.browsingData.removeDownloads( RemovalOptions options, function callback)`"
},
{
  name: "removeFileSystems",
  description: "`chrome.browsingData.removeFileSystems( RemovalOptions options, function callback)`"
},
{
  name: "removeFormData",
  description: "`chrome.browsingData.removeFormData( RemovalOptions options, function callback)`"
},
{
  name: "removeHistory",
  description: "`chrome.browsingData.removeHistory( RemovalOptions options, function callback)`"
},
{
  name: "removeIndexedDB",
  description: "`chrome.browsingData.removeIndexedDB( RemovalOptions options, function callback)`"
},
{
  name: "removeLocalStorage",
  description: "`chrome.browsingData.removeLocalStorage( RemovalOptions options, function callback)`"
},
{
  name: "removePluginData",
  description: "`chrome.browsingData.removePluginData( RemovalOptions options, function callback)`"
},
{
  name: "removePasswords",
  description: "`chrome.browsingData.removePasswords( RemovalOptions options, function callback)`"
},
{
  name: "removeServiceWorkers",
  description: "`chrome.browsingData.removeServiceWorkers( RemovalOptions options, function callback)`"
},
{
  name: "removeWebSQL",
  description: "`chrome.browsingData.removeWebSQL( RemovalOptions options, function callback)`"
}];
var cr = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.browsingData.") ? Je.map(n =>
      {
        let e = new se.CompletionItem(n.name, se.CompletionItemKind.Method);
        return e.documentation = new se.MarkdownString(n.description), e
      }) : void 0
    }
  },
  Qe = cr;
var w = s(require("vscode"));
var $e = [
{
  name: "requestPin",
  description: "`chrome.certificateProvider.requestPin(object details, function callback)`"
},
{
  name: "stopPinRequest",
  description: "`chrome.certificateProvider.stopPinRequest(object details, function callback)`"
}];
var et = [
{
  name: "onCertificatesRequested"
},
{
  name: "onSignDigestRequested"
}];
var lr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.certificateProvider.")) return;
      let r = $e.map(e =>
        {
          let o = new w.CompletionItem(e.name, w.CompletionItemKind.Method);
          return o.documentation = new w.MarkdownString(e.description), o
        }),
        n = et.map(e => new w.CompletionItem(e.name, w.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  tt = lr;
var ce = s(require("vscode"));
var ot = [
{
  name: "automation",
  description: "The chrome.automation API allows developers to access the automation (accessibility) tree for the browser. The tree resembles the DOM tree, but only exposes the semantic structure of a page. It can be used to programmatically interact with a page by examining names, roles, and states, listening for events, and performing actions on nodes."
},
{
  name: "processes",
  description: "Use the chrome.processes API to interact with the browser's processes."
},
{
  name: "dns",
  description: "Use the chrome.dns API for dns resolution."
}];
var nt = [];
var it = [
{
  name: "accessibilityFeatures",
  description: "Use the chrome.accessibilityFeatures API to manage Chrome's accessibility features. This API relies on the ChromeSetting prototype of the type API for getting and setting individual accessibility features. In order to get feature states the extension must request accessibilityFeatures.read permission. For modifying feature state, the extension needs accessibilityFeatures.modify permission. Note that accessibilityFeatures.modify does not imply accessibilityFeatures.read permission."
},
{
  name: "action",
  description: "Use the chrome.action API to control the extension's icon in the Google Chrome toolbar."
},
{
  name: "alarms",
  description: "Use the chrome.alarms API to schedule code to run periodically or at a specified time in the future."
},
{
  name: "audio",
  description: "The chrome.audio API is provided to allow users to get information about and control the audio devices attached to the system. This API is currently only available in kiosk mode for ChromeOS."
},
{
  name: "bookmarks",
  description: "Use the chrome.bookmarks API to create, organize, and otherwise manipulate bookmarks. Also see Override Pages, which you can use to create a custom Bookmark Manager page."
},
{
  name: "browsingData",
  description: "Use the chrome.browsingData API to remove browsing data from a user's local profile."
},
{
  name: "certificateProvider",
  description: "Use this API to expose certificates to the platform which can use these certificates for TLS authentications."
},
{
  name: "commands",
  description: "Use the commands API to add keyboard shortcuts that trigger actions in your extension, for example, an action to open the browser action or send a command to the extension."
},
{
  name: "contentSettings",
  description: "Use the chrome.contentSettings API to change settings that control whether websites can use features such as cookies, JavaScript, and plugins. More generally speaking, content settings allow you to customize Chrome's behavior on a per-site basis instead of globally."
},
{
  name: "contextMenus",
  description: "Use the chrome.contextMenus API to add items to Google Chrome's context menu. You can choose what types of objects your context menu additions apply to, such as images, hyperlinks, and pages."
},
{
  name: "cookies",
  description: "Use the chrome.cookies API to query and modify cookies, and to be notified when they change."
},
{
  name: "debugger",
  description: "The chrome.debugger API serves as an alternate transport for Chrome's remote debugging protocol. Use chrome.debugger to attach to one or more tabs to instrument network interaction, debug JavaScript, mutate the DOM and CSS, etc. Use the Debuggee tabId to target tabs with sendCommand and route events by tabId from onEvent callbacks."
},
{
  name: "declarativeContent",
  description: "Use the chrome.declarativeContent API to take actions depending on the content of a page, without requiring permission to read the page's content."
},
{
  name: "declarativeNetRequest",
  description: "The chrome.declarativeNetRequest API is used to block or redirect network requests by specifying declarative rules."
},
{
  name: "desktopCapture",
  description: "Desktop Capture API that can be used to capture content of screen, individual windows or tabs."
},
{
  name: "devtools.inspectedWindow",
  description: "Use the chrome.devtools.inspectedWindow API to interact with the inspected window: obtain the tab ID for the inspected page, evaluate the code in the context of the inspected window, reload the page, or obtain the list of resources within the page."
},
{
  name: "devtools.network",
  description: "Use the chrome.devtools.network API to retrieve the information about network requests displayed by the Developer Tools in the Network panel."
},
{
  name: "devtools.panels",
  description: "Use the chrome.devtools.panels API to integrate your extension into Developer Tools window UI: create your own panels, access existing panels, and add sidebars."
},
{
  name: "devtools.recorder",
  description: "Use the chrome.devtools.recorder API to customize the Recorder panel in DevTools."
},
{
  name: "documentScan",
  description: "Use the chrome.documentScan API to discover and retrieve images from attached paper document scanners."
},
{
  name: "dom",
  description: "Use the chrome.dom API to access special DOM APIs for Extensions."
},
{
  name: "downloads",
  description: "Use the chrome.downloads API to programmatically initiate, monitor, manipulate, and search for downloads."
},
{
  name: "enterprise.deviceAttributes",
  description: "Use the chrome.enterprise.deviceAttributes API to read device attributes. Note: This API is only available to extensions force-installed by enterprise policy."
},
{
  name: "enterprise.hardwarePlatform",
  description: "Use the chrome.enterprise.hardwarePlatform API to get the manufacturer and model of the hardware platform where the browser runs. Note: This API is only available to extensions installed by enterprise policy."
},
{
  name: "enterprise.networkingAttributes",
  description: "Use the chrome.enterprise.networkingAttributes API to read information about your current network. Note: This API is only available to extensions force-installed by enterprise policy. This API only works on ChromeOS."
},
{
  name: "enterprise.platformKeys",
  description: "Use the chrome.enterprise.platformKeys API to generate hardware-backed keys and to install certificates for these keys. The certificates will be managed by the platform and can be used for TLS authentication, network access or by other extension through chrome.platformKeys."
},
{
  name: "events",
  description: "The chrome.events namespace contains common types used by APIs dispatching events to notify you when something interesting happens."
},
{
  name: "extension",
  description: "The chrome.extension API has utilities that can be used by any extension page. It includes support for exchanging messages between an extension and its content scripts or between extensions, as described in detail in Message Passing."
},
{
  name: "extensionTypes",
  description: "The chrome.extensionTypes API contains type declarations for Chrome extensions."
},
{
  name: "fileBrowserHandler",
  description: "Use the chrome.fileBrowserHandler API to extend the Chrome OS file browser. For example, you can use this API to enable users to upload files to your website."
},
{
  name: "fileSystemProvider",
  description: "Use the chrome.fileSystemProvider API to create file systems, that can be accessible from the file manager on Chrome OS."
},
{
  name: "fontSettings",
  description: "Use the chrome.fontSettings API to manage Chrome's font settings."
},
{
  name: "gcm",
  description: "Use chrome.gcm to enable apps and extensions to send and receive messages through the Google Cloud Messaging Service."
},
{
  name: "history",
  description: "Use the chrome.history API to interact with the browser's record of visited pages. You can add, remove, and query for URLs in the browser's history. To override the history page with your own version, see Override Pages."
},
{
  name: "i18n",
  description: "Use the chrome.i18n infrastructure to implement internationalization across your whole app or extension."
},
{
  name: "identity",
  description: "Use the chrome.identity API to get OAuth2 access tokens."
},
{
  name: "idle",
  description: "Use the chrome.idle API to detect when the machine's idle state changes."
},
{
  name: "input.ime",
  description: "Use the chrome.input.ime API to implement a custom IME for Chrome OS. This allows your extension to handle keystrokes, set the composition, and manage the candidate window."
},
{
  name: "instanceID",
  description: "Use chrome.instanceID to access the Instance ID service."
},
{
  name: "management",
  description: "The chrome.management API provides ways to manage the list of extensions/apps that are installed and running. It is particularly useful for extensions that override the built-in New Tab page."
},
{
  name: "networking.config",
  description: "Use the networking.config API to authenticate to captive portals."
},
{
  name: "notifications",
  description: "Use the chrome.notifications API to create rich notifications using templates and show these notifications to users in the system tray."
},
{
  name: "omnibox",
  description: "The omnibox API allows you to register a keyword with Google Chrome's address bar, which is also known as the omnibox."
},
{
  name: "offscreen",
  description: "Use the offscreen API to create and manage offscreen documents."
},
{
  name: "pageCapture",
  description: "Use the chrome.pageCapture API to save a tab as MHTML."
},
{
  name: "permissions",
  description: "Use the chrome.permissions API to request declared optional permissions at run time rather than install time, so users understand why the permissions are needed and grant only those that are necessary."
},
{
  name: "platformKeys",
  description: "Use the chrome.platformKeys API to access client certificates managed by the platform. If the user or policy grants the permission, an extension can use such a certficate in its custom authentication protocol. E.g. this allows usage of platform managed certificates in third party VPNs (see chrome.vpnProvider)."
},
{
  name: "power",
  description: "Use the chrome.power API to override the system's power management features."
},
{
  name: "printerProvider",
  description: "The chrome.printerProvider API exposes events used by print manager to query printers controlled by extensions, to query their capabilities and to submit print jobs to these printers."
},
{
  name: "privacy",
  description: "Use the chrome.privacy API to control usage of the features in Chrome that can affect a user's privacy. This API relies on the ChromeSetting prototype of the type API for getting and setting Chrome's configuration."
},
{
  name: "proxy",
  description: "Use the chrome.proxy API to manage Chrome's proxy settings. This API relies on the ChromeSetting prototype of the type API for getting and setting the proxy configuration."
},
{
  name: "runtime",
  description: "Use the chrome.runtime API to retrieve the background page, return details about the manifest, and listen for and respond to events in the app or extension lifecycle. You can also use this API to convert the relative path of URLs to fully-qualified URLs."
},
{
  name: "search",
  description: "Use the chrome.search API to search via the default provider."
},
{
  name: "sessions",
  description: "Use the chrome.sessions API to query and restore tabs and windows from a browsing session."
},
{
  name: "sidePanel",
  description: "Use the chrome.sidePanel API to host content in the browser's side panel alongside the main content of a webpage."
},
{
  name: "storage",
  description: "Use the chrome.storage API to store, retrieve, and track changes to user data."
},
{
  name: "system.cpu",
  description: "Use the system.cpu API to query CPU metadata."
},
{
  name: "system.memory",
  description: "The chrome.system.memory API."
},
{
  name: "system.storage",
  description: "Use the chrome.system.storage API to query storage device information and be notified when a removable storage device is attached and detached."
},
{
  name: "tabCapture",
  description: "Use the chrome.tabCapture API to interact with tab media streams."
},
{
  name: "tabs",
  description: "Use the chrome.tabs API to interact with the browser's tab system. You can use this API to create, modify, and rearrange tabs in the browser."
},
{
  name: "topSites",
  description: "Use the chrome.topSites API to access the top sites that are displayed on the new tab page."
},
{
  name: "tts",
  description: "Use the chrome.tts API to play synthesized text-to-speech (TTS). See also the related ttsEngine API, which allows an extension to implement a speech engine."
},
{
  name: "ttsEngine",
  description: "Use the chrome.ttsEngine API to implement a text-to-speech(TTS) engine using an extension. If your extension registers using this API, it will receive events containing an utterance to be spoken and other parameters when any extension or Chrome App uses the tts API to generate speech. Your extension can then use any available web technology to synthesize and output the speech, and send events back to the calling function to report the status."
},
{
  name: "userScripts",
  description: "Use the userScripts API to execute user scripts in the User Scripts context."
},
{
  name: "types",
  description: "The chrome.types API contains type declarations for Chrome."
},
{
  name: "vpnProvider",
  description: "Use the chrome.vpnProvider API to implement a VPN client."
},
{
  name: "wallpaper",
  description: "Use the chrome.wallpaper API to change the ChromeOS wallpaper."
},
{
  name: "webNavigation",
  description: "Use the chrome.webNavigation API to receive notifications about the status of navigation requests in-flight."
},
{
  name: "webRequest",
  description: "Use the chrome.webRequest API to observe and analyze traffic and to intercept, block, or modify requests in-flight."
},
{
  name: "windows",
  description: "Use the chrome.windows API to interact with browser windows. You can use this API to create, modify, and rearrange windows in the browser."
}];
var rt = [
{
  name: "browserAction",
  description: "Use browser actions to put icons in the main Google Chrome toolbar, to the right of the address bar. In addition to its icon, a browser action can have a tooltip, a badge, and a popup."
},
{
  name: "declarativeWebRequest",
  description: "Note: this API is currently on hold, without concrete plans to move to stable. Use the chrome.declarativeWebRequest API to intercept, block, or modify requests in-flight. It is significantly faster than the chrome.webRequest API because you can register rules that are evaluated in the browser rather than the JavaScript engine, which reduces roundtrip latencies and allows higher efficiency."
},
{
  name: "pageAction",
  description: "Use the chrome.pageAction API to put icons in the main Google Chrome toolbar, to the right of the address bar. Page actions represent actions that can be taken on the current page, but that aren't applicable to all pages. Page actions appear grayed out when inactive."
}];
var fr = {
    provideCompletionItems(i, t)
    {
      if (i.lineAt(t).text.substring(0, t.character).endsWith("chrome.")) return [...it, ...nt, ...ot, ...rt].map(r =>
      {
        let n = new ce.CompletionItem(r.name, ce.CompletionItemKind.Module);
        return n.commitCharacters = ["."], n.documentation = new ce.MarkdownString(r.description), n
      })
    }
  },
  mt = fr;
var k = s(require("vscode"));
var st = [
{
  name: "getAll",
  description: "`chrome.commands.getAll(function callback)`"
}];
var ct = [
{
  name: "onCommand"
}];
var Cr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.commands.")) return;
      let r = st.map(e =>
        {
          let o = new k.CompletionItem(e.name, k.CompletionItemKind.Method);
          return o.documentation = new k.MarkdownString(e.description), o
        }),
        n = ct.map(e => new k.CompletionItem(e.name, k.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  at = Cr;
var Se = s(require("vscode"));
var dt = [
{
  name: "cookies"
},
{
  name: "images"
},
{
  name: "javascript"
},
{
  name: "location"
},
{
  name: "plugins"
},
{
  name: "popups"
},
{
  name: "notifications"
},
{
  name: "fullscreen"
},
{
  name: "mouselock"
},
{
  name: "microphone"
},
{
  name: "camera"
},
{
  name: "unsandboxedPlugins"
},
{
  name: "automaticDownloads"
}];
var Pr = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.contentSettings.") ? dt.map(n => new Se.CompletionItem(n.name, Se.CompletionItemKind.Property)) : void 0
    }
  },
  lt = Pr;
var d = s(require("vscode"));
var pt = [
{
  name: "ACTION_MENU_TOP_LEVEL_LIMIT"
}];
var ut = [
{
  name: "create",
  description: "`integer or string chrome.contextMenus.create(object createProperties, function callback)`"
},
{
  name: "update",
  description: "`chrome.contextMenus.update(integer or string id, object updateProperties, function callback)`"
},
{
  name: "remove",
  description: "`chrome.contextMenus.remove(integer or string menuItemId, function callback)`"
},
{
  name: "removeAll",
  description: "`chrome.contextMenus.removeAll(function callback)`"
}];
var ht = [
{
  name: "onClicked"
}];
var yr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.contextMenus.")) return;
      let r = pt.map(o => new d.CompletionItem(o.name, d.CompletionItemKind.Property)),
        n = ut.map(o =>
        {
          let c = new d.CompletionItem(o.name, d.CompletionItemKind.Method);
          return c.documentation = new d.MarkdownString(o.description), c
        }),
        e = ht.map(o => new d.CompletionItem(o.name, d.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  vt = yr;
var x = s(require("vscode"));
var ft = [
{
  name: "get",
  description: "`chrome.cookies.get(object details, function callback)`"
},
{
  name: "getAll",
  description: "`chrome.cookies.getAll(object details, function callback)`"
},
{
  name: "set",
  description: "`chrome.cookies.set(object details, function callback)`"
},
{
  name: "remove",
  description: "`chrome.cookies.remove(object details, function callback)`"
},
{
  name: "getAllCookieStores",
  description: "`chrome.cookies.getAllCookieStores(function callback)`"
}];
var It = [
{
  name: "onChanged"
}];
var Dr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.cookies.")) return;
      let r = ft.map(e =>
        {
          let o = new x.CompletionItem(e.name, x.CompletionItemKind.Method);
          return o.documentation = new x.MarkdownString(e.description), o
        }),
        n = It.map(e => new x.CompletionItem(e.name, x.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  gt = Dr;
var y = s(require("vscode"));
var Ct = [
{
  name: "attach",
  description: "`chrome.debugger.attach( Debuggee target, string requiredVersion, function callback)`"
},
{
  name: "detach",
  description: "`chrome.debugger.detach( Debuggee target, function callback)`"
},
{
  name: "sendCommand",
  description: "`chrome.debugger.sendCommand( Debuggee target, string method, object commandParams, function callback)`"
},
{
  name: "getTargets",
  description: "`chrome.debugger.getTargets(function callback)`"
}];
var bt = [
{
  name: "onEvent"
},
{
  name: "onDetach"
}];
var Kr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.debugger.")) return;
      let r = Ct.map(e =>
        {
          let o = new y.CompletionItem(e.name, y.CompletionItemKind.Method);
          return o.documentation = new y.MarkdownString(e.description), o
        }),
        n = bt.map(e => new y.CompletionItem(e.name, y.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Pt = Kr;
var De = s(require("vscode"));
var wt = [
{
  name: "onPageChanged"
}];
var Er = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.declarativeContent.") ? wt.map(n => new De.CompletionItem(n.name, De.CompletionItemKind.Event)) : void 0
    }
  },
  kt = Er;
var A = s(require("vscode"));
var xt = [
{
  name: "MAX_NUMBER_OF_ALLOWED_PAGES"
},
{
  name: "MAX_NUMBER_OF_RULES"
},
{
  name: "MAX_NUMBER_OF_DYNAMIC_RULES"
}];
var yt = [
{
  name: "addDynamicRules",
  description: "`chrome.declarativeNetRequest.addDynamicRules(array of Rule rules, function callback)`"
},
{
  name: "removeDynamicRules",
  description: "`chrome.declarativeNetRequest.removeDynamicRules(array of integer rule_ids, function callback)`"
},
{
  name: "getDynamicRules",
  description: "`chrome.declarativeNetRequest.getDynamicRules(function callback)`"
},
{
  name: "addAllowedPages",
  description: "`chrome.declarativeNetRequest.addAllowedPages(array of string page_patterns, function callback)`"
},
{
  name: "removeAllowedPages",
  description: "`chrome.declarativeNetRequest.removeAllowedPages(array of string page_patterns, function callback)`"
},
{
  name: "getAllowedPages",
  description: "`chrome.declarativeNetRequest.getAllowedPages(function callback)`"
}];
var jr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.declarativeNetRequest.")) return;
      let r = xt.map(e => new A.CompletionItem(e.name, A.CompletionItemKind.Property)),
        n = yt.map(e =>
        {
          let o = new A.CompletionItem(e.name, A.CompletionItemKind.Method);
          return o.documentation = new A.MarkdownString(e.description), o
        });
      return [...r, ...n]
    }
  },
  At = jr;
var Me = s(require("vscode"));
var St = [
{
  name: "onRequest"
},
{
  name: "onMessage"
}];
var Fr = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.declarativeWebRequest.") ? St.map(n => new Me.CompletionItem(n.name, Me.CompletionItemKind.Event)) : void 0
    }
  },
  Dt = Fr;
var ae = s(require("vscode"));
var Mt = [
{
  name: "chooseDesktopMedia",
  description: "integer `chrome.desktopCapture.chooseDesktopMedia(array of DesktopCaptureSourceType sources, tabs.Tab targetTab, function callback)`"
},
{
  name: "cancelChooseDesktopMedia",
  description: "`chrome.desktopCapture.cancelChooseDesktopMedia(integer desktopMediaRequestId)`"
}];
var Br = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.desktopCapture.") ? Mt.map(n =>
      {
        let e = new ae.CompletionItem(n.name, ae.CompletionItemKind.Method);
        return e.documentation = new ae.MarkdownString(n.description), e
      }) : void 0
    }
  },
  Tt = Br;
var l = s(require("vscode"));
var Kt = [
{
  name: "tabId"
}];
var Rt = [
{
  name: "eval",
  description: "`chrome.devtools.inspectedWindow.eval(string expression, object options, function callback)`"
},
{
  name: "reload",
  description: "`chrome.devtools.inspectedWindow.reload(object reloadOptions)`"
},
{
  name: "getResources",
  description: "`chrome.devtools.inspectedWindow.getResources(function callback)`"
}];
var Et = [
{
  name: "onResourceAdded"
},
{
  name: "onResourceContentCommitted"
}];
var Hr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.devtools.inspectedWindow.")) return;
      let r = Kt.map(o => new l.CompletionItem(o.name, l.CompletionItemKind.Property)),
        n = Rt.map(o =>
        {
          let c = new l.CompletionItem(o.name, l.CompletionItemKind.Method);
          return c.documentation = new l.MarkdownString(o.description), c
        }),
        e = Et.map(o => new l.CompletionItem(o.name, l.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  Ut = Hr;
var S = s(require("vscode"));
var Wt = [
{
  name: "getHAR",
  description: "`chrome.devtools.network.getHAR(function callback)`"
}];
var jt = [
{
  name: "onRequestFinished"
},
{
  name: "onNavigated"
}];
var Gr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.devtools.network.")) return;
      let r = Wt.map(e =>
        {
          let o = new S.CompletionItem(e.name, S.CompletionItemKind.Method);
          return o.documentation = new S.MarkdownString(e.description), o
        }),
        n = jt.map(e => new S.CompletionItem(e.name, S.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  qt = Gr;
var D = s(require("vscode"));
var Ft = [
{
  name: "elements"
},
{
  name: "sources"
},
{
  name: "themeName"
}];
var Ot = [
{
  name: "create",
  description: "`chrome.devtools.panels.create(string title, string iconPath, string pagePath, function callback)`"
},
{
  name: "setOpenResourceHandler",
  description: "`chrome.devtools.panels.setOpenResourceHandler(function callback)`"
},
{
  name: "openResource",
  description: "`chrome.devtools.panels.openResource(string url, integer lineNumber, function callback)`"
}];
var Yr = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.devtools.panels.")) return;
      let r = Ft.map(e => new D.CompletionItem(e.name, D.CompletionItemKind.Property)),
        n = Ot.map(e =>
        {
          let o = new D.CompletionItem(e.name, D.CompletionItemKind.Method);
          return o.documentation = new D.MarkdownString(e.description), o
        });
      return [...r, ...n]
    }
  },
  Bt = Yr;
var M = s(require("vscode"));
var Nt = [
{
  name: "createView",
  description: "`chrome.devtools.recorder.createView(title: string, pagePath: string)`"
},
{
  name: "registerRecorderExtensionPlugin",
  description: "`chrome.devtools.recorder.registerRecorderExtensionPlugin(plugin: RecordedExtensionPlugin, name: string, mediaType: string)`"
}];
var Lt = [];
var $r = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.devtools.recorder.")) return;
      let r = Nt.map(e =>
        {
          let o = new M.CompletionItem(e.name, M.CompletionItemKind.Method);
          return o.documentation = new M.MarkdownString(e.description), o
        }),
        n = Lt.map(e => new M.CompletionItem(e.name, M.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  _t = $r;
var de = s(require("vscode"));
var Ht = [
{
  name: "scan",
  description: "`chrome.documentScan.scan(object options, function callback)`"
}];
var tm = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.documentScan.") ? Ht.map(n =>
      {
        let e = new de.CompletionItem(n.name, de.CompletionItemKind.Method);
        return e.documentation = new de.MarkdownString(n.description), e
      }) : void 0
    }
  },
  zt = tm;
var T = s(require("vscode"));
var Vt = [
{
  name: "openOrClosedShadowRoot",
  description: "`chrome.dom.openOrClosedShadowRoot(element: HTMLElement)`"
}];
var Gt = [];
var im = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.dom.")) return;
      let r = Vt.map(e =>
        {
          let o = new T.CompletionItem(e.name, T.CompletionItemKind.Method);
          return o.documentation = new T.MarkdownString(e.description), o
        }),
        n = Gt.map(e => new T.CompletionItem(e.name, T.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Zt = im;
var K = s(require("vscode"));
var Xt = [
{
  name: "download",
  description: "`chrome.downloads.download(object options, function callback)`"
},
{
  name: "search",
  description: "`chrome.downloads.search(object query, function callback)`"
},
{
  name: "pause",
  description: "`chrome.downloads.pause(integer downloadId, function callback)`"
},
{
  name: "resume",
  description: "`chrome.downloads.resume(integer downloadId, function callback)`"
},
{
  name: "cancel",
  description: "`chrome.downloads.cancel(integer downloadId, function callback)`"
},
{
  name: "getFileIcon",
  description: "`chrome.downloads.getFileIcon(integer downloadId, object options, function callback)`"
},
{
  name: "open",
  description: "`chrome.downloads.open(integer downloadId)`"
},
{
  name: "show",
  description: "`chrome.downloads.show(integer downloadId)`"
},
{
  name: "showDefaultFolder",
  description: "`chrome.downloads.showDefaultFolder()`"
},
{
  name: "erase",
  description: "`chrome.downloads.erase(object query, function callback)`"
},
{
  name: "removeFile",
  description: "`chrome.downloads.removeFile(integer downloadId, function callback)`"
},
{
  name: "acceptDanger",
  description: "`chrome.downloads.acceptDanger(integer downloadId, function callback)`"
},
{
  name: "drag",
  description: "`chrome.downloads.drag(integer downloadId)`"
},
{
  name: "setShelfEnabled",
  description: "`chrome.downloads.setShelfEnabled(boolean enabled)`"
}];
var Yt = [
{
  name: "onCreated"
},
{
  name: "onErased"
},
{
  name: "onChanged"
},
{
  name: "onDeterminingFilename"
}];
var sm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.downloads.")) return;
      let r = Xt.map(e =>
        {
          let o = new K.CompletionItem(e.name, K.CompletionItemKind.Method);
          return o.documentation = new K.MarkdownString(e.description), o
        }),
        n = Yt.map(e => new K.CompletionItem(e.name, K.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Jt = sm;
var le = s(require("vscode"));
var Qt = [
{
  name: "getDirectoryDeviceId",
  description: "`chrome.enterprise.deviceAttributes.getDirectoryDeviceId(function callback)`"
},
{
  name: "getDeviceSerialNumber",
  description: "`chrome.enterprise.deviceAttributes.getDeviceSerialNumber(function callback)`"
},
{
  name: "getDeviceAssetId",
  description: "`chrome.enterprise.deviceAttributes.getDeviceAssetId(function callback)`"
},
{
  name: "getDeviceAnnotatedLocation",
  description: "`chrome.enterprise.deviceAttributes.getDeviceAnnotatedLocation(function callback)`"
}];
var am = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.enterprise.deviceAttributes.") ? Qt.map(n =>
      {
        let e = new le.CompletionItem(n.name, le.CompletionItemKind.Method);
        return e.documentation = new le.MarkdownString(n.description), e
      }) : void 0
    }
  },
  $t = am;
var R = s(require("vscode"));
var eo = [
{
  name: "getHardwarePlatformInfo",
  description: "`chrome.enterprise.getHardwarePlatformInfo(callback?: function)`"
}];
var to = [];
var pm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.enterprise.hardwarePlatform.")) return;
      let r = eo.map(e =>
        {
          let o = new R.CompletionItem(e.name, R.CompletionItemKind.Method);
          return o.documentation = new R.MarkdownString(e.description), o
        }),
        n = to.map(e => new R.CompletionItem(e.name, R.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  oo = pm;
var E = s(require("vscode"));
var no = [
{
  name: "getNetworkDetails",
  description: "`chrome.networkingAttributes.getNetworkDetails(callback?: function)`"
}];
var io = [];
var vm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.enterprise.networkingAttributes.")) return;
      let r = no.map(e =>
        {
          let o = new E.CompletionItem(e.name, E.CompletionItemKind.Method);
          return o.documentation = new E.MarkdownString(e.description), o
        }),
        n = io.map(e => new E.CompletionItem(e.name, E.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  ro = vm;
var pe = s(require("vscode"));
var mo = [
{
  name: "getTokens",
  description: "`chrome.enterprise.platformKeys.getTokens(function callback)`"
},
{
  name: "getCertificates",
  description: "`chrome.enterprise.platformKeys.getCertificates(string tokenId, function callback)`"
},
{
  name: "importCertificate",
  description: "`chrome.enterprise.platformKeys.importCertificate(string tokenId, ArrayBuffer certificate, function callback)`"
},
{
  name: "removeCertificate",
  description: "`chrome.enterprise.platformKeys.removeCertificate(string tokenId, ArrayBuffer certificate, function callback)`"
},
{
  name: "challengeMachineKey",
  description: "`chrome.enterprise.platformKeys.challengeMachineKey(ArrayBuffer challenge, boolean registerKey, function callback)`"
},
{
  name: "challengeUserKey",
  description: "`chrome.enterprise.platformKeys.challengeUserKey(ArrayBuffer challenge, boolean registerKey, function callback)`"
}];
var Im = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.enterprise.platformKeys.") ? mo.map(n =>
      {
        let e = new pe.CompletionItem(n.name, pe.CompletionItemKind.Method);
        return e.documentation = new pe.MarkdownString(n.description), e
      }) : void 0
    }
  },
  so = Im;
var p = s(require("vscode"));
var co = [
{
  name: "lastError"
},
{
  name: "inIncognitoContext"
}];
var ao = [
{
  name: "sendRequest",
  description: "`chrome.extension.sendRequest(string extensionId, any request, function responseCallback)`"
},
{
  name: "getURL",
  description: "`string chrome.extension.getURL(string path)`"
},
{
  name: "getViews",
  description: "`array of Window chrome.extension.getViews(object fetchProperties)`"
},
{
  name: "getBackgroundPage",
  description: "`Window chrome.extension.getBackgroundPage()`"
},
{
  name: "getExtensionTabs",
  description: "`array of Window chrome.extension.getExtensionTabs(integer windowId)`"
},
{
  name: "isAllowedIncognitoAccess",
  description: "`chrome.extension.isAllowedIncognitoAccess(function callback)`"
},
{
  name: "isAllowedFileSchemeAccess",
  description: "`chrome.extension.isAllowedFileSchemeAccess(function callback)`"
},
{
  name: "setUpdateUrlData",
  description: "`chrome.extension.setUpdateUrlData(string data)`"
}];
var lo = [
{
  name: "onRequest"
},
{
  name: "onRequestExternal"
}];
var Pm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.extension.")) return;
      let r = co.map(o => new p.CompletionItem(o.name, p.CompletionItemKind.Property)),
        n = ao.map(o =>
        {
          let c = new p.CompletionItem(o.name, p.CompletionItemKind.Method);
          return c.documentation = new p.MarkdownString(o.description), c
        }),
        e = lo.map(o => new p.CompletionItem(o.name, p.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  po = Pm;
var U = s(require("vscode"));
var uo = [
{
  name: "selectFile",
  description: "`chrome.fileBrowserHandler.selectFile(object selectionParams, function callback)`"
}];
var ho = [
{
  name: "onExecute"
}];
var xm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.fileBrowserHandler.")) return;
      let r = uo.map(e =>
        {
          let o = new U.CompletionItem(e.name, U.CompletionItemKind.Method);
          return o.documentation = new U.MarkdownString(e.description), o
        }),
        n = ho.map(e => new U.CompletionItem(e.name, U.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  vo = xm;
var W = s(require("vscode"));
var fo = [
{
  name: "mount",
  description: "`chrome.fileSystemProvider.mount(object options, function callback)`"
},
{
  name: "unmount",
  description: "`chrome.fileSystemProvider.unmount(object options, function callback)`"
},
{
  name: "getAll",
  description: "`chrome.fileSystemProvider.getAll(function callback)`"
},
{
  name: "get",
  description: "`chrome.fileSystemProvider.get(string fileSystemId, function callback)`"
},
{
  name: "notify",
  description: "`chrome.fileSystemProvider.notify(object options, function callback)`"
}];
var Io = [
{
  name: "onUnmountRequested"
},
{
  name: "onGetMetadataRequested"
},
{
  name: "onGetActionsRequested"
},
{
  name: "onReadDirectoryRequested"
},
{
  name: "onOpenFileRequested"
},
{
  name: "onCloseFileRequested"
},
{
  name: "onReadFileRequested"
},
{
  name: "onCreateDirectoryRequested"
},
{
  name: "onDeleteEntryRequested"
},
{
  name: "onCreateFileRequested"
},
{
  name: "onCopyEntryRequested"
},
{
  name: "onMoveEntryRequested"
},
{
  name: "onTruncateRequested"
},
{
  name: "onWriteFileRequested"
},
{
  name: "onAbortRequested"
},
{
  name: "onConfigureRequested"
},
{
  name: "onMountRequested"
},
{
  name: "onAddWatcherRequested"
},
{
  name: "onRemoveWatcherRequested"
},
{
  name: "onExecuteActionRequested"
}];
var Sm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.fileSystemProvider.")) return;
      let r = fo.map(e =>
        {
          let o = new W.CompletionItem(e.name, W.CompletionItemKind.Method);
          return o.documentation = new W.MarkdownString(e.description), o
        }),
        n = Io.map(e => new W.CompletionItem(e.name, W.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  go = Sm;
var j = s(require("vscode"));
var Co = [
{
  name: "clearFont",
  description: "`chrome.fontSettings.clearFont(object details, function callback)`"
},
{
  name: "getFont",
  description: "`chrome.fontSettings.getFont(object details, function callback)`"
},
{
  name: "setFont",
  description: "`chrome.fontSettings.setFont(object details, function callback)`"
},
{
  name: "getFontList",
  description: "`chrome.fontSettings.getFontList(function callback)`"
},
{
  name: "clearDefaultFontSize",
  description: "`chrome.fontSettings.clearDefaultFontSize(object details, function callback)`"
},
{
  name: "getDefaultFontSize",
  description: "`chrome.fontSettings.getDefaultFontSize(object details, function callback)`"
},
{
  name: "setDefaultFontSize",
  description: "`chrome.fontSettings.setDefaultFontSize(object details, function callback)`"
},
{
  name: "clearDefaultFixedFontSize",
  description: "`chrome.fontSettings.clearDefaultFixedFontSize(object details, function callback)`"
},
{
  name: "getDefaultFixedFontSize",
  description: "`chrome.fontSettings.getDefaultFixedFontSize(object details, function callback)`"
},
{
  name: "setDefaultFixedFontSize",
  description: "`chrome.fontSettings.setDefaultFixedFontSize(object details, function callback)`"
},
{
  name: "clearMinimumFontSize",
  description: "`chrome.fontSettings.clearMinimumFontSize(object details, function callback)`"
},
{
  name: "getMinimumFontSize",
  description: "`chrome.fontSettings.getMinimumFontSize(object details, function callback)`"
},
{
  name: "setMinimumFontSize",
  description: "`chrome.fontSettings.setMinimumFontSize(object details, function callback)`"
}];
var bo = [
{
  name: "onFontChanged"
},
{
  name: "onDefaultFontSizeChanged"
},
{
  name: "onDefaultFixedFontSizeChanged"
},
{
  name: "onMinimumFontSizeChanged"
}];
var Tm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.fontSettings.")) return;
      let r = Co.map(e =>
        {
          let o = new j.CompletionItem(e.name, j.CompletionItemKind.Method);
          return o.documentation = new j.MarkdownString(e.description), o
        }),
        n = bo.map(e => new j.CompletionItem(e.name, j.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Po = Tm;
var q = s(require("vscode"));
var wo = [
{
  name: "register",
  description: "`chrome.gcm.register(array of string senderIds, function callback)`"
},
{
  name: "unregister",
  description: "`chrome.gcm.unregister(function callback)`"
},
{
  name: "send",
  description: "`chrome.gcm.send(object message, function callback)`"
}];
var ko = [
{
  name: "onMessage"
},
{
  name: "onMessagesDeleted"
},
{
  name: "onSendError"
}];
var Em = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.gcm.")) return;
      let r = wo.map(e =>
        {
          let o = new q.CompletionItem(e.name, q.CompletionItemKind.Method);
          return o.documentation = new q.MarkdownString(e.description), o
        }),
        n = ko.map(e => new q.CompletionItem(e.name, q.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  xo = Em;
var F = s(require("vscode"));
var yo = [
{
  name: "search",
  description: "`chrome.history.search(object query, function callback)`"
},
{
  name: "getVisits",
  description: "`chrome.history.getVisits(object details, function callback)`"
},
{
  name: "addUrl",
  description: "`chrome.history.addUrl(object details, function callback)`"
},
{
  name: "deleteUrl",
  description: "`chrome.history.deleteUrl(object details, function callback)`"
},
{
  name: "deleteRange",
  description: "`chrome.history.deleteRange(object range, function callback)`"
},
{
  name: "deleteAll",
  description: "`chrome.history.deleteAll(function callback)`"
}];
var Ao = [
{
  name: "onVisited"
},
{
  name: "onVisitRemoved"
}];
var jm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.history.")) return;
      let r = yo.map(e =>
        {
          let o = new F.CompletionItem(e.name, F.CompletionItemKind.Method);
          return o.documentation = new F.MarkdownString(e.description), o
        }),
        n = Ao.map(e => new F.CompletionItem(e.name, F.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  So = jm;
var ue = s(require("vscode"));
var Do = [
{
  name: "getAcceptLanguages",
  description: "`chrome.i18n.getAcceptLanguages(function callback)`"
},
{
  name: "getMessage",
  description: "string `chrome.i18n.getMessage(string messageName, any substitutions)`"
},
{
  name: "getUILanguage",
  description: "string `chrome.i18n.getUILanguage()`"
},
{
  name: "detectLanguage",
  description: "`chrome.i18n.detectLanguage(string text, function callback)`"
}];
var Fm = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.i18n.") ? Do.map(n =>
      {
        let e = new ue.CompletionItem(n.name, ue.CompletionItemKind.Method);
        return e.documentation = new ue.MarkdownString(n.description), e
      }) : void 0
    }
  },
  Mo = Fm;
var O = s(require("vscode"));
var To = [
{
  name: "getAccounts",
  description: "`chrome.identity.getAccounts(function callback)`"
},
{
  name: "getAuthToken",
  description: "`chrome.identity.getAuthToken(object details, function callback)`"
},
{
  name: "getProfileUserInfo",
  description: "`chrome.identity.getProfileUserInfo(function callback)`"
},
{
  name: "removeCachedAuthToken",
  description: "`chrome.identity.removeCachedAuthToken(object details, function callback)`"
},
{
  name: "launchWebAuthFlow",
  description: "`chrome.identity.launchWebAuthFlow(object details, function callback)`"
},
{
  name: "getRedirectURL",
  description: "`string chrome.identity.getRedirectURL(string path)`"
}];
var Ko = [
{
  name: "onSignInChanged"
}];
var Nm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.identity.")) return;
      let r = To.map(e =>
        {
          let o = new O.CompletionItem(e.name, O.CompletionItemKind.Method);
          return o.documentation = new O.MarkdownString(e.description), o
        }),
        n = Ko.map(e => new O.CompletionItem(e.name, O.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Ro = Nm;
var B = s(require("vscode"));
var Eo = [
{
  name: "queryState",
  description: "`chrome.idle.queryState(integer detectionIntervalInSeconds, function callback)`"
},
{
  name: "setDetectionInterval",
  description: "`chrome.idle.setDetectionInterval(integer intervalInSeconds)`"
},
{
  name: "getAutoLockDelay",
  description: "`chrome.idle.getAutoLockDelay(function callback)`"
}];
var Uo = [
{
  name: "onStateChanged"
}];
var Hm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.idle.")) return;
      let r = Eo.map(e =>
        {
          let o = new B.CompletionItem(e.name, B.CompletionItemKind.Method);
          return o.documentation = new B.MarkdownString(e.description), o
        }),
        n = Uo.map(e => new B.CompletionItem(e.name, B.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Wo = Hm;
var N = s(require("vscode"));
var jo = [
{
  name: "setComposition",
  description: "`chrome.input.ime.setComposition(object parameters, function callback)`"
},
{
  name: "clearComposition",
  description: "`chrome.input.ime.clearComposition(object parameters, function callback)`"
},
{
  name: "commitText",
  description: "`chrome.input.ime.commitText(object parameters, function callback)`"
},
{
  name: "sendKeyEvents",
  description: "`chrome.input.ime.sendKeyEvents(object parameters, function callback)`"
},
{
  name: "hideInputView",
  description: "`chrome.input.ime.hideInputView()`"
},
{
  name: "setCandidateWindowProperties",
  description: "`chrome.input.ime.setCandidateWindowProperties(object parameters, function callback)`"
},
{
  name: "setCandidates",
  description: "`chrome.input.ime.setCandidates(object parameters, function callback)`"
},
{
  name: "setCursorPosition",
  description: "`chrome.input.ime.setCursorPosition(object parameters, function callback)`"
},
{
  name: "setMenuItems",
  description: "`chrome.input.ime.setMenuItems(object parameters, function callback)`"
},
{
  name: "updateMenuItems",
  description: "`chrome.input.ime.updateMenuItems(object parameters, function callback)`"
},
{
  name: "deleteSurroundingText",
  description: "`chrome.input.ime.deleteSurroundingText(object parameters, function callback)`"
},
{
  name: "keyEventHandled",
  description: "`chrome.input.ime.keyEventHandled(string requestId, boolean response)`"
},
{
  name: "createWindow",
  description: "`chrome.input.ime.createWindow( CreateWindowOptions options, function callback)`"
},
{
  name: "showWindow",
  description: "`chrome.input.ime.showWindow(integer windowId, function callback)`"
},
{
  name: "hideWindow",
  description: "`chrome.input.ime.hideWindow(integer windowId, function callback)`"
},
{
  name: "activate",
  description: "`chrome.input.ime.activate(function callback)`"
},
{
  name: "deactivate",
  description: "`chrome.input.ime.deactivate(function callback)`"
}];
var qo = [
{
  name: "onActivate"
},
{
  name: "onDeactivated"
},
{
  name: "onFocus"
},
{
  name: "onBlur"
},
{
  name: "onInputContextUpdate"
},
{
  name: "onKeyEvent"
},
{
  name: "onCandidateClicked"
},
{
  name: "onMenuItemActivated"
},
{
  name: "onSurroundingTextChanged"
},
{
  name: "onReset"
},
{
  name: "onCompositionBoundsChanged"
}];
var Gm = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.input.ime.")) return;
      let r = jo.map(e =>
        {
          let o = new N.CompletionItem(e.name, N.CompletionItemKind.Method);
          return o.documentation = new N.MarkdownString(e.description), o
        }),
        n = qo.map(e => new N.CompletionItem(e.name, N.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Fo = Gm;
var L = s(require("vscode"));
var Oo = [
{
  name: "getID",
  description: "`chrome.instanceID.getID(function callback)`"
},
{
  name: "getCreationTime",
  description: "`chrome.instanceID.getCreationTime(function callback)`"
},
{
  name: "getToken",
  description: "`chrome.instanceID.getToken(object getTokenParams, function callback)`"
},
{
  name: "deleteToken",
  description: "`chrome.instanceID.deleteToken(object deleteTokenParams, function callback)`"
},
{
  name: "deleteID",
  description: "`chrome.instanceID.deleteID(function callback)`"
}];
var Bo = [
{
  name: "onTokenRefresh"
}];
var Ym = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.instanceID.")) return;
      let r = Oo.map(e =>
        {
          let o = new L.CompletionItem(e.name, L.CompletionItemKind.Method);
          return o.documentation = new L.MarkdownString(e.description), o
        }),
        n = Bo.map(e => new L.CompletionItem(e.name, L.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  No = Ym;
var _ = s(require("vscode"));
var Lo = [
{
  name: "getAll",
  description: "`chrome.management.getAll(function callback)`"
},
{
  name: "get",
  description: "`chrome.management.get(string id, function callback)`"
},
{
  name: "getSelf",
  description: "`chrome.management.getSelf(function callback)`"
},
{
  name: "getPermissionWarningsById",
  description: "`chrome.management.getPermissionWarningsById(string id, function callback)`"
},
{
  name: "getPermissionWarningsByManifest",
  description: "`chrome.management.getPermissionWarningsByManifest(string manifestStr, function callback)`"
},
{
  name: "setEnabled",
  description: "`chrome.management.setEnabled(string id, boolean enabled, function callback)`"
},
{
  name: "uninstall",
  description: "`chrome.management.uninstall(string id, object options, function callback)`"
},
{
  name: "uninstallSelf",
  description: "`chrome.management.uninstallSelf(object options, function callback)`"
},
{
  name: "launchApp",
  description: "`chrome.management.launchApp(string id, function callback)`"
},
{
  name: "createAppShortcut",
  description: "`chrome.management.createAppShortcut(string id, function callback)`"
},
{
  name: "setLaunchType",
  description: "`chrome.management.setLaunchType(string id, LaunchType launchType, function callback)`"
},
{
  name: "generateAppForLink",
  description: "`chrome.management.generateAppForLink(string url, string title, function callback)`"
},
{
  name: "installReplacementWebApp",
  description: "`chrome.management.installReplacementWebApp(function callback)`"
}];
var _o = [
{
  name: "onInstalled"
},
{
  name: "onUninstalled"
},
{
  name: "onEnabled"
},
{
  name: "onDisabled"
}];
var $m = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.management.")) return;
      let r = Lo.map(e =>
        {
          let o = new _.CompletionItem(e.name, _.CompletionItemKind.Method);
          return o.documentation = new _.MarkdownString(e.description), o
        }),
        n = _o.map(e => new _.CompletionItem(e.name, _.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Ho = $m;
var H = s(require("vscode"));
var zo = [
{
  name: "setNetworkFilter",
  description: "`chrome.networking.config.setNetworkFilter(array of NetworkInfo networks, function callback)`"
},
{
  name: "finishAuthentication",
  description: '`chrome.networking.config.finishAuthentication(string GUID, enum of "unhandled", "succeeded", "rejected", or "failed" result, function callback)`'
}];
var Vo = [
{
  name: "onCaptivePortalDetected"
}];
var os = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.networking.config.")) return;
      let r = zo.map(e =>
        {
          let o = new H.CompletionItem(e.name, H.CompletionItemKind.Method);
          return o.documentation = new H.MarkdownString(e.description), o
        }),
        n = Vo.map(e => new H.CompletionItem(e.name, H.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Go = os;
var z = s(require("vscode"));
var Zo = [
{
  name: "create",
  description: "`chrome.notifications.create(string notificationId, NotificationOptions options, function callback)`"
},
{
  name: "update",
  description: "`chrome.notifications.update(string notificationId, NotificationOptions options, function callback)`"
},
{
  name: "clear",
  description: "`chrome.notifications.clear(string notificationId, function callback)`"
},
{
  name: "getAll",
  description: "`chrome.notifications.getAll(function callback)`"
},
{
  name: "getPermissionLevel",
  description: "`chrome.notifications.getPermissionLevel(function callback)`"
}];
var Xo = [
{
  name: "onClosed"
},
{
  name: "onClicked"
},
{
  name: "onButtonClicked"
},
{
  name: "onPermissionLevelChanged"
},
{
  name: "onShowSettings"
}];
var rs = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.notifications.")) return;
      let r = Zo.map(e =>
        {
          let o = new z.CompletionItem(e.name, z.CompletionItemKind.Method);
          return o.documentation = new z.MarkdownString(e.description), o
        }),
        n = Xo.map(e => new z.CompletionItem(e.name, z.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Yo = rs;
var V = s(require("vscode"));
var Jo = [
{
  name: "closeDocument",
  description: "`chrome.offscreen.createDocument(callback?: function)`"
},
{
  name: "createDocument",
  description: "`chrome.offscreen.createDocument(callback?: function)`"
}];
var Qo = [];
var cs = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.offscreen.")) return;
      let r = Jo.map(e =>
        {
          let o = new V.CompletionItem(e.name, V.CompletionItemKind.Method);
          return o.documentation = new V.MarkdownString(e.description), o
        }),
        n = Qo.map(e => new V.CompletionItem(e.name, V.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  $o = cs;
var G = s(require("vscode"));
var en = [
{
  name: "setDefaultSuggestion",
  description: "`chrome.omnibox.setDefaultSuggestion(object suggestion)`"
}];
var tn = [
{
  name: "onInputStarted"
},
{
  name: "onInputChanged"
},
{
  name: "onInputEntered"
},
{
  name: "onInputCancelled"
},
{
  name: "onDeleteSuggestion"
}];
var ls = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.omnibox.")) return;
      let r = en.map(e =>
        {
          let o = new G.CompletionItem(e.name, G.CompletionItemKind.Method);
          return o.documentation = new G.MarkdownString(e.description), o
        }),
        n = tn.map(e => new G.CompletionItem(e.name, G.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  on = ls;
var Z = s(require("vscode"));
var nn = [
{
  name: "show",
  description: "`chrome.pageAction.show(integer tabId, function callback)`"
},
{
  name: "hide",
  description: "`chrome.pageAction.hide(integer tabId, function callback)`"
},
{
  name: "setTitle",
  description: "`chrome.pageAction.setTitle(object details, function callback)`"
},
{
  name: "getTitle",
  description: "`chrome.pageAction.getTitle(object details, function callback)`"
},
{
  name: "setIcon",
  description: "`chrome.pageAction.setIcon(object details, function callback)`"
},
{
  name: "setPopup",
  description: "`chrome.pageAction.setPopup(object details, function callback)`"
},
{
  name: "getPopup",
  description: "`chrome.pageAction.getPopup(object details, function callback)`"
}];
var rn = [
{
  name: "onClicked"
}];
var hs = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.pageAction.")) return;
      let r = nn.map(e =>
        {
          let o = new Z.CompletionItem(e.name, Z.CompletionItemKind.Method);
          return o.documentation = new Z.MarkdownString(e.description), o
        }),
        n = rn.map(e => new Z.CompletionItem(e.name, Z.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  mn = hs;
var he = s(require("vscode"));
var sn = [
{
  name: "saveAsMHTML",
  description: "`chrome.pageCapture.saveAsMHTML(object details, function callback)`"
}];
var fs = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.pageCapture.") ? sn.map(n =>
      {
        let e = new he.CompletionItem(n.name, he.CompletionItemKind.Method);
        return e.documentation = new he.MarkdownString(n.description), e
      }) : void 0
    }
  },
  cn = fs;
var X = s(require("vscode"));
var an = [
{
  name: "getAll",
  description: "`chrome.permissions.getAll(function callback)`"
},
{
  name: "contains",
  description: "`chrome.permissions.contains( Permissions permissions, function callback)`"
},
{
  name: "request",
  description: "`chrome.permissions.request( Permissions permissions, function callback)`"
},
{
  name: "remove",
  description: "`chrome.permissions.remove( Permissions permissions, function callback)`"
}];
var dn = [
{
  name: "onAdded"
},
{
  name: "onRemoved"
}];
var Cs = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.permissions.")) return;
      let r = an.map(e =>
        {
          let o = new X.CompletionItem(e.name, X.CompletionItemKind.Method);
          return o.documentation = new X.MarkdownString(e.description), o
        }),
        n = dn.map(e => new X.CompletionItem(e.name, X.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  ln = Cs;
var ve = s(require("vscode"));
var pn = [
{
  name: "selectClientCertificates",
  description: "`chrome.platformKeys.selectClientCertificates(object details, function callback)`"
},
{
  name: "getKeyPair",
  description: "`chrome.platformKeys.getKeyPair(ArrayBuffer certificate, object parameters, function callback)`"
},
{
  name: "subtleCrypto",
  description: "object `chrome.platformKeys.subtleCrypto()`"
},
{
  name: "verifyTLSServerCertificate",
  description: "`chrome.platformKeys.verifyTLSServerCertificate(object details, function callback)`"
}];
var Ps = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.platformKeys.") ? pn.map(n =>
      {
        let e = new ve.CompletionItem(n.name, ve.CompletionItemKind.Method);
        return e.documentation = new ve.MarkdownString(n.description), e
      }) : void 0
    }
  },
  un = Ps;
var fe = s(require("vscode"));
var hn = [
{
  name: "requestKeepAwake",
  description: "`chrome.power.requestKeepAwake( Level level)`"
},
{
  name: "releaseKeepAwake",
  description: "`chrome.power.releaseKeepAwake()`"
}];
var ks = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.power.") ? hn.map(n =>
      {
        let e = new fe.CompletionItem(n.name, fe.CompletionItemKind.Method);
        return e.documentation = new fe.MarkdownString(n.description), e
      }) : void 0
    }
  },
  vn = ks;
var Te = s(require("vscode"));
var fn = [
{
  name: "onGetPrintersRequested"
},
{
  name: "onGetUsbPrinterInfoRequested"
},
{
  name: "onGetCapabilityRequested"
},
{
  name: "onPrintRequested"
}];
var ys = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.printerProvider.") ? fn.map(n => new Te.CompletionItem(n.name, Te.CompletionItemKind.Event)) : void 0
    }
  },
  In = ys;
var Ke = s(require("vscode"));
var gn = [
{
  name: "network"
},
{
  name: "services"
},
{
  name: "websites"
}];
var Ss = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.privacy.") ? gn.map(n => new Ke.CompletionItem(n.name, Ke.CompletionItemKind.Property)) : void 0
    }
  },
  Cn = Ss;
var Ie = s(require("vscode"));
var bn = [
{
  name: "settings"
}];
var Pn = [
{
  name: "onProxyError"
}];
var Ts = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.proxy.")) return;
      let r = bn.map(e => new Ie.CompletionItem(e.name, Ie.CompletionItemKind.Property)),
        n = Pn.map(e => new Ie.CompletionItem(e.name, Ie.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  wn = Ts;
var u = s(require("vscode"));
var kn = [
{
  name: "lastError"
},
{
  name: "id"
}];
var xn = [
{
  name: "getBackgroundPage",
  description: "`chrome.runtime.getBackgroundPage(function callback)`"
},
{
  name: "openOptionsPage",
  description: "`chrome.runtime.openOptionsPage(function callback)`"
},
{
  name: "getManifest",
  description: "object `chrome.runtime.getManifest()`"
},
{
  name: "getURL",
  description: "string `chrome.runtime.getURL(string path)`"
},
{
  name: "setUninstallURL",
  description: "`chrome.runtime.setUninstallURL(string url, function callback)`"
},
{
  name: "reload",
  description: "`chrome.runtime.reload()`"
},
{
  name: "requestUpdateCheck",
  description: "`chrome.runtime.requestUpdateCheck(function callback)`"
},
{
  name: "restart",
  description: "`chrome.runtime.restart()`"
},
{
  name: "restartAfterDelay",
  description: "`chrome.runtime.restartAfterDelay(integer seconds, function callback)`"
},
{
  name: "connect",
  description: "Port `chrome.runtime.connect(string extensionId, object connectInfo)`"
},
{
  name: "connectNative",
  description: "Port `chrome.runtime.connectNative(string application)`"
},
{
  name: "sendMessage",
  description: "`chrome.runtime.sendMessage(string extensionId, any message, object options, function responseCallback)`"
},
{
  name: "sendNativeMessage",
  description: "`chrome.runtime.sendNativeMessage(string application, object message, function responseCallback)`"
},
{
  name: "getPlatformInfo",
  description: "`chrome.runtime.getPlatformInfo(function callback)`"
},
{
  name: "getPackageDirectoryEntry",
  description: "`chrome.runtime.getPackageDirectoryEntry(function callback)`"
}];
var yn = [
{
  name: "onStartup"
},
{
  name: "onInstalled"
},
{
  name: "onSuspend"
},
{
  name: "onSuspendCanceled"
},
{
  name: "onUpdateAvailable"
},
{
  name: "onBrowserUpdateAvailable"
},
{
  name: "onConnect"
},
{
  name: "onConnectExternal"
},
{
  name: "onConnectNative"
},
{
  name: "onMessage"
},
{
  name: "onMessageExternal"
},
{
  name: "onRestartRequired"
}];
var Us = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.runtime.")) return;
      let r = kn.map(o => new u.CompletionItem(o.name, u.CompletionItemKind.Property)),
        n = xn.map(o =>
        {
          let c = new u.CompletionItem(o.name, u.CompletionItemKind.Method);
          return c.documentation = new u.MarkdownString(o.description), c
        }),
        e = yn.map(o => new u.CompletionItem(o.name, u.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  An = Us;
var Y = s(require("vscode"));
var Sn = [
{
  name: "query",
  description: "`chrome.search.query(queryInfo: QueryInfo, callback?: function)`"
}];
var Dn = [];
var qs = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.search.")) return;
      let r = Sn.map(e =>
        {
          let o = new Y.CompletionItem(e.name, Y.CompletionItemKind.Method);
          return o.documentation = new Y.MarkdownString(e.description), o
        }),
        n = Dn.map(e => new Y.CompletionItem(e.name, Y.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Mn = qs;
var h = s(require("vscode"));
var Tn = [
{
  name: "MAX_SESSION_RESULTS"
}];
var Kn = [
{
  name: "getRecentlyClosed",
  description: "`chrome.sessions.getRecentlyClosed( Filter filter, function callback)`"
},
{
  name: "getDevices",
  description: "`chrome.sessions.getDevices( Filter filter, function callback)`"
},
{
  name: "restore",
  description: "`chrome.sessions.restore(string sessionId, function callback)`"
}];
var Rn = [
{
  name: "onChanged"
}];
var Ns = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.sessions.")) return;
      let r = Tn.map(o => new h.CompletionItem(o.name, h.CompletionItemKind.Property)),
        n = Kn.map(o =>
        {
          let c = new h.CompletionItem(o.name, h.CompletionItemKind.Method);
          return c.documentation = new h.MarkdownString(o.description), c
        }),
        e = Rn.map(o => new h.CompletionItem(o.name, h.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  En = Ns;
var J = s(require("vscode"));
var Un = [
{
  name: "getOptions",
  description: "`chrome.sidePanel.getOptions(options: GetPanelOptions, callback?: function)`"
},
{
  name: "getPanelBehavior",
  description: "`chrome.sidePanel.getPanelBehavior(callback?: function)`"
},
{
  name: "open",
  description: "`chrome.sidePanel.open(options: OpenOptions, callback?: function)`"
},
{
  name: "setOptions",
  description: "`chrome.sidePanel.setOptions(options: PanelOptions, callback?: function)`"
},
{
  name: "setPanelBehavior",
  description: "`chrome.sidePanel.setPanelBehavior(behavior: PanelBehavior, callback?: function)`"
}];
var Wn = [];
var Hs = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.sidePanel.")) return;
      let r = Un.map(e =>
        {
          let o = new J.CompletionItem(e.name, J.CompletionItemKind.Method);
          return o.documentation = new J.MarkdownString(e.description), o
        }),
        n = Wn.map(e => new J.CompletionItem(e.name, J.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  jn = Hs;
var ge = s(require("vscode"));
var qn = [
{
  name: "sync"
},
{
  name: "local"
},
{
  name: "managed"
}];
var Fn = [
{
  name: "onChanged"
}];
var Gs = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.storage.")) return;
      let r = qn.map(e => new ge.CompletionItem(e.name, ge.CompletionItemKind.Property)),
        n = Fn.map(e => new ge.CompletionItem(e.name, ge.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  On = Gs;
var Ce = s(require("vscode"));
var Bn = [
{
  name: "getInfo",
  description: "`chrome.system.cpu.getInfo(function callback)`"
}];
var Xs = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.system.cpu.") ? Bn.map(n =>
      {
        let e = new Ce.CompletionItem(n.name, Ce.CompletionItemKind.Method);
        return e.documentation = new Ce.MarkdownString(n.description), e
      }) : void 0
    }
  },
  Nn = Xs;
var be = s(require("vscode"));
var Ln = [
{
  name: "getInfo",
  description: "`chrome.system.memory.getInfo(function callback)`"
}];
var Js = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.system.memory.") ? Ln.map(n =>
      {
        let e = new be.CompletionItem(n.name, be.CompletionItemKind.Method);
        return e.documentation = new be.MarkdownString(n.description), e
      }) : void 0
    }
  },
  _n = Js;
var Q = s(require("vscode"));
var Hn = [
{
  name: "getInfo",
  description: "`chrome.system.storage.getInfo(function callback)`"
},
{
  name: "ejectDevice",
  description: "`chrome.system.storage.ejectDevice(string id, function callback)`"
},
{
  name: "getAvailableCapacity",
  description: "`chrome.system.storage.getAvailableCapacity(string id, function callback)`"
}];
var zn = [
{
  name: "onAttached"
},
{
  name: "onDetached"
}];
var ec = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.system.storage.")) return;
      let r = Hn.map(e =>
        {
          let o = new Q.CompletionItem(e.name, Q.CompletionItemKind.Method);
          return o.documentation = new Q.MarkdownString(e.description), o
        }),
        n = zn.map(e => new Q.CompletionItem(e.name, Q.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Vn = ec;
var $ = s(require("vscode"));
var Gn = [
{
  name: "capture",
  description: "`chrome.tabCapture.capture( CaptureOptions options, function callback)`"
},
{
  name: "getCapturedTabs",
  description: "`chrome.tabCapture.getCapturedTabs(function callback)`"
},
{
  name: "captureOffscreenTab",
  description: "`chrome.tabCapture.captureOffscreenTab(string startUrl, CaptureOptions options, function callback)`"
},
{
  name: "getMediaStreamId",
  description: "`chrome.tabCapture.getMediaStreamId(object options, function callback)`"
}];
var Zn = [
{
  name: "onStatusChanged"
}];
var nc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.tabCapture.")) return;
      let r = Gn.map(e =>
        {
          let o = new $.CompletionItem(e.name, $.CompletionItemKind.Method);
          return o.documentation = new $.MarkdownString(e.description), o
        }),
        n = Zn.map(e => new $.CompletionItem(e.name, $.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Xn = nc;
var v = s(require("vscode"));
var Yn = [
{
  name: "TAB_ID_NONE"
}];
var Jn = [
{
  name: "get",
  description: "`chrome.tabs.get(integer tabId, function callback)`"
},
{
  name: "getCurrent",
  description: "`chrome.tabs.getCurrent(function callback)`"
},
{
  name: "connect",
  description: "`runtime.Port chrome.tabs.connect(integer tabId, object connectInfo)`"
},
{
  name: "sendRequest",
  description: "`chrome.tabs.sendRequest(integer tabId, any request, function responseCallback)`"
},
{
  name: "sendMessage",
  description: "`chrome.tabs.sendMessage(integer tabId, any message, object options, function responseCallback)`"
},
{
  name: "getSelected",
  description: "`chrome.tabs.getSelected(integer windowId, function callback)`"
},
{
  name: "getAllInWindow",
  description: "`chrome.tabs.getAllInWindow(integer windowId, function callback)`"
},
{
  name: "create",
  description: "`chrome.tabs.create(object createProperties, function callback)`"
},
{
  name: "duplicate",
  description: "`chrome.tabs.duplicate(integer tabId, function callback)`"
},
{
  name: "query",
  description: "`chrome.tabs.query(object queryInfo, function callback)`"
},
{
  name: "highlight",
  description: "`chrome.tabs.highlight(object highlightInfo, function callback)`"
},
{
  name: "update",
  description: "`chrome.tabs.update(integer tabId, object updateProperties, function callback)`"
},
{
  name: "move",
  description: "`chrome.tabs.move(integer or array of integer tabIds, object moveProperties, function callback)`"
},
{
  name: "reload",
  description: "`chrome.tabs.reload(integer tabId, object reloadProperties, function callback)`"
},
{
  name: "remove",
  description: "`chrome.tabs.remove(integer or array of integer tabIds, function callback)`"
},
{
  name: "detectLanguage",
  description: "`chrome.tabs.detectLanguage(integer tabId, function callback)`"
},
{
  name: "captureVisibleTab",
  description: "`chrome.tabs.captureVisibleTab(integer windowId, object options, function callback)`"
},
{
  name: "executeScript",
  description: "`chrome.tabs.executeScript(integer tabId, object details, function callback)`"
},
{
  name: "insertCSS",
  description: "`chrome.tabs.insertCSS(integer tabId, object details, function callback)`"
},
{
  name: "setZoom",
  description: "`chrome.tabs.setZoom(integer tabId, double zoomFactor, function callback)`"
},
{
  name: "getZoom",
  description: "`chrome.tabs.getZoom(integer tabId, function callback)`"
},
{
  name: "setZoomSettings",
  description: "`chrome.tabs.setZoomSettings(integer tabId, ZoomSettings zoomSettings, function callback)`"
},
{
  name: "getZoomSettings",
  description: "`chrome.tabs.getZoomSettings(integer tabId, function callback)`"
},
{
  name: "discard",
  description: "`chrome.tabs.discard(integer tabId, function callback)`"
},
{
  name: "goForward",
  description: "`chrome.tabs.goForward(integer tabId, function callback)`"
},
{
  name: "goBack",
  description: "`chrome.tabs.goBack(integer tabId, function callback)`"
},
{
  name: "group",
  description: "`chrome.tabs.group(object options, function callback)`"
},
{
  name: "ungroup",
  description: "`chrome.tabs.ungroup(number | [number, ...number[]] tabIds, function callback)`"
}];
var Qn = [
{
  name: "onCreated"
},
{
  name: "onUpdated"
},
{
  name: "onMoved"
},
{
  name: "onSelectionChanged"
},
{
  name: "onActiveChanged"
},
{
  name: "onActivated"
},
{
  name: "onHighlightChanged"
},
{
  name: "onHighlighted"
},
{
  name: "onDetached"
},
{
  name: "onAttached"
},
{
  name: "onRemoved"
},
{
  name: "onReplaced"
},
{
  name: "onZoomChange"
}];
var sc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.tabs.")) return;
      let r = Yn.map(o => new v.CompletionItem(o.name, v.CompletionItemKind.Property)),
        n = Jn.map(o =>
        {
          let c = new v.CompletionItem(o.name, v.CompletionItemKind.Method);
          return c.documentation = new v.MarkdownString(o.description), c
        }),
        e = Qn.map(o => new v.CompletionItem(o.name, v.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  $n = sc;
var Pe = s(require("vscode"));
var ei = [
{
  name: "get",
  description: "`chrome.topSites.get(function callback)`"
}];
var ac = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.topSites.") ? ei.map(n =>
      {
        let e = new Pe.CompletionItem(n.name, Pe.CompletionItemKind.Method);
        return e.documentation = new Pe.MarkdownString(n.description), e
      }) : void 0
    }
  },
  ti = ac;
var we = s(require("vscode"));
var oi = [
{
  name: "speak",
  description: "`chrome.tts.speak(string utterance, object options, function callback)`"
},
{
  name: "stop",
  description: "`chrome.tts.stop()`"
},
{
  name: "pause",
  description: "`chrome.tts.pause()`"
},
{
  name: "resume",
  description: "`chrome.tts.resume()`"
},
{
  name: "isSpeaking",
  description: "`chrome.tts.isSpeaking(function callback)`"
},
{
  name: "getVoices",
  description: "`chrome.tts.getVoices(function callback)`"
}];
var lc = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.tts.") ? oi.map(n =>
      {
        let e = new we.CompletionItem(n.name, we.CompletionItemKind.Method);
        return e.documentation = new we.MarkdownString(n.description), e
      }) : void 0
    }
  },
  ni = lc;
var ee = s(require("vscode"));
var ii = [
{
  name: "updateVoices",
  description: "`chrome.ttsEngine.updateVoices(array of tts.TtsVoice voices)`"
}];
var ri = [
{
  name: "onSpeak"
},
{
  name: "onStop"
},
{
  name: "onPause"
},
{
  name: "onResume"
}];
var hc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.ttsEngine.")) return;
      let r = ii.map(e =>
        {
          let o = new ee.CompletionItem(e.name, ee.CompletionItemKind.Method);
          return o.documentation = new ee.MarkdownString(e.description), o
        }),
        n = ri.map(e => new ee.CompletionItem(e.name, ee.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  mi = hc;
var te = s(require("vscode"));
var si = [
{
  name: "configureWorld",
  description: "`chrome.userScripts.configureWorld(properties: WorldProperties, callback?: function)`"
},
{
  name: "getScripts",
  description: "`chrome.userScripts.getScripts(filter?: UserScriptsFilter, callback?: function)`"
},
{
  name: "register",
  description: "`chrome.userScripts.register(scripts: RegisteredUserScripts[], callback?: function)`"
},
{
  name: "unregister",
  description: "`chrome.userScripts.unregister(filter: UserScriptFilter, callback?: function)`"
},
{
  name: "update",
  description: "`chrome.userScripts.update(scripts: RegisteredUserScript[], callback?: function)`"
}];
var ci = [];
var Ic = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.userScripts.")) return;
      let r = si.map(e =>
        {
          let o = new te.CompletionItem(e.name, te.CompletionItemKind.Method);
          return o.documentation = new te.MarkdownString(e.description), o
        }),
        n = ci.map(e => new te.CompletionItem(e.name, te.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  ai = Ic;
var oe = s(require("vscode"));
var di = [
{
  name: "createConfig",
  description: "`chrome.vpnProvider.createConfig(string name, function callback)`"
},
{
  name: "destroyConfig",
  description: "`chrome.vpnProvider.destroyConfig(string id, function callback)`"
},
{
  name: "setParameters",
  description: "`chrome.vpnProvider.setParameters(object parameters, function callback)`"
},
{
  name: "sendPacket",
  description: "`chrome.vpnProvider.sendPacket(ArrayBuffer data, function callback)`"
},
{
  name: "notifyConnectionStateChanged",
  description: '`chrome.vpnProvider.notifyConnectionStateChanged(enum of "connected", or "failure" state, function callback)`'
}];
var li = [
{
  name: "onPlatformMessage"
},
{
  name: "onPacketReceived"
},
{
  name: "onConfigRemoved"
},
{
  name: "onConfigCreated"
},
{
  name: "onUIEvent"
}];
var bc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.vpnProvider.")) return;
      let r = di.map(e =>
        {
          let o = new oe.CompletionItem(e.name, oe.CompletionItemKind.Method);
          return o.documentation = new oe.MarkdownString(e.description), o
        }),
        n = li.map(e => new oe.CompletionItem(e.name, oe.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  pi = bc;
var ke = s(require("vscode"));
var ui = [
{
  name: "setWallpaper",
  description: "`chrome.wallpaper.setWallpaper(object details, function callback)`"
}];
var wc = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.wallpaper.") ? ui.map(n =>
      {
        let e = new ke.CompletionItem(n.name, ke.CompletionItemKind.Method);
        return e.documentation = new ke.MarkdownString(n.description), e
      }) : void 0
    }
  },
  hi = wc;
var ne = s(require("vscode"));
var vi = [
{
  name: "getFrame",
  description: "`chrome.webNavigation.getFrame(object details, function callback)`"
},
{
  name: "getAllFrames",
  description: "`chrome.webNavigation.getAllFrames(object details, function callback)`"
}];
var fi = [
{
  name: "onBeforeNavigate"
},
{
  name: "onCommitted"
},
{
  name: "onDOMContentLoaded"
},
{
  name: "onCompleted"
},
{
  name: "onErrorOccurred"
},
{
  name: "onCreatedNavigationTarget"
},
{
  name: "onReferenceFragmentUpdated"
},
{
  name: "onTabReplaced"
},
{
  name: "onHistoryStateUpdated"
}];
var yc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.webNavigation.")) return;
      let r = vi.map(e =>
        {
          let o = new ne.CompletionItem(e.name, ne.CompletionItemKind.Method);
          return o.documentation = new ne.MarkdownString(e.description), o
        }),
        n = fi.map(e => new ne.CompletionItem(e.name, ne.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Ii = yc;
var f = s(require("vscode"));
var gi = [
{
  name: "MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES"
}];
var Ci = [
{
  name: "handlerBehaviorChanged",
  description: "`chrome.webRequest.handlerBehaviorChanged(function callback)`"
}];
var bi = [
{
  name: "onBeforeRequest"
},
{
  name: "onBeforeSendHeaders"
},
{
  name: "onSendHeaders"
},
{
  name: "onHeadersReceived"
},
{
  name: "onAuthRequired"
},
{
  name: "onResponseStarted"
},
{
  name: "onBeforeRedirect"
},
{
  name: "onCompleted"
},
{
  name: "onErrorOccurred"
},
{
  name: "onActionIgnored"
}];
var Mc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.webRequest.")) return;
      let r = gi.map(o => new f.CompletionItem(o.name, f.CompletionItemKind.Property)),
        n = Ci.map(o =>
        {
          let c = new f.CompletionItem(o.name, f.CompletionItemKind.Method);
          return c.documentation = new f.MarkdownString(o.description), c
        }),
        e = bi.map(o => new f.CompletionItem(o.name, f.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  Pi = Mc;
var I = s(require("vscode"));
var wi = [
{
  name: "WINDOW_ID_NONE"
},
{
  name: "WINDOW_ID_CURRENT"
}];
var ki = [
{
  name: "get",
  description: "`chrome.windows.get(integer windowId, object getInfo, function callback)`"
},
{
  name: "getCurrent",
  description: "`chrome.windows.getCurrent(object getInfo, function callback)`"
},
{
  name: "getLastFocused",
  description: "`chrome.windows.getLastFocused(object getInfo, function callback)`"
},
{
  name: "getAll",
  description: "`chrome.windows.getAll(object getInfo, function callback)`"
},
{
  name: "create",
  description: "`chrome.windows.create(object createData, function callback)`"
},
{
  name: "update",
  description: "`chrome.windows.update(integer windowId, object updateInfo, function callback)`"
},
{
  name: "remove",
  description: "`chrome.windows.remove(integer windowId, function callback)`"
}];
var xi = [
{
  name: "onCreated"
},
{
  name: "onRemoved"
},
{
  name: "onFocusChanged"
}];
var Ec = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.windows.")) return;
      let r = wi.map(o => new I.CompletionItem(o.name, I.CompletionItemKind.Property)),
        n = ki.map(o =>
        {
          let c = new I.CompletionItem(o.name, I.CompletionItemKind.Method);
          return c.documentation = new I.MarkdownString(o.description), c
        }),
        e = xi.map(o => new I.CompletionItem(o.name, I.CompletionItemKind.Event));
      return [...r, ...n, ...e]
    }
  },
  yi = Ec;
var xe = s(require("vscode"));
var Ai = [
{
  name: "getTree",
  description: "`chrome.automation.getTree(integer tabId, function callback)`"
},
{
  name: "getDesktop",
  description: "`chrome.automation.getDesktop(function callback)`"
},
{
  name: "getFocus",
  description: "`chrome.automation.getFocus(function callback)`"
},
{
  name: "addTreeChangeObserver",
  description: '`chrome.automation.addTreeChangeObserver(enum of "noTreeChanges", "liveRegionTreeChanges", "textMarkerChanges", or "allTreeChanges" filter, function observer)`'
},
{
  name: "removeTreeChangeObserver",
  description: "`chrome.automation.removeTreeChangeObserver(function observer)`"
},
{
  name: "setDocumentSelection",
  description: "`chrome.automation.setDocumentSelection( SetDocumentSelectionParams params)`"
}];
var Wc = {
    provideCompletionItems(i, t)
    {
      return i.lineAt(t).text.substr(0, t.character).endsWith("chrome.automation.") ? Ai.map(n =>
      {
        let e = new xe.CompletionItem(n.name, xe.CompletionItemKind.Method);
        return e.documentation = new xe.MarkdownString(n.description), e
      }) : void 0
    }
  },
  Si = Wc;
var ie = s(require("vscode"));
var Di = [
{
  name: "getProcessIdForTab",
  description: "`chrome.processes.getProcessIdForTab(integer tabId, function callback)`"
},
{
  name: "terminate",
  description: "`chrome.processes.terminate(integer processId, function callback)`"
},
{
  name: "getProcessInfo",
  description: "`chrome.processes.getProcessInfo(integer or array of integer processIds, boolean includeMemory, function callback)`"
}];
var Mi = [
{
  name: "onUpdated"
},
{
  name: "onUpdatedWithMemory"
},
{
  name: "onCreated"
},
{
  name: "onUnresponsive"
},
{
  name: "onExited"
}];
var Fc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substr(0, t.character).endsWith("chrome.processes.")) return;
      let r = Di.map(e =>
        {
          let o = new ie.CompletionItem(e.name, ie.CompletionItemKind.Method);
          return o.documentation = new ie.MarkdownString(e.description), o
        }),
        n = Mi.map(e => new ie.CompletionItem(e.name, ie.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Ti = Fc;
var re = s(require("vscode"));
var Ki = [
{
  name: "resolve",
  description: "`chrome.dns.resolve(hostname: string, callback?: function)`"
}];
var Ri = [];
var Nc = {
    provideCompletionItems(i, t)
    {
      if (!i.lineAt(t).text.substring(0, t.character).endsWith("chrome.dns.")) return;
      let r = Ki.map(e =>
        {
          let o = new re.CompletionItem(e.name, re.CompletionItemKind.Method);
          return o.documentation = new re.MarkdownString(e.description), o
        }),
        n = Ri.map(e => new re.CompletionItem(e.name, re.CompletionItemKind.Event));
      return [...r, ...n]
    }
  },
  Ei = Nc;
var Ui = [Ue, qe, Be, _e, Ge, Qe, tt, mt, at, lt, vt, gt, Pt, kt, At, Tt, Ut, qt, Bt, _t, zt, Zt, Jt, $t, oo, ro, so, po, vo, go, Po, xo, So, Mo, Ro, Wo, Fo, No, Ho, Go, Yo, $o, on, cn, ln, un, vn, In, Cn, wn, An, Mn, En, jn, On, Nn, _n, Vn, Xn, $n, ti, ni, mi, ai, pi, hi, Ii, Pi, yi, Si, Ti, Ei, Ye, Dt, mn];
var Wi = ["javascript", "typescript", "plaintext"];

function Lc(i)
{
  i.subscriptions.push(me.languages.registerCompletionItemProvider(Wi,
  {
    provideCompletionItems(t, m, r, n)
    {
      let e = new me.CompletionItem("chrome");
      return e.commitCharacters = ["."], e.documentation = new me.MarkdownString("Chrome provides extensions with many special-purpose APIs like `chrome.runtime` and `chrome.alarms`."), [e]
    }
  })), Ui.forEach(t =>
  {
    me.languages.registerCompletionItemProvider(Wi, t, ".")
  })
}

function _c()
{}
0 && (module.exports = {
  activate,
  deactivate
});
solomonkinard.chrome-extension-api

Metadata

Publisher

Statistics

Files

Code
