diff --git a/manifest.json b/manifest.json index 3af1f55..1570a31 100644 --- a/manifest.json +++ b/manifest.json @@ -2,7 +2,7 @@ "manifest_version": 2, "name": "SOMtodayn't", - "version": "1.15", + "version": "1.20", "author": "McArn", "description": "Changes the slogan on the login page of the school management system SOMtoday.", @@ -21,7 +21,10 @@ "background": { "persistent": true, - "scripts": ["background/js/index.js"] + "scripts": [ + "vendor/browser-polyfill.js", + "background/js/index.js" + ] }, "browser_action": { @@ -36,7 +39,10 @@ "content_scripts": [ { "matches": ["*://*.somtoday.nl/*"], - "js": ["content/js/index.js"] + "js": [ + "vendor/browser-polyfill.js", + "content/js/index.js" + ] } ] diff --git a/package-lock.json b/package-lock.json index 163b769..7db9707 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2003,7 +2003,6 @@ "version": "0.8.8", "resolved": "https://registry.npmjs.org/dtrace-provider/-/dtrace-provider-0.8.8.tgz", "integrity": "sha512-b7Z7cNtHPhH9EJhNNbbeqTcXB8LGFFZhq1PGgEvpeHlzd36bhbdTWoE/Ba/YguqpBSlAPKnARWhVlhunCMwfxg==", - "optional": true, "requires": { "nan": "^2.14.0" } @@ -4240,8 +4239,7 @@ "moment": { "version": "2.24.0", "resolved": "https://registry.npmjs.org/moment/-/moment-2.24.0.tgz", - "integrity": "sha512-bV7f+6l2QigeBBZSM/6yTNq4P2fNpSWj/0e7jQcy87A8e7o2nAfP/34/2ky5Vw4B9S446EtIhodAzkFCcR4dQg==", - "optional": true + "integrity": "sha512-bV7f+6l2QigeBBZSM/6yTNq4P2fNpSWj/0e7jQcy87A8e7o2nAfP/34/2ky5Vw4B9S446EtIhodAzkFCcR4dQg==" }, "ms": { "version": "2.0.0", @@ -4269,7 +4267,6 @@ "version": "2.1.1", "resolved": "https://registry.npmjs.org/mv/-/mv-2.1.1.tgz", "integrity": "sha1-rmzg1vbV4KT32JN5jQPB6pVZtqI=", - "optional": true, "requires": { "mkdirp": "~0.5.1", "ncp": "~2.0.0", @@ -4280,7 +4277,6 @@ "version": "6.0.4", "resolved": "https://registry.npmjs.org/glob/-/glob-6.0.4.tgz", "integrity": "sha1-DwiGD2oVUSey+t1PnOJLGqtuTSI=", - "optional": true, "requires": { "inflight": "^1.0.4", "inherits": "2", @@ -4293,7 +4289,6 @@ "version": "2.4.5", "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.4.5.tgz", "integrity": "sha1-7nEM5dk6j9uFb7Xqj/Di11k0sto=", - "optional": true, "requires": { "glob": "^6.0.1" } @@ -4313,8 +4308,7 @@ "nan": { "version": "2.14.0", "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz", - "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==", - "optional": true + "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==" }, "nanomatch": { "version": "1.2.13", @@ -4347,8 +4341,7 @@ "ncp": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ncp/-/ncp-2.0.0.tgz", - "integrity": "sha1-GVoh1sRuNh0vsSgbo4uR6d9727M=", - "optional": true + "integrity": "sha1-GVoh1sRuNh0vsSgbo4uR6d9727M=" }, "neo-async": { "version": "2.6.1", @@ -5154,8 +5147,7 @@ "safe-json-stringify": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/safe-json-stringify/-/safe-json-stringify-1.2.0.tgz", - "integrity": "sha512-gH8eh2nZudPQO6TytOvbxnuhYBOvDBBLW52tz5q6X58lJcd/tkmqFR+5Z9adS8aJtURSXWThWy/xJtJwixErvg==", - "optional": true + "integrity": "sha512-gH8eh2nZudPQO6TytOvbxnuhYBOvDBBLW52tz5q6X58lJcd/tkmqFR+5Z9adS8aJtURSXWThWy/xJtJwixErvg==" }, "safe-regex": { "version": "1.1.0", @@ -6229,6 +6221,12 @@ "zip-dir": "1.0.2" } }, + "webextension-polyfill": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/webextension-polyfill/-/webextension-polyfill-0.5.0.tgz", + "integrity": "sha512-aFrl38x43t1bTboX/paCT8I97+idzX/TY0+fuM52hrIkCpYfROEF9kSn0BXuEIi3J9LTYt2ZZKkhx9NB1qF3nA==", + "dev": true + }, "webidl-conversions": { "version": "4.0.2", "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz", diff --git a/popup/html/index.html b/popup/html/index.html index 261db20..76fbc5b 100644 --- a/popup/html/index.html +++ b/popup/html/index.html @@ -2,6 +2,7 @@ + diff --git a/vendor/browser-polyfill.js b/vendor/browser-polyfill.js new file mode 100644 index 0000000..8c2afd6 --- /dev/null +++ b/vendor/browser-polyfill.js @@ -0,0 +1,1187 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define("webextension-polyfill", ["module"], factory); + } else if (typeof exports !== "undefined") { + factory(module); + } else { + var mod = { + exports: {} + }; + factory(mod); + global.browser = mod.exports; + } +})(this, function (module) { + /* webextension-polyfill - v0.5.0 - Thu Sep 26 2019 22:22:26 */ + /* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ + /* vim: set sts=2 sw=2 et tw=80: */ + /* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + "use strict"; + + if (typeof browser === "undefined" || Object.getPrototypeOf(browser) !== Object.prototype) { + const CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE = "The message port closed before a response was received."; + const SEND_RESPONSE_DEPRECATION_WARNING = "Returning a Promise is the preferred way to send a reply from an onMessage/onMessageExternal listener, as the sendResponse will be removed from the specs (See https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage)"; + + // Wrapping the bulk of this polyfill in a one-time-use function is a minor + // optimization for Firefox. Since Spidermonkey does not fully parse the + // contents of a function until the first time it's called, and since it will + // never actually need to be called, this allows the polyfill to be included + // in Firefox nearly for free. + const wrapAPIs = extensionAPIs => { + // NOTE: apiMetadata is associated to the content of the api-metadata.json file + // at build time by replacing the following "include" with the content of the + // JSON file. + const apiMetadata = { + "alarms": { + "clear": { + "minArgs": 0, + "maxArgs": 1 + }, + "clearAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "bookmarks": { + "create": { + "minArgs": 1, + "maxArgs": 1 + }, + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getChildren": { + "minArgs": 1, + "maxArgs": 1 + }, + "getRecent": { + "minArgs": 1, + "maxArgs": 1 + }, + "getSubTree": { + "minArgs": 1, + "maxArgs": 1 + }, + "getTree": { + "minArgs": 0, + "maxArgs": 0 + }, + "move": { + "minArgs": 2, + "maxArgs": 2 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeTree": { + "minArgs": 1, + "maxArgs": 1 + }, + "search": { + "minArgs": 1, + "maxArgs": 1 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + }, + "browserAction": { + "disable": { + "minArgs": 0, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "enable": { + "minArgs": 0, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "getBadgeBackgroundColor": { + "minArgs": 1, + "maxArgs": 1 + }, + "getBadgeText": { + "minArgs": 1, + "maxArgs": 1 + }, + "getPopup": { + "minArgs": 1, + "maxArgs": 1 + }, + "getTitle": { + "minArgs": 1, + "maxArgs": 1 + }, + "openPopup": { + "minArgs": 0, + "maxArgs": 0 + }, + "setBadgeBackgroundColor": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setBadgeText": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setIcon": { + "minArgs": 1, + "maxArgs": 1 + }, + "setPopup": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setTitle": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + } + }, + "browsingData": { + "remove": { + "minArgs": 2, + "maxArgs": 2 + }, + "removeCache": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeCookies": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeDownloads": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeFormData": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeHistory": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeLocalStorage": { + "minArgs": 1, + "maxArgs": 1 + }, + "removePasswords": { + "minArgs": 1, + "maxArgs": 1 + }, + "removePluginData": { + "minArgs": 1, + "maxArgs": 1 + }, + "settings": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "commands": { + "getAll": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "contextMenus": { + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + }, + "cookies": { + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAllCookieStores": { + "minArgs": 0, + "maxArgs": 0 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "set": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "devtools": { + "inspectedWindow": { + "eval": { + "minArgs": 1, + "maxArgs": 2, + "singleCallbackArg": false + } + }, + "panels": { + "create": { + "minArgs": 3, + "maxArgs": 3, + "singleCallbackArg": true + } + } + }, + "downloads": { + "cancel": { + "minArgs": 1, + "maxArgs": 1 + }, + "download": { + "minArgs": 1, + "maxArgs": 1 + }, + "erase": { + "minArgs": 1, + "maxArgs": 1 + }, + "getFileIcon": { + "minArgs": 1, + "maxArgs": 2 + }, + "open": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "pause": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeFile": { + "minArgs": 1, + "maxArgs": 1 + }, + "resume": { + "minArgs": 1, + "maxArgs": 1 + }, + "search": { + "minArgs": 1, + "maxArgs": 1 + }, + "show": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + } + }, + "extension": { + "isAllowedFileSchemeAccess": { + "minArgs": 0, + "maxArgs": 0 + }, + "isAllowedIncognitoAccess": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "history": { + "addUrl": { + "minArgs": 1, + "maxArgs": 1 + }, + "deleteAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "deleteRange": { + "minArgs": 1, + "maxArgs": 1 + }, + "deleteUrl": { + "minArgs": 1, + "maxArgs": 1 + }, + "getVisits": { + "minArgs": 1, + "maxArgs": 1 + }, + "search": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "i18n": { + "detectLanguage": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAcceptLanguages": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "identity": { + "launchWebAuthFlow": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "idle": { + "queryState": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "management": { + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "getSelf": { + "minArgs": 0, + "maxArgs": 0 + }, + "setEnabled": { + "minArgs": 2, + "maxArgs": 2 + }, + "uninstallSelf": { + "minArgs": 0, + "maxArgs": 1 + } + }, + "notifications": { + "clear": { + "minArgs": 1, + "maxArgs": 1 + }, + "create": { + "minArgs": 1, + "maxArgs": 2 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "getPermissionLevel": { + "minArgs": 0, + "maxArgs": 0 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + }, + "pageAction": { + "getPopup": { + "minArgs": 1, + "maxArgs": 1 + }, + "getTitle": { + "minArgs": 1, + "maxArgs": 1 + }, + "hide": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setIcon": { + "minArgs": 1, + "maxArgs": 1 + }, + "setPopup": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setTitle": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "show": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + } + }, + "permissions": { + "contains": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "request": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "runtime": { + "getBackgroundPage": { + "minArgs": 0, + "maxArgs": 0 + }, + "getPlatformInfo": { + "minArgs": 0, + "maxArgs": 0 + }, + "openOptionsPage": { + "minArgs": 0, + "maxArgs": 0 + }, + "requestUpdateCheck": { + "minArgs": 0, + "maxArgs": 0 + }, + "sendMessage": { + "minArgs": 1, + "maxArgs": 3 + }, + "sendNativeMessage": { + "minArgs": 2, + "maxArgs": 2 + }, + "setUninstallURL": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "sessions": { + "getDevices": { + "minArgs": 0, + "maxArgs": 1 + }, + "getRecentlyClosed": { + "minArgs": 0, + "maxArgs": 1 + }, + "restore": { + "minArgs": 0, + "maxArgs": 1 + } + }, + "storage": { + "local": { + "clear": { + "minArgs": 0, + "maxArgs": 0 + }, + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getBytesInUse": { + "minArgs": 0, + "maxArgs": 1 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "set": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "managed": { + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getBytesInUse": { + "minArgs": 0, + "maxArgs": 1 + } + }, + "sync": { + "clear": { + "minArgs": 0, + "maxArgs": 0 + }, + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getBytesInUse": { + "minArgs": 0, + "maxArgs": 1 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "set": { + "minArgs": 1, + "maxArgs": 1 + } + } + }, + "tabs": { + "captureVisibleTab": { + "minArgs": 0, + "maxArgs": 2 + }, + "create": { + "minArgs": 1, + "maxArgs": 1 + }, + "detectLanguage": { + "minArgs": 0, + "maxArgs": 1 + }, + "discard": { + "minArgs": 0, + "maxArgs": 1 + }, + "duplicate": { + "minArgs": 1, + "maxArgs": 1 + }, + "executeScript": { + "minArgs": 1, + "maxArgs": 2 + }, + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getCurrent": { + "minArgs": 0, + "maxArgs": 0 + }, + "getZoom": { + "minArgs": 0, + "maxArgs": 1 + }, + "getZoomSettings": { + "minArgs": 0, + "maxArgs": 1 + }, + "highlight": { + "minArgs": 1, + "maxArgs": 1 + }, + "insertCSS": { + "minArgs": 1, + "maxArgs": 2 + }, + "move": { + "minArgs": 2, + "maxArgs": 2 + }, + "query": { + "minArgs": 1, + "maxArgs": 1 + }, + "reload": { + "minArgs": 0, + "maxArgs": 2 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeCSS": { + "minArgs": 1, + "maxArgs": 2 + }, + "sendMessage": { + "minArgs": 2, + "maxArgs": 3 + }, + "setZoom": { + "minArgs": 1, + "maxArgs": 2 + }, + "setZoomSettings": { + "minArgs": 1, + "maxArgs": 2 + }, + "update": { + "minArgs": 1, + "maxArgs": 2 + } + }, + "topSites": { + "get": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "webNavigation": { + "getAllFrames": { + "minArgs": 1, + "maxArgs": 1 + }, + "getFrame": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "webRequest": { + "handlerBehaviorChanged": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "windows": { + "create": { + "minArgs": 0, + "maxArgs": 1 + }, + "get": { + "minArgs": 1, + "maxArgs": 2 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 1 + }, + "getCurrent": { + "minArgs": 0, + "maxArgs": 1 + }, + "getLastFocused": { + "minArgs": 0, + "maxArgs": 1 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + } + }; + + if (Object.keys(apiMetadata).length === 0) { + throw new Error("api-metadata.json has not been included in browser-polyfill"); + } + + /** + * A WeakMap subclass which creates and stores a value for any key which does + * not exist when accessed, but behaves exactly as an ordinary WeakMap + * otherwise. + * + * @param {function} createItem + * A function which will be called in order to create the value for any + * key which does not exist, the first time it is accessed. The + * function receives, as its only argument, the key being created. + */ + class DefaultWeakMap extends WeakMap { + constructor(createItem, items = undefined) { + super(items); + this.createItem = createItem; + } + + get(key) { + if (!this.has(key)) { + this.set(key, this.createItem(key)); + } + + return super.get(key); + } + } + + /** + * Returns true if the given object is an object with a `then` method, and can + * therefore be assumed to behave as a Promise. + * + * @param {*} value The value to test. + * @returns {boolean} True if the value is thenable. + */ + const isThenable = value => { + return value && typeof value === "object" && typeof value.then === "function"; + }; + + /** + * Creates and returns a function which, when called, will resolve or reject + * the given promise based on how it is called: + * + * - If, when called, `chrome.runtime.lastError` contains a non-null object, + * the promise is rejected with that value. + * - If the function is called with exactly one argument, the promise is + * resolved to that value. + * - Otherwise, the promise is resolved to an array containing all of the + * function's arguments. + * + * @param {object} promise + * An object containing the resolution and rejection functions of a + * promise. + * @param {function} promise.resolve + * The promise's resolution function. + * @param {function} promise.rejection + * The promise's rejection function. + * @param {object} metadata + * Metadata about the wrapped method which has created the callback. + * @param {integer} metadata.maxResolvedArgs + * The maximum number of arguments which may be passed to the + * callback created by the wrapped async function. + * + * @returns {function} + * The generated callback function. + */ + const makeCallback = (promise, metadata) => { + return (...callbackArgs) => { + if (extensionAPIs.runtime.lastError) { + promise.reject(extensionAPIs.runtime.lastError); + } else if (metadata.singleCallbackArg || callbackArgs.length <= 1 && metadata.singleCallbackArg !== false) { + promise.resolve(callbackArgs[0]); + } else { + promise.resolve(callbackArgs); + } + }; + }; + + const pluralizeArguments = numArgs => numArgs == 1 ? "argument" : "arguments"; + + /** + * Creates a wrapper function for a method with the given name and metadata. + * + * @param {string} name + * The name of the method which is being wrapped. + * @param {object} metadata + * Metadata about the method being wrapped. + * @param {integer} metadata.minArgs + * The minimum number of arguments which must be passed to the + * function. If called with fewer than this number of arguments, the + * wrapper will raise an exception. + * @param {integer} metadata.maxArgs + * The maximum number of arguments which may be passed to the + * function. If called with more than this number of arguments, the + * wrapper will raise an exception. + * @param {integer} metadata.maxResolvedArgs + * The maximum number of arguments which may be passed to the + * callback created by the wrapped async function. + * + * @returns {function(object, ...*)} + * The generated wrapper function. + */ + const wrapAsyncFunction = (name, metadata) => { + return function asyncFunctionWrapper(target, ...args) { + if (args.length < metadata.minArgs) { + throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`); + } + + if (args.length > metadata.maxArgs) { + throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`); + } + + return new Promise((resolve, reject) => { + if (metadata.fallbackToNoCallback) { + // This API method has currently no callback on Chrome, but it return a promise on Firefox, + // and so the polyfill will try to call it with a callback first, and it will fallback + // to not passing the callback if the first call fails. + try { + target[name](...args, makeCallback({ resolve, reject }, metadata)); + } catch (cbError) { + console.warn(`${name} API method doesn't seem to support the callback parameter, ` + "falling back to call it without a callback: ", cbError); + + target[name](...args); + + // Update the API method metadata, so that the next API calls will not try to + // use the unsupported callback anymore. + metadata.fallbackToNoCallback = false; + metadata.noCallback = true; + + resolve(); + } + } else if (metadata.noCallback) { + target[name](...args); + resolve(); + } else { + target[name](...args, makeCallback({ resolve, reject }, metadata)); + } + }); + }; + }; + + /** + * Wraps an existing method of the target object, so that calls to it are + * intercepted by the given wrapper function. The wrapper function receives, + * as its first argument, the original `target` object, followed by each of + * the arguments passed to the original method. + * + * @param {object} target + * The original target object that the wrapped method belongs to. + * @param {function} method + * The method being wrapped. This is used as the target of the Proxy + * object which is created to wrap the method. + * @param {function} wrapper + * The wrapper function which is called in place of a direct invocation + * of the wrapped method. + * + * @returns {Proxy} + * A Proxy object for the given method, which invokes the given wrapper + * method in its place. + */ + const wrapMethod = (target, method, wrapper) => { + return new Proxy(method, { + apply(targetMethod, thisObj, args) { + return wrapper.call(thisObj, target, ...args); + } + }); + }; + + let hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty); + + /** + * Wraps an object in a Proxy which intercepts and wraps certain methods + * based on the given `wrappers` and `metadata` objects. + * + * @param {object} target + * The target object to wrap. + * + * @param {object} [wrappers = {}] + * An object tree containing wrapper functions for special cases. Any + * function present in this object tree is called in place of the + * method in the same location in the `target` object tree. These + * wrapper methods are invoked as described in {@see wrapMethod}. + * + * @param {object} [metadata = {}] + * An object tree containing metadata used to automatically generate + * Promise-based wrapper functions for asynchronous. Any function in + * the `target` object tree which has a corresponding metadata object + * in the same location in the `metadata` tree is replaced with an + * automatically-generated wrapper function, as described in + * {@see wrapAsyncFunction} + * + * @returns {Proxy} + */ + const wrapObject = (target, wrappers = {}, metadata = {}) => { + let cache = Object.create(null); + let handlers = { + has(proxyTarget, prop) { + return prop in target || prop in cache; + }, + + get(proxyTarget, prop, receiver) { + if (prop in cache) { + return cache[prop]; + } + + if (!(prop in target)) { + return undefined; + } + + let value = target[prop]; + + if (typeof value === "function") { + // This is a method on the underlying object. Check if we need to do + // any wrapping. + + if (typeof wrappers[prop] === "function") { + // We have a special-case wrapper for this method. + value = wrapMethod(target, target[prop], wrappers[prop]); + } else if (hasOwnProperty(metadata, prop)) { + // This is an async method that we have metadata for. Create a + // Promise wrapper for it. + let wrapper = wrapAsyncFunction(prop, metadata[prop]); + value = wrapMethod(target, target[prop], wrapper); + } else { + // This is a method that we don't know or care about. Return the + // original method, bound to the underlying object. + value = value.bind(target); + } + } else if (typeof value === "object" && value !== null && (hasOwnProperty(wrappers, prop) || hasOwnProperty(metadata, prop))) { + // This is an object that we need to do some wrapping for the children + // of. Create a sub-object wrapper for it with the appropriate child + // metadata. + value = wrapObject(value, wrappers[prop], metadata[prop]); + } else { + // We don't need to do any wrapping for this property, + // so just forward all access to the underlying object. + Object.defineProperty(cache, prop, { + configurable: true, + enumerable: true, + get() { + return target[prop]; + }, + set(value) { + target[prop] = value; + } + }); + + return value; + } + + cache[prop] = value; + return value; + }, + + set(proxyTarget, prop, value, receiver) { + if (prop in cache) { + cache[prop] = value; + } else { + target[prop] = value; + } + return true; + }, + + defineProperty(proxyTarget, prop, desc) { + return Reflect.defineProperty(cache, prop, desc); + }, + + deleteProperty(proxyTarget, prop) { + return Reflect.deleteProperty(cache, prop); + } + }; + + // Per contract of the Proxy API, the "get" proxy handler must return the + // original value of the target if that value is declared read-only and + // non-configurable. For this reason, we create an object with the + // prototype set to `target` instead of using `target` directly. + // Otherwise we cannot return a custom object for APIs that + // are declared read-only and non-configurable, such as `chrome.devtools`. + // + // The proxy handlers themselves will still use the original `target` + // instead of the `proxyTarget`, so that the methods and properties are + // dereferenced via the original targets. + let proxyTarget = Object.create(target); + return new Proxy(proxyTarget, handlers); + }; + + /** + * Creates a set of wrapper functions for an event object, which handles + * wrapping of listener functions that those messages are passed. + * + * A single wrapper is created for each listener function, and stored in a + * map. Subsequent calls to `addListener`, `hasListener`, or `removeListener` + * retrieve the original wrapper, so that attempts to remove a + * previously-added listener work as expected. + * + * @param {DefaultWeakMap} wrapperMap + * A DefaultWeakMap object which will create the appropriate wrapper + * for a given listener function when one does not exist, and retrieve + * an existing one when it does. + * + * @returns {object} + */ + const wrapEvent = wrapperMap => ({ + addListener(target, listener, ...args) { + target.addListener(wrapperMap.get(listener), ...args); + }, + + hasListener(target, listener) { + return target.hasListener(wrapperMap.get(listener)); + }, + + removeListener(target, listener) { + target.removeListener(wrapperMap.get(listener)); + } + }); + + // Keep track if the deprecation warning has been logged at least once. + let loggedSendResponseDeprecationWarning = false; + + const onMessageWrappers = new DefaultWeakMap(listener => { + if (typeof listener !== "function") { + return listener; + } + + /** + * Wraps a message listener function so that it may send responses based on + * its return value, rather than by returning a sentinel value and calling a + * callback. If the listener function returns a Promise, the response is + * sent when the promise either resolves or rejects. + * + * @param {*} message + * The message sent by the other end of the channel. + * @param {object} sender + * Details about the sender of the message. + * @param {function(*)} sendResponse + * A callback which, when called with an arbitrary argument, sends + * that value as a response. + * @returns {boolean} + * True if the wrapped listener returned a Promise, which will later + * yield a response. False otherwise. + */ + return function onMessage(message, sender, sendResponse) { + let didCallSendResponse = false; + + let wrappedSendResponse; + let sendResponsePromise = new Promise(resolve => { + wrappedSendResponse = function (response) { + if (!loggedSendResponseDeprecationWarning) { + console.warn(SEND_RESPONSE_DEPRECATION_WARNING, new Error().stack); + loggedSendResponseDeprecationWarning = true; + } + didCallSendResponse = true; + resolve(response); + }; + }); + + let result; + try { + result = listener(message, sender, wrappedSendResponse); + } catch (err) { + result = Promise.reject(err); + } + + const isResultThenable = result !== true && isThenable(result); + + // If the listener didn't returned true or a Promise, or called + // wrappedSendResponse synchronously, we can exit earlier + // because there will be no response sent from this listener. + if (result !== true && !isResultThenable && !didCallSendResponse) { + return false; + } + + // A small helper to send the message if the promise resolves + // and an error if the promise rejects (a wrapped sendMessage has + // to translate the message into a resolved promise or a rejected + // promise). + const sendPromisedResult = promise => { + promise.then(msg => { + // send the message value. + sendResponse(msg); + }, error => { + // Send a JSON representation of the error if the rejected value + // is an instance of error, or the object itself otherwise. + let message; + if (error && (error instanceof Error || typeof error.message === "string")) { + message = error.message; + } else { + message = "An unexpected error occurred"; + } + + sendResponse({ + __mozWebExtensionPolyfillReject__: true, + message + }); + }).catch(err => { + // Print an error on the console if unable to send the response. + console.error("Failed to send onMessage rejected reply", err); + }); + }; + + // If the listener returned a Promise, send the resolved value as a + // result, otherwise wait the promise related to the wrappedSendResponse + // callback to resolve and send it as a response. + if (isResultThenable) { + sendPromisedResult(result); + } else { + sendPromisedResult(sendResponsePromise); + } + + // Let Chrome know that the listener is replying. + return true; + }; + }); + + const wrappedSendMessageCallback = ({ reject, resolve }, reply) => { + if (extensionAPIs.runtime.lastError) { + // Detect when none of the listeners replied to the sendMessage call and resolve + // the promise to undefined as in Firefox. + // See https://github.com/mozilla/webextension-polyfill/issues/130 + if (extensionAPIs.runtime.lastError.message === CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE) { + resolve(); + } else { + reject(extensionAPIs.runtime.lastError); + } + } else if (reply && reply.__mozWebExtensionPolyfillReject__) { + // Convert back the JSON representation of the error into + // an Error instance. + reject(new Error(reply.message)); + } else { + resolve(reply); + } + }; + + const wrappedSendMessage = (name, metadata, apiNamespaceObj, ...args) => { + if (args.length < metadata.minArgs) { + throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`); + } + + if (args.length > metadata.maxArgs) { + throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`); + } + + return new Promise((resolve, reject) => { + const wrappedCb = wrappedSendMessageCallback.bind(null, { resolve, reject }); + args.push(wrappedCb); + apiNamespaceObj.sendMessage(...args); + }); + }; + + const staticWrappers = { + runtime: { + onMessage: wrapEvent(onMessageWrappers), + onMessageExternal: wrapEvent(onMessageWrappers), + sendMessage: wrappedSendMessage.bind(null, "sendMessage", { minArgs: 1, maxArgs: 3 }) + }, + tabs: { + sendMessage: wrappedSendMessage.bind(null, "sendMessage", { minArgs: 2, maxArgs: 3 }) + } + }; + const settingMetadata = { + clear: { minArgs: 1, maxArgs: 1 }, + get: { minArgs: 1, maxArgs: 1 }, + set: { minArgs: 1, maxArgs: 1 } + }; + apiMetadata.privacy = { + network: { + networkPredictionEnabled: settingMetadata, + webRTCIPHandlingPolicy: settingMetadata + }, + services: { + passwordSavingEnabled: settingMetadata + }, + websites: { + hyperlinkAuditingEnabled: settingMetadata, + referrersEnabled: settingMetadata + } + }; + + return wrapObject(extensionAPIs, staticWrappers, apiMetadata); + }; + + if (typeof chrome != "object" || !chrome || !chrome.runtime || !chrome.runtime.id) { + throw new Error("This script should only be loaded in a browser extension."); + } + + // The build process adds a UMD wrapper around this file, which makes the + // `module` variable available. + module.exports = wrapAPIs(chrome); + } else { + module.exports = browser; + } +}); +//# sourceMappingURL=browser-polyfill.js.map diff --git a/vendor/browser-polyfill.js.map b/vendor/browser-polyfill.js.map new file mode 100644 index 0000000..0087908 --- /dev/null +++ b/vendor/browser-polyfill.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["browser-polyfill.js"],"names":["browser","Object","getPrototypeOf","prototype","CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE","SEND_RESPONSE_DEPRECATION_WARNING","wrapAPIs","extensionAPIs","apiMetadata","keys","length","Error","DefaultWeakMap","WeakMap","constructor","createItem","items","undefined","get","key","has","set","isThenable","value","then","makeCallback","promise","metadata","callbackArgs","runtime","lastError","reject","singleCallbackArg","resolve","pluralizeArguments","numArgs","wrapAsyncFunction","name","asyncFunctionWrapper","target","args","minArgs","maxArgs","Promise","fallbackToNoCallback","cbError","console","warn","noCallback","wrapMethod","method","wrapper","Proxy","apply","targetMethod","thisObj","call","hasOwnProperty","Function","bind","wrapObject","wrappers","cache","create","handlers","proxyTarget","prop","receiver","defineProperty","configurable","enumerable","desc","Reflect","deleteProperty","wrapEvent","wrapperMap","addListener","listener","hasListener","removeListener","loggedSendResponseDeprecationWarning","onMessageWrappers","onMessage","message","sender","sendResponse","didCallSendResponse","wrappedSendResponse","sendResponsePromise","response","stack","result","err","isResultThenable","sendPromisedResult","msg","error","__mozWebExtensionPolyfillReject__","catch","wrappedSendMessageCallback","reply","wrappedSendMessage","apiNamespaceObj","wrappedCb","push","sendMessage","staticWrappers","onMessageExternal","tabs","settingMetadata","clear","privacy","network","networkPredictionEnabled","webRTCIPHandlingPolicy","services","passwordSavingEnabled","websites","hyperlinkAuditingEnabled","referrersEnabled","chrome","id","module","exports"],"mappings":"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","file":"browser-polyfill.js","sourcesContent":["/* webextension-polyfill - v0.5.0 - Thu Sep 26 2019 22:22:26 */\n/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */\n/* vim: set sts=2 sw=2 et tw=80: */\n/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/. */\n\"use strict\";\n\nif (typeof browser === \"undefined\" || Object.getPrototypeOf(browser) !== Object.prototype) {\n const CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE = \"The message port closed before a response was received.\";\n const SEND_RESPONSE_DEPRECATION_WARNING = \"Returning a Promise is the preferred way to send a reply from an onMessage/onMessageExternal listener, as the sendResponse will be removed from the specs (See https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage)\";\n\n // Wrapping the bulk of this polyfill in a one-time-use function is a minor\n // optimization for Firefox. Since Spidermonkey does not fully parse the\n // contents of a function until the first time it's called, and since it will\n // never actually need to be called, this allows the polyfill to be included\n // in Firefox nearly for free.\n const wrapAPIs = extensionAPIs => {\n // NOTE: apiMetadata is associated to the content of the api-metadata.json file\n // at build time by replacing the following \"include\" with the content of the\n // JSON file.\n const apiMetadata = {\n \"alarms\": {\n \"clear\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"clearAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"get\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n }\n },\n \"bookmarks\": {\n \"create\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"get\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getChildren\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getRecent\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getSubTree\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getTree\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"move\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n },\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeTree\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"search\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"update\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n }\n },\n \"browserAction\": {\n \"disable\": {\n \"minArgs\": 0,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"enable\": {\n \"minArgs\": 0,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"getBadgeBackgroundColor\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getBadgeText\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getPopup\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getTitle\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"openPopup\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"setBadgeBackgroundColor\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"setBadgeText\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"setIcon\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"setPopup\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"setTitle\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n }\n },\n \"browsingData\": {\n \"remove\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n },\n \"removeCache\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeCookies\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeDownloads\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeFormData\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeHistory\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeLocalStorage\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removePasswords\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removePluginData\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"settings\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n }\n },\n \"commands\": {\n \"getAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n }\n },\n \"contextMenus\": {\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"update\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n }\n },\n \"cookies\": {\n \"get\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getAll\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getAllCookieStores\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"set\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"devtools\": {\n \"inspectedWindow\": {\n \"eval\": {\n \"minArgs\": 1,\n \"maxArgs\": 2,\n \"singleCallbackArg\": false\n }\n },\n \"panels\": {\n \"create\": {\n \"minArgs\": 3,\n \"maxArgs\": 3,\n \"singleCallbackArg\": true\n }\n }\n },\n \"downloads\": {\n \"cancel\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"download\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"erase\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getFileIcon\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"open\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"pause\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeFile\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"resume\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"search\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"show\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n }\n },\n \"extension\": {\n \"isAllowedFileSchemeAccess\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"isAllowedIncognitoAccess\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n }\n },\n \"history\": {\n \"addUrl\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"deleteAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"deleteRange\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"deleteUrl\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getVisits\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"search\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"i18n\": {\n \"detectLanguage\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getAcceptLanguages\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n }\n },\n \"identity\": {\n \"launchWebAuthFlow\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"idle\": {\n \"queryState\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"management\": {\n \"get\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"getSelf\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"setEnabled\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n },\n \"uninstallSelf\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n }\n },\n \"notifications\": {\n \"clear\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"create\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"getAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"getPermissionLevel\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"update\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n }\n },\n \"pageAction\": {\n \"getPopup\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getTitle\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"hide\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"setIcon\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"setPopup\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"setTitle\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n },\n \"show\": {\n \"minArgs\": 1,\n \"maxArgs\": 1,\n \"fallbackToNoCallback\": true\n }\n },\n \"permissions\": {\n \"contains\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"request\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"runtime\": {\n \"getBackgroundPage\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"getPlatformInfo\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"openOptionsPage\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"requestUpdateCheck\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"sendMessage\": {\n \"minArgs\": 1,\n \"maxArgs\": 3\n },\n \"sendNativeMessage\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n },\n \"setUninstallURL\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"sessions\": {\n \"getDevices\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getRecentlyClosed\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"restore\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n }\n },\n \"storage\": {\n \"local\": {\n \"clear\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"get\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getBytesInUse\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"set\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"managed\": {\n \"get\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getBytesInUse\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n }\n },\n \"sync\": {\n \"clear\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"get\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getBytesInUse\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"set\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n }\n },\n \"tabs\": {\n \"captureVisibleTab\": {\n \"minArgs\": 0,\n \"maxArgs\": 2\n },\n \"create\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"detectLanguage\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"discard\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"duplicate\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"executeScript\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"get\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getCurrent\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n },\n \"getZoom\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getZoomSettings\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"highlight\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"insertCSS\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"move\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n },\n \"query\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"reload\": {\n \"minArgs\": 0,\n \"maxArgs\": 2\n },\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"removeCSS\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"sendMessage\": {\n \"minArgs\": 2,\n \"maxArgs\": 3\n },\n \"setZoom\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"setZoomSettings\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"update\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n }\n },\n \"topSites\": {\n \"get\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n }\n },\n \"webNavigation\": {\n \"getAllFrames\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"getFrame\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n }\n },\n \"webRequest\": {\n \"handlerBehaviorChanged\": {\n \"minArgs\": 0,\n \"maxArgs\": 0\n }\n },\n \"windows\": {\n \"create\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"get\": {\n \"minArgs\": 1,\n \"maxArgs\": 2\n },\n \"getAll\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getCurrent\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"getLastFocused\": {\n \"minArgs\": 0,\n \"maxArgs\": 1\n },\n \"remove\": {\n \"minArgs\": 1,\n \"maxArgs\": 1\n },\n \"update\": {\n \"minArgs\": 2,\n \"maxArgs\": 2\n }\n }\n };\n\n if (Object.keys(apiMetadata).length === 0) {\n throw new Error(\"api-metadata.json has not been included in browser-polyfill\");\n }\n\n /**\n * A WeakMap subclass which creates and stores a value for any key which does\n * not exist when accessed, but behaves exactly as an ordinary WeakMap\n * otherwise.\n *\n * @param {function} createItem\n * A function which will be called in order to create the value for any\n * key which does not exist, the first time it is accessed. The\n * function receives, as its only argument, the key being created.\n */\n class DefaultWeakMap extends WeakMap {\n constructor(createItem, items = undefined) {\n super(items);\n this.createItem = createItem;\n }\n\n get(key) {\n if (!this.has(key)) {\n this.set(key, this.createItem(key));\n }\n\n return super.get(key);\n }\n }\n\n /**\n * Returns true if the given object is an object with a `then` method, and can\n * therefore be assumed to behave as a Promise.\n *\n * @param {*} value The value to test.\n * @returns {boolean} True if the value is thenable.\n */\n const isThenable = value => {\n return value && typeof value === \"object\" && typeof value.then === \"function\";\n };\n\n /**\n * Creates and returns a function which, when called, will resolve or reject\n * the given promise based on how it is called:\n *\n * - If, when called, `chrome.runtime.lastError` contains a non-null object,\n * the promise is rejected with that value.\n * - If the function is called with exactly one argument, the promise is\n * resolved to that value.\n * - Otherwise, the promise is resolved to an array containing all of the\n * function's arguments.\n *\n * @param {object} promise\n * An object containing the resolution and rejection functions of a\n * promise.\n * @param {function} promise.resolve\n * The promise's resolution function.\n * @param {function} promise.rejection\n * The promise's rejection function.\n * @param {object} metadata\n * Metadata about the wrapped method which has created the callback.\n * @param {integer} metadata.maxResolvedArgs\n * The maximum number of arguments which may be passed to the\n * callback created by the wrapped async function.\n *\n * @returns {function}\n * The generated callback function.\n */\n const makeCallback = (promise, metadata) => {\n return (...callbackArgs) => {\n if (extensionAPIs.runtime.lastError) {\n promise.reject(extensionAPIs.runtime.lastError);\n } else if (metadata.singleCallbackArg ||\n (callbackArgs.length <= 1 && metadata.singleCallbackArg !== false)) {\n promise.resolve(callbackArgs[0]);\n } else {\n promise.resolve(callbackArgs);\n }\n };\n };\n\n const pluralizeArguments = (numArgs) => numArgs == 1 ? \"argument\" : \"arguments\";\n\n /**\n * Creates a wrapper function for a method with the given name and metadata.\n *\n * @param {string} name\n * The name of the method which is being wrapped.\n * @param {object} metadata\n * Metadata about the method being wrapped.\n * @param {integer} metadata.minArgs\n * The minimum number of arguments which must be passed to the\n * function. If called with fewer than this number of arguments, the\n * wrapper will raise an exception.\n * @param {integer} metadata.maxArgs\n * The maximum number of arguments which may be passed to the\n * function. If called with more than this number of arguments, the\n * wrapper will raise an exception.\n * @param {integer} metadata.maxResolvedArgs\n * The maximum number of arguments which may be passed to the\n * callback created by the wrapped async function.\n *\n * @returns {function(object, ...*)}\n * The generated wrapper function.\n */\n const wrapAsyncFunction = (name, metadata) => {\n return function asyncFunctionWrapper(target, ...args) {\n if (args.length < metadata.minArgs) {\n throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`);\n }\n\n if (args.length > metadata.maxArgs) {\n throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`);\n }\n\n return new Promise((resolve, reject) => {\n if (metadata.fallbackToNoCallback) {\n // This API method has currently no callback on Chrome, but it return a promise on Firefox,\n // and so the polyfill will try to call it with a callback first, and it will fallback\n // to not passing the callback if the first call fails.\n try {\n target[name](...args, makeCallback({resolve, reject}, metadata));\n } catch (cbError) {\n console.warn(`${name} API method doesn't seem to support the callback parameter, ` +\n \"falling back to call it without a callback: \", cbError);\n\n target[name](...args);\n\n // Update the API method metadata, so that the next API calls will not try to\n // use the unsupported callback anymore.\n metadata.fallbackToNoCallback = false;\n metadata.noCallback = true;\n\n resolve();\n }\n } else if (metadata.noCallback) {\n target[name](...args);\n resolve();\n } else {\n target[name](...args, makeCallback({resolve, reject}, metadata));\n }\n });\n };\n };\n\n /**\n * Wraps an existing method of the target object, so that calls to it are\n * intercepted by the given wrapper function. The wrapper function receives,\n * as its first argument, the original `target` object, followed by each of\n * the arguments passed to the original method.\n *\n * @param {object} target\n * The original target object that the wrapped method belongs to.\n * @param {function} method\n * The method being wrapped. This is used as the target of the Proxy\n * object which is created to wrap the method.\n * @param {function} wrapper\n * The wrapper function which is called in place of a direct invocation\n * of the wrapped method.\n *\n * @returns {Proxy}\n * A Proxy object for the given method, which invokes the given wrapper\n * method in its place.\n */\n const wrapMethod = (target, method, wrapper) => {\n return new Proxy(method, {\n apply(targetMethod, thisObj, args) {\n return wrapper.call(thisObj, target, ...args);\n },\n });\n };\n\n let hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);\n\n /**\n * Wraps an object in a Proxy which intercepts and wraps certain methods\n * based on the given `wrappers` and `metadata` objects.\n *\n * @param {object} target\n * The target object to wrap.\n *\n * @param {object} [wrappers = {}]\n * An object tree containing wrapper functions for special cases. Any\n * function present in this object tree is called in place of the\n * method in the same location in the `target` object tree. These\n * wrapper methods are invoked as described in {@see wrapMethod}.\n *\n * @param {object} [metadata = {}]\n * An object tree containing metadata used to automatically generate\n * Promise-based wrapper functions for asynchronous. Any function in\n * the `target` object tree which has a corresponding metadata object\n * in the same location in the `metadata` tree is replaced with an\n * automatically-generated wrapper function, as described in\n * {@see wrapAsyncFunction}\n *\n * @returns {Proxy}\n */\n const wrapObject = (target, wrappers = {}, metadata = {}) => {\n let cache = Object.create(null);\n let handlers = {\n has(proxyTarget, prop) {\n return prop in target || prop in cache;\n },\n\n get(proxyTarget, prop, receiver) {\n if (prop in cache) {\n return cache[prop];\n }\n\n if (!(prop in target)) {\n return undefined;\n }\n\n let value = target[prop];\n\n if (typeof value === \"function\") {\n // This is a method on the underlying object. Check if we need to do\n // any wrapping.\n\n if (typeof wrappers[prop] === \"function\") {\n // We have a special-case wrapper for this method.\n value = wrapMethod(target, target[prop], wrappers[prop]);\n } else if (hasOwnProperty(metadata, prop)) {\n // This is an async method that we have metadata for. Create a\n // Promise wrapper for it.\n let wrapper = wrapAsyncFunction(prop, metadata[prop]);\n value = wrapMethod(target, target[prop], wrapper);\n } else {\n // This is a method that we don't know or care about. Return the\n // original method, bound to the underlying object.\n value = value.bind(target);\n }\n } else if (typeof value === \"object\" && value !== null &&\n (hasOwnProperty(wrappers, prop) ||\n hasOwnProperty(metadata, prop))) {\n // This is an object that we need to do some wrapping for the children\n // of. Create a sub-object wrapper for it with the appropriate child\n // metadata.\n value = wrapObject(value, wrappers[prop], metadata[prop]);\n } else {\n // We don't need to do any wrapping for this property,\n // so just forward all access to the underlying object.\n Object.defineProperty(cache, prop, {\n configurable: true,\n enumerable: true,\n get() {\n return target[prop];\n },\n set(value) {\n target[prop] = value;\n },\n });\n\n return value;\n }\n\n cache[prop] = value;\n return value;\n },\n\n set(proxyTarget, prop, value, receiver) {\n if (prop in cache) {\n cache[prop] = value;\n } else {\n target[prop] = value;\n }\n return true;\n },\n\n defineProperty(proxyTarget, prop, desc) {\n return Reflect.defineProperty(cache, prop, desc);\n },\n\n deleteProperty(proxyTarget, prop) {\n return Reflect.deleteProperty(cache, prop);\n },\n };\n\n // Per contract of the Proxy API, the \"get\" proxy handler must return the\n // original value of the target if that value is declared read-only and\n // non-configurable. For this reason, we create an object with the\n // prototype set to `target` instead of using `target` directly.\n // Otherwise we cannot return a custom object for APIs that\n // are declared read-only and non-configurable, such as `chrome.devtools`.\n //\n // The proxy handlers themselves will still use the original `target`\n // instead of the `proxyTarget`, so that the methods and properties are\n // dereferenced via the original targets.\n let proxyTarget = Object.create(target);\n return new Proxy(proxyTarget, handlers);\n };\n\n /**\n * Creates a set of wrapper functions for an event object, which handles\n * wrapping of listener functions that those messages are passed.\n *\n * A single wrapper is created for each listener function, and stored in a\n * map. Subsequent calls to `addListener`, `hasListener`, or `removeListener`\n * retrieve the original wrapper, so that attempts to remove a\n * previously-added listener work as expected.\n *\n * @param {DefaultWeakMap} wrapperMap\n * A DefaultWeakMap object which will create the appropriate wrapper\n * for a given listener function when one does not exist, and retrieve\n * an existing one when it does.\n *\n * @returns {object}\n */\n const wrapEvent = wrapperMap => ({\n addListener(target, listener, ...args) {\n target.addListener(wrapperMap.get(listener), ...args);\n },\n\n hasListener(target, listener) {\n return target.hasListener(wrapperMap.get(listener));\n },\n\n removeListener(target, listener) {\n target.removeListener(wrapperMap.get(listener));\n },\n });\n\n // Keep track if the deprecation warning has been logged at least once.\n let loggedSendResponseDeprecationWarning = false;\n\n const onMessageWrappers = new DefaultWeakMap(listener => {\n if (typeof listener !== \"function\") {\n return listener;\n }\n\n /**\n * Wraps a message listener function so that it may send responses based on\n * its return value, rather than by returning a sentinel value and calling a\n * callback. If the listener function returns a Promise, the response is\n * sent when the promise either resolves or rejects.\n *\n * @param {*} message\n * The message sent by the other end of the channel.\n * @param {object} sender\n * Details about the sender of the message.\n * @param {function(*)} sendResponse\n * A callback which, when called with an arbitrary argument, sends\n * that value as a response.\n * @returns {boolean}\n * True if the wrapped listener returned a Promise, which will later\n * yield a response. False otherwise.\n */\n return function onMessage(message, sender, sendResponse) {\n let didCallSendResponse = false;\n\n let wrappedSendResponse;\n let sendResponsePromise = new Promise(resolve => {\n wrappedSendResponse = function(response) {\n if (!loggedSendResponseDeprecationWarning) {\n console.warn(SEND_RESPONSE_DEPRECATION_WARNING, new Error().stack);\n loggedSendResponseDeprecationWarning = true;\n }\n didCallSendResponse = true;\n resolve(response);\n };\n });\n\n let result;\n try {\n result = listener(message, sender, wrappedSendResponse);\n } catch (err) {\n result = Promise.reject(err);\n }\n\n const isResultThenable = result !== true && isThenable(result);\n\n // If the listener didn't returned true or a Promise, or called\n // wrappedSendResponse synchronously, we can exit earlier\n // because there will be no response sent from this listener.\n if (result !== true && !isResultThenable && !didCallSendResponse) {\n return false;\n }\n\n // A small helper to send the message if the promise resolves\n // and an error if the promise rejects (a wrapped sendMessage has\n // to translate the message into a resolved promise or a rejected\n // promise).\n const sendPromisedResult = (promise) => {\n promise.then(msg => {\n // send the message value.\n sendResponse(msg);\n }, error => {\n // Send a JSON representation of the error if the rejected value\n // is an instance of error, or the object itself otherwise.\n let message;\n if (error && (error instanceof Error ||\n typeof error.message === \"string\")) {\n message = error.message;\n } else {\n message = \"An unexpected error occurred\";\n }\n\n sendResponse({\n __mozWebExtensionPolyfillReject__: true,\n message,\n });\n }).catch(err => {\n // Print an error on the console if unable to send the response.\n console.error(\"Failed to send onMessage rejected reply\", err);\n });\n };\n\n // If the listener returned a Promise, send the resolved value as a\n // result, otherwise wait the promise related to the wrappedSendResponse\n // callback to resolve and send it as a response.\n if (isResultThenable) {\n sendPromisedResult(result);\n } else {\n sendPromisedResult(sendResponsePromise);\n }\n\n // Let Chrome know that the listener is replying.\n return true;\n };\n });\n\n const wrappedSendMessageCallback = ({reject, resolve}, reply) => {\n if (extensionAPIs.runtime.lastError) {\n // Detect when none of the listeners replied to the sendMessage call and resolve\n // the promise to undefined as in Firefox.\n // See https://github.com/mozilla/webextension-polyfill/issues/130\n if (extensionAPIs.runtime.lastError.message === CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE) {\n resolve();\n } else {\n reject(extensionAPIs.runtime.lastError);\n }\n } else if (reply && reply.__mozWebExtensionPolyfillReject__) {\n // Convert back the JSON representation of the error into\n // an Error instance.\n reject(new Error(reply.message));\n } else {\n resolve(reply);\n }\n };\n\n const wrappedSendMessage = (name, metadata, apiNamespaceObj, ...args) => {\n if (args.length < metadata.minArgs) {\n throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`);\n }\n\n if (args.length > metadata.maxArgs) {\n throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`);\n }\n\n return new Promise((resolve, reject) => {\n const wrappedCb = wrappedSendMessageCallback.bind(null, {resolve, reject});\n args.push(wrappedCb);\n apiNamespaceObj.sendMessage(...args);\n });\n };\n\n const staticWrappers = {\n runtime: {\n onMessage: wrapEvent(onMessageWrappers),\n onMessageExternal: wrapEvent(onMessageWrappers),\n sendMessage: wrappedSendMessage.bind(null, \"sendMessage\", {minArgs: 1, maxArgs: 3}),\n },\n tabs: {\n sendMessage: wrappedSendMessage.bind(null, \"sendMessage\", {minArgs: 2, maxArgs: 3}),\n },\n };\n const settingMetadata = {\n clear: {minArgs: 1, maxArgs: 1},\n get: {minArgs: 1, maxArgs: 1},\n set: {minArgs: 1, maxArgs: 1},\n };\n apiMetadata.privacy = {\n network: {\n networkPredictionEnabled: settingMetadata,\n webRTCIPHandlingPolicy: settingMetadata,\n },\n services: {\n passwordSavingEnabled: settingMetadata,\n },\n websites: {\n hyperlinkAuditingEnabled: settingMetadata,\n referrersEnabled: settingMetadata,\n },\n };\n\n return wrapObject(extensionAPIs, staticWrappers, apiMetadata);\n };\n\n if (typeof chrome != \"object\" || !chrome || !chrome.runtime || !chrome.runtime.id) {\n throw new Error(\"This script should only be loaded in a browser extension.\");\n }\n\n // The build process adds a UMD wrapper around this file, which makes the\n // `module` variable available.\n module.exports = wrapAPIs(chrome);\n} else {\n module.exports = browser;\n}\n"]} \ No newline at end of file