darkreader
Version:
Dark mode for every website
1,369 lines (1,342 loc) • 289 kB
JavaScript
/**
* Dark Reader v4.9.58
* https://darkreader.org/
*/
(function (global, factory) {
typeof exports === "object" && typeof module !== "undefined"
? factory(exports)
: typeof define === "function" && define.amd
? define(["exports"], factory)
: ((global =
typeof globalThis !== "undefined" ? globalThis : global || self),
factory((global.DarkReader = {})));
})(this, function (exports) {
"use strict";
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
var __assign = function () {
__assign =
Object.assign ||
function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
}
function __generator(thisArg, body) {
var _ = {
label: 0,
sent: function () {
if (t[0] & 1) throw t[1];
return t[1];
},
trys: [],
ops: []
},
f,
y,
t,
g;
return (
(g = {next: verb(0), throw: verb(1), return: verb(2)}),
typeof Symbol === "function" &&
(g[Symbol.iterator] = function () {
return this;
}),
g
);
function verb(n) {
return function (v) {
return step([n, v]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_)
try {
if (
((f = 1),
y &&
(t =
op[0] & 2
? y["return"]
: op[0]
? y["throw"] ||
((t = y["return"]) && t.call(y), 0)
: y.next) &&
!(t = t.call(y, op[1])).done)
)
return t;
if (((y = 0), t)) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return {value: op[1], done: false};
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (
!((t = _.trys),
(t = t.length > 0 && t[t.length - 1])) &&
(op[0] === 6 || op[0] === 2)
) {
_ = 0;
continue;
}
if (
op[0] === 3 &&
(!t || (op[1] > t[0] && op[1] < t[3]))
) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5) throw op[1];
return {value: op[0] ? op[1] : void 0, done: true};
}
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator,
m = s && o[s],
i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length) o = void 0;
return {value: o && o[i++], done: !o};
}
};
throw new TypeError(
s ? "Object is not iterable." : "Symbol.iterator is not defined."
);
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o),
r,
ar = [],
e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
} catch (error) {
e = {error: error};
} finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
} finally {
if (e) throw e.error;
}
}
return ar;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
var MessageType;
(function (MessageType) {
MessageType["UI_GET_DATA"] = "ui-get-data";
MessageType["UI_SUBSCRIBE_TO_CHANGES"] = "ui-subscribe-to-changes";
MessageType["UI_UNSUBSCRIBE_FROM_CHANGES"] =
"ui-unsubscribe-from-changes";
MessageType["UI_CHANGE_SETTINGS"] = "ui-change-settings";
MessageType["UI_SET_THEME"] = "ui-set-theme";
MessageType["UI_SET_SHORTCUT"] = "ui-set-shortcut";
MessageType["UI_TOGGLE_ACTIVE_TAB"] = "ui-toggle-active-tab";
MessageType["UI_MARK_NEWS_AS_READ"] = "ui-mark-news-as-read";
MessageType["UI_MARK_NEWS_AS_DISPLAYED"] = "ui-mark-news-as-displayed";
MessageType["UI_LOAD_CONFIG"] = "ui-load-config";
MessageType["UI_APPLY_DEV_DYNAMIC_THEME_FIXES"] =
"ui-apply-dev-dynamic-theme-fixes";
MessageType["UI_RESET_DEV_DYNAMIC_THEME_FIXES"] =
"ui-reset-dev-dynamic-theme-fixes";
MessageType["UI_APPLY_DEV_INVERSION_FIXES"] =
"ui-apply-dev-inversion-fixes";
MessageType["UI_RESET_DEV_INVERSION_FIXES"] =
"ui-reset-dev-inversion-fixes";
MessageType["UI_APPLY_DEV_STATIC_THEMES"] =
"ui-apply-dev-static-themes";
MessageType["UI_RESET_DEV_STATIC_THEMES"] =
"ui-reset-dev-static-themes";
MessageType["UI_SAVE_FILE"] = "ui-save-file";
MessageType["UI_REQUEST_EXPORT_CSS"] = "ui-request-export-css";
MessageType["UI_COLOR_SCHEME_CHANGE"] = "ui-color-scheme-change";
MessageType["BG_CHANGES"] = "bg-changes";
MessageType["BG_ADD_CSS_FILTER"] = "bg-add-css-filter";
MessageType["BG_ADD_STATIC_THEME"] = "bg-add-static-theme";
MessageType["BG_ADD_SVG_FILTER"] = "bg-add-svg-filter";
MessageType["BG_ADD_DYNAMIC_THEME"] = "bg-add-dynamic-theme";
MessageType["BG_EXPORT_CSS"] = "bg-export-css";
MessageType["BG_UNSUPPORTED_SENDER"] = "bg-unsupported-sender";
MessageType["BG_CLEAN_UP"] = "bg-clean-up";
MessageType["BG_RELOAD"] = "bg-reload";
MessageType["BG_FETCH_RESPONSE"] = "bg-fetch-response";
MessageType["BG_UI_UPDATE"] = "bg-ui-update";
MessageType["BG_CSS_UPDATE"] = "bg-css-update";
MessageType["CS_COLOR_SCHEME_CHANGE"] = "cs-color-scheme-change";
MessageType["CS_FRAME_CONNECT"] = "cs-frame-connect";
MessageType["CS_FRAME_FORGET"] = "cs-frame-forget";
MessageType["CS_FRAME_FREEZE"] = "cs-frame-freeze";
MessageType["CS_FRAME_RESUME"] = "cs-frame-resume";
MessageType["CS_EXPORT_CSS_RESPONSE"] = "cs-export-css-response";
MessageType["CS_FETCH"] = "cs-fetch";
MessageType["CS_DARK_THEME_DETECTED"] = "cs-dark-theme-detected";
MessageType["CS_DARK_THEME_NOT_DETECTED"] =
"cs-dark-theme-not-detected";
MessageType["CS_LOG"] = "cs-log";
})(MessageType || (MessageType = {}));
var isNavigatorDefined = typeof navigator !== "undefined";
var userAgent = isNavigatorDefined
? navigator.userAgentData &&
Array.isArray(navigator.userAgentData.brands)
? navigator.userAgentData.brands
.map(function (brand) {
return ""
.concat(brand.brand.toLowerCase(), " ")
.concat(brand.version);
})
.join(" ")
: navigator.userAgent.toLowerCase()
: "some useragent";
var platform = isNavigatorDefined
? navigator.userAgentData &&
typeof navigator.userAgentData.platform === "string"
? navigator.userAgentData.platform.toLowerCase()
: navigator.platform.toLowerCase()
: "some platform";
var isChromium =
userAgent.includes("chrome") || userAgent.includes("chromium");
var isThunderbird = userAgent.includes("thunderbird");
var isFirefox =
userAgent.includes("firefox") ||
userAgent.includes("librewolf") ||
isThunderbird;
userAgent.includes("vivaldi");
userAgent.includes("yabrowser");
userAgent.includes("opr") || userAgent.includes("opera");
userAgent.includes("edg");
var isSafari = userAgent.includes("safari") && !isChromium;
var isWindows = platform.startsWith("win");
var isMacOS = platform.startsWith("mac");
isNavigatorDefined && navigator.userAgentData
? navigator.userAgentData.mobile
: userAgent.includes("mobile");
var isShadowDomSupported = typeof ShadowRoot === "function";
var isMatchMediaChangeEventListenerSupported =
typeof MediaQueryList === "function" &&
typeof MediaQueryList.prototype.addEventListener === "function";
(function () {
var m = userAgent.match(/chrom(?:e|ium)(?:\/| )([^ ]+)/);
if (m && m[1]) {
return m[1];
}
return "";
})();
(function () {
var m = userAgent.match(/(?:firefox|librewolf)(?:\/| )([^ ]+)/);
if (m && m[1]) {
return m[1];
}
return "";
})();
var isDefinedSelectorSupported = (function () {
try {
document.querySelector(":defined");
return true;
} catch (err) {
return false;
}
})();
var isCSSColorSchemePropSupported = (function () {
if (typeof document === "undefined") {
return false;
}
var el = document.createElement("div");
el.setAttribute("style", "color-scheme: dark");
return el.style && el.style.colorScheme === "dark";
})();
function getOKResponse(url, mimeType, origin) {
return __awaiter(this, void 0, void 0, function () {
var response;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
return [
4,
fetch(url, {
cache: "force-cache",
credentials: "omit",
referrer: origin
})
];
case 1:
response = _a.sent();
if (
isFirefox &&
mimeType === "text/css" &&
url.startsWith("moz-extension://") &&
url.endsWith(".css")
) {
return [2, response];
}
if (
mimeType &&
!response.headers
.get("Content-Type")
.startsWith(mimeType)
) {
throw new Error(
"Mime type mismatch when loading ".concat(url)
);
}
if (!response.ok) {
throw new Error(
"Unable to load "
.concat(url, " ")
.concat(response.status, " ")
.concat(response.statusText)
);
}
return [2, response];
}
});
});
}
function loadAsDataURL(url, mimeType) {
return __awaiter(this, void 0, void 0, function () {
var response;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
return [4, getOKResponse(url, mimeType)];
case 1:
response = _a.sent();
return [4, readResponseAsDataURL(response)];
case 2:
return [2, _a.sent()];
}
});
});
}
function readResponseAsDataURL(response) {
return __awaiter(this, void 0, void 0, function () {
var blob, dataURL;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
return [4, response.blob()];
case 1:
blob = _a.sent();
return [
4,
new Promise(function (resolve) {
var reader = new FileReader();
reader.onloadend = function () {
return resolve(reader.result);
};
reader.readAsDataURL(blob);
})
];
case 2:
dataURL = _a.sent();
return [2, dataURL];
}
});
});
}
var throwCORSError = function (url) {
return __awaiter(void 0, void 0, void 0, function () {
return __generator(this, function (_a) {
return [
2,
Promise.reject(
new Error(
[
"Embedded Dark Reader cannot access a cross-origin resource",
url,
"Overview your URLs and CORS policies or use",
"`DarkReader.setFetchMethod(fetch: (url) => Promise<Response>))`.",
"See if using `DarkReader.setFetchMethod(window.fetch)`",
"before `DarkReader.enable()` works."
].join(" ")
)
)
];
});
});
};
var fetcher = throwCORSError;
function setFetchMethod$1(fetch) {
if (fetch) {
fetcher = fetch;
} else {
fetcher = throwCORSError;
}
}
function callFetchMethod(url) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
return [4, fetcher(url)];
case 1:
return [2, _a.sent()];
}
});
});
}
if (!window.chrome) {
window.chrome = {};
}
if (!chrome.runtime) {
chrome.runtime = {};
}
var messageListeners = new Set();
function sendMessage() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return __awaiter(this, void 0, void 0, function () {
var id_1, _a, url, responseType, response, text_1, error_1;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (!(args[0] && args[0].type === MessageType.CS_FETCH))
return [3, 8];
id_1 = args[0].id;
_b.label = 1;
case 1:
_b.trys.push([1, 7, , 8]);
(_a = args[0].data),
(url = _a.url),
(responseType = _a.responseType);
return [4, callFetchMethod(url)];
case 2:
response = _b.sent();
if (!(responseType === "data-url")) return [3, 4];
return [4, readResponseAsDataURL(response)];
case 3:
text_1 = _b.sent();
return [3, 6];
case 4:
return [4, response.text()];
case 5:
text_1 = _b.sent();
_b.label = 6;
case 6:
messageListeners.forEach(function (cb) {
return cb({
type: MessageType.BG_FETCH_RESPONSE,
data: text_1,
error: null,
id: id_1
});
});
return [3, 8];
case 7:
error_1 = _b.sent();
console.error(error_1);
messageListeners.forEach(function (cb) {
return cb({
type: MessageType.BG_FETCH_RESPONSE,
data: null,
error: error_1,
id: id_1
});
});
return [3, 8];
case 8:
return [2];
}
});
});
}
function addMessageListener(callback) {
messageListeners.add(callback);
}
if (typeof chrome.runtime.sendMessage === "function") {
var nativeSendMessage_1 = chrome.runtime.sendMessage;
chrome.runtime.sendMessage = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
sendMessage.apply(void 0, __spreadArray([], __read(args), false));
nativeSendMessage_1.apply(chrome.runtime, args);
};
} else {
chrome.runtime.sendMessage = sendMessage;
}
if (!chrome.runtime.onMessage) {
chrome.runtime.onMessage = {};
}
if (typeof chrome.runtime.onMessage.addListener === "function") {
var nativeAddListener_1 = chrome.runtime.onMessage.addListener;
chrome.runtime.onMessage.addListener = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
addMessageListener(args[0]);
nativeAddListener_1.apply(chrome.runtime.onMessage, args);
};
} else {
chrome.runtime.onMessage.addListener = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return addMessageListener(args[0]);
};
}
var ThemeEngine;
(function (ThemeEngine) {
ThemeEngine["cssFilter"] = "cssFilter";
ThemeEngine["svgFilter"] = "svgFilter";
ThemeEngine["staticTheme"] = "staticTheme";
ThemeEngine["dynamicTheme"] = "dynamicTheme";
})(ThemeEngine || (ThemeEngine = {}));
var AutomationMode;
(function (AutomationMode) {
AutomationMode["NONE"] = "";
AutomationMode["TIME"] = "time";
AutomationMode["SYSTEM"] = "system";
AutomationMode["LOCATION"] = "location";
})(AutomationMode || (AutomationMode = {}));
var DEFAULT_COLORS = {
darkScheme: {
background: "#181a1b",
text: "#e8e6e3"
},
lightScheme: {
background: "#dcdad7",
text: "#181a1b"
}
};
var DEFAULT_THEME = {
mode: 1,
brightness: 100,
contrast: 100,
grayscale: 0,
sepia: 0,
useFont: false,
fontFamily: isMacOS
? "Helvetica Neue"
: isWindows
? "Segoe UI"
: "Open Sans",
textStroke: 0,
engine: ThemeEngine.dynamicTheme,
stylesheet: "",
darkSchemeBackgroundColor: DEFAULT_COLORS.darkScheme.background,
darkSchemeTextColor: DEFAULT_COLORS.darkScheme.text,
lightSchemeBackgroundColor: DEFAULT_COLORS.lightScheme.background,
lightSchemeTextColor: DEFAULT_COLORS.lightScheme.text,
scrollbarColor: isMacOS ? "" : "auto",
selectionColor: "auto",
styleSystemControls: !isCSSColorSchemePropSupported,
lightColorScheme: "Default",
darkColorScheme: "Default",
immediateModify: false
};
({
enabled: true,
fetchNews: true,
theme: DEFAULT_THEME,
presets: [],
customThemes: [],
siteList: [],
siteListEnabled: [],
applyToListedOnly: false,
changeBrowserTheme: false,
syncSettings: true,
syncSitesFixes: false,
automation: {
enabled: false,
mode: AutomationMode.NONE,
behavior: "OnOff"
},
time: {
activation: "18:00",
deactivation: "9:00"
},
location: {
latitude: null,
longitude: null
},
previewNewDesign: false,
enableForPDF: true,
enableForProtectedPages: false,
enableContextMenus: false,
detectDarkTheme: false
});
function isArrayLike(items) {
return items.length != null;
}
function forEach(items, iterator) {
var e_1, _a;
if (isArrayLike(items)) {
for (var i = 0, len = items.length; i < len; i++) {
iterator(items[i]);
}
} else {
try {
for (
var items_1 = __values(items), items_1_1 = items_1.next();
!items_1_1.done;
items_1_1 = items_1.next()
) {
var item = items_1_1.value;
iterator(item);
}
} catch (e_1_1) {
e_1 = {error: e_1_1};
} finally {
try {
if (items_1_1 && !items_1_1.done && (_a = items_1.return))
_a.call(items_1);
} finally {
if (e_1) throw e_1.error;
}
}
}
}
function push(array, addition) {
forEach(addition, function (a) {
return array.push(a);
});
}
function toArray(items) {
var results = [];
for (var i = 0, len = items.length; i < len; i++) {
results.push(items[i]);
}
return results;
}
function logInfo() {}
function logWarn() {}
function throttle(callback) {
var pending = false;
var frameId = null;
var lastArgs;
var throttled = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
lastArgs = args;
if (frameId) {
pending = true;
} else {
callback.apply(
void 0,
__spreadArray([], __read(lastArgs), false)
);
frameId = requestAnimationFrame(function () {
frameId = null;
if (pending) {
callback.apply(
void 0,
__spreadArray([], __read(lastArgs), false)
);
pending = false;
}
});
}
};
var cancel = function () {
cancelAnimationFrame(frameId);
pending = false;
frameId = null;
};
return Object.assign(throttled, {cancel: cancel});
}
function createAsyncTasksQueue() {
var tasks = [];
var frameId = null;
function runTasks() {
var task;
while ((task = tasks.shift())) {
task();
}
frameId = null;
}
function add(task) {
tasks.push(task);
if (!frameId) {
frameId = requestAnimationFrame(runTasks);
}
}
function cancel() {
tasks.splice(0);
cancelAnimationFrame(frameId);
frameId = null;
}
return {add: add, cancel: cancel};
}
function getDuration(time) {
var duration = 0;
if (time.seconds) {
duration += time.seconds * 1000;
}
if (time.minutes) {
duration += time.minutes * 60 * 1000;
}
if (time.hours) {
duration += time.hours * 60 * 60 * 1000;
}
if (time.days) {
duration += time.days * 24 * 60 * 60 * 1000;
}
return duration;
}
function removeNode(node) {
node && node.parentNode && node.parentNode.removeChild(node);
}
function watchForNodePosition(node, mode, onRestore) {
if (onRestore === void 0) {
onRestore = Function.prototype;
}
var MAX_ATTEMPTS_COUNT = 10;
var RETRY_TIMEOUT = getDuration({seconds: 2});
var ATTEMPTS_INTERVAL = getDuration({seconds: 10});
var prevSibling = node.previousSibling;
var parent = node.parentNode;
if (!parent) {
throw new Error(
"Unable to watch for node position: parent element not found"
);
}
if (mode === "prev-sibling" && !prevSibling) {
throw new Error(
"Unable to watch for node position: there is no previous sibling"
);
}
var attempts = 0;
var start = null;
var timeoutId = null;
var restore = throttle(function () {
if (timeoutId) {
return;
}
attempts++;
var now = Date.now();
if (start == null) {
start = now;
} else if (attempts >= MAX_ATTEMPTS_COUNT) {
if (now - start < ATTEMPTS_INTERVAL) {
timeoutId = setTimeout(function () {
start = null;
attempts = 0;
timeoutId = null;
restore();
}, RETRY_TIMEOUT);
return;
}
start = now;
attempts = 1;
}
if (mode === "parent") {
if (prevSibling && prevSibling.parentNode !== parent) {
stop();
return;
}
}
if (mode === "prev-sibling") {
if (prevSibling.parentNode == null) {
stop();
return;
}
if (prevSibling.parentNode !== parent) {
updateParent(prevSibling.parentNode);
}
}
parent.insertBefore(
node,
prevSibling ? prevSibling.nextSibling : parent.firstChild
);
observer.takeRecords();
onRestore && onRestore();
});
var observer = new MutationObserver(function () {
if (
(mode === "parent" && node.parentNode !== parent) ||
(mode === "prev-sibling" &&
node.previousSibling !== prevSibling)
) {
restore();
}
});
var run = function () {
observer.observe(parent, {childList: true});
};
var stop = function () {
clearTimeout(timeoutId);
observer.disconnect();
restore.cancel();
};
var skip = function () {
observer.takeRecords();
};
var updateParent = function (parentNode) {
parent = parentNode;
stop();
run();
};
run();
return {run: run, stop: stop, skip: skip};
}
function iterateShadowHosts(root, iterator) {
if (root == null) {
return;
}
var walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
acceptNode: function (node) {
return node.shadowRoot == null
? NodeFilter.FILTER_SKIP
: NodeFilter.FILTER_ACCEPT;
}
});
for (
var node = root.shadowRoot ? walker.currentNode : walker.nextNode();
node != null;
node = walker.nextNode()
) {
if (node.classList.contains("surfingkeys_hints_host")) {
continue;
}
iterator(node);
iterateShadowHosts(node.shadowRoot, iterator);
}
}
var isDOMReady = function () {
return (
document.readyState === "complete" ||
document.readyState === "interactive"
);
};
function setIsDOMReady(newFunc) {
isDOMReady = newFunc;
}
var readyStateListeners = new Set();
function addDOMReadyListener(listener) {
isDOMReady() ? listener() : readyStateListeners.add(listener);
}
function removeDOMReadyListener(listener) {
readyStateListeners.delete(listener);
}
function isReadyStateComplete() {
return document.readyState === "complete";
}
var readyStateCompleteListeners = new Set();
function addReadyStateCompleteListener(listener) {
isReadyStateComplete()
? listener()
: readyStateCompleteListeners.add(listener);
}
function cleanReadyStateCompleteListeners() {
readyStateCompleteListeners.clear();
}
if (!isDOMReady()) {
var onReadyStateChange_1 = function () {
if (isDOMReady()) {
readyStateListeners.forEach(function (listener) {
return listener();
});
readyStateListeners.clear();
if (isReadyStateComplete()) {
document.removeEventListener(
"readystatechange",
onReadyStateChange_1
);
readyStateCompleteListeners.forEach(function (listener) {
return listener();
});
readyStateCompleteListeners.clear();
}
}
};
document.addEventListener("readystatechange", onReadyStateChange_1);
}
var HUGE_MUTATIONS_COUNT = 1000;
function isHugeMutation(mutations) {
if (mutations.length > HUGE_MUTATIONS_COUNT) {
return true;
}
var addedNodesCount = 0;
for (var i = 0; i < mutations.length; i++) {
addedNodesCount += mutations[i].addedNodes.length;
if (addedNodesCount > HUGE_MUTATIONS_COUNT) {
return true;
}
}
return false;
}
function getElementsTreeOperations(mutations) {
var additions = new Set();
var deletions = new Set();
var moves = new Set();
mutations.forEach(function (m) {
forEach(m.addedNodes, function (n) {
if (n instanceof Element && n.isConnected) {
additions.add(n);
}
});
forEach(m.removedNodes, function (n) {
if (n instanceof Element) {
if (n.isConnected) {
moves.add(n);
additions.delete(n);
} else {
deletions.add(n);
}
}
});
});
var duplicateAdditions = [];
var duplicateDeletions = [];
additions.forEach(function (node) {
if (additions.has(node.parentElement)) {
duplicateAdditions.push(node);
}
});
deletions.forEach(function (node) {
if (deletions.has(node.parentElement)) {
duplicateDeletions.push(node);
}
});
duplicateAdditions.forEach(function (node) {
return additions.delete(node);
});
duplicateDeletions.forEach(function (node) {
return deletions.delete(node);
});
return {additions: additions, moves: moves, deletions: deletions};
}
var optimizedTreeObservers = new Map();
var optimizedTreeCallbacks = new WeakMap();
function createOptimizedTreeObserver(root, callbacks) {
var observer;
var observerCallbacks;
var domReadyListener;
if (optimizedTreeObservers.has(root)) {
observer = optimizedTreeObservers.get(root);
observerCallbacks = optimizedTreeCallbacks.get(observer);
} else {
var hadHugeMutationsBefore_1 = false;
var subscribedForReadyState_1 = false;
observer = new MutationObserver(function (mutations) {
if (isHugeMutation(mutations)) {
if (!hadHugeMutationsBefore_1 || isDOMReady()) {
observerCallbacks.forEach(function (_a) {
var onHugeMutations = _a.onHugeMutations;
return onHugeMutations(root);
});
} else if (!subscribedForReadyState_1) {
domReadyListener = function () {
return observerCallbacks.forEach(function (_a) {
var onHugeMutations = _a.onHugeMutations;
return onHugeMutations(root);
});
};
addDOMReadyListener(domReadyListener);
subscribedForReadyState_1 = true;
}
hadHugeMutationsBefore_1 = true;
} else {
var elementsOperations_1 =
getElementsTreeOperations(mutations);
observerCallbacks.forEach(function (_a) {
var onMinorMutations = _a.onMinorMutations;
return onMinorMutations(elementsOperations_1);
});
}
});
observer.observe(root, {childList: true, subtree: true});
optimizedTreeObservers.set(root, observer);
observerCallbacks = new Set();
optimizedTreeCallbacks.set(observer, observerCallbacks);
}
observerCallbacks.add(callbacks);
return {
disconnect: function () {
observerCallbacks.delete(callbacks);
if (domReadyListener) {
removeDOMReadyListener(domReadyListener);
}
if (observerCallbacks.size === 0) {
observer.disconnect();
optimizedTreeCallbacks.delete(observer);
optimizedTreeObservers.delete(root);
}
}
};
}
var anchor;
var parsedURLCache = new Map();
function fixBaseURL($url) {
if (!anchor) {
anchor = document.createElement("a");
}
anchor.href = $url;
return anchor.href;
}
function parseURL($url, $base) {
if ($base === void 0) {
$base = null;
}
var key = "".concat($url).concat($base ? ";".concat($base) : "");
if (parsedURLCache.has(key)) {
return parsedURLCache.get(key);
}
if ($base) {
var parsedURL_1 = new URL($url, fixBaseURL($base));
parsedURLCache.set(key, parsedURL_1);
return parsedURL_1;
}
var parsedURL = new URL(fixBaseURL($url));
parsedURLCache.set($url, parsedURL);
return parsedURL;
}
function getAbsoluteURL($base, $relative) {
if ($relative.match(/^data\\?\:/)) {
return $relative;
}
if (/^\/\//.test($relative)) {
return "".concat(location.protocol).concat($relative);
}
var b = parseURL($base);
var a = parseURL($relative, b.href);
return a.href;
}
function isRelativeHrefOnAbsolutePath(href) {
if (href.startsWith("data:")) {
return true;
}
var url = parseURL(href);
if (url.protocol !== location.protocol) {
return false;
}
if (url.hostname !== location.hostname) {
return false;
}
if (url.port !== location.port) {
return false;
}
return url.pathname === location.pathname;
}
function iterateCSSRules(rules, iterate, onMediaRuleError) {
forEach(rules, function (rule) {
if (rule.selectorText) {
iterate(rule);
} else if (rule.href) {
try {
iterateCSSRules(
rule.styleSheet.cssRules,
iterate,
onMediaRuleError
);
} catch (err) {
logInfo("Found a non-loaded link.");
onMediaRuleError && onMediaRuleError();
}
} else if (rule.media) {
var media = Array.from(rule.media);
var isScreenOrAllOrQuery = media.some(function (m) {
return (
m.startsWith("screen") ||
m.startsWith("all") ||
m.startsWith("(")
);
});
var isPrintOrSpeech = media.some(function (m) {
return m.startsWith("print") || m.startsWith("speech");
});
if (isScreenOrAllOrQuery || !isPrintOrSpeech) {
iterateCSSRules(rule.cssRules, iterate, onMediaRuleError);
}
} else if (rule.conditionText) {
if (CSS.supports(rule.conditionText)) {
iterateCSSRules(rule.cssRules, iterate, onMediaRuleError);
}
} else {
logWarn("CSSRule type not supported", rule);
}
});
}
var shorthandVarDependantProperties = [
"background",
"border",
"border-color",
"border-bottom",
"border-left",
"border-right",
"border-top",
"outline",
"outline-color"
];
var shorthandVarDepPropRegexps = isSafari
? shorthandVarDependantProperties.map(function (prop) {
var regexp = new RegExp("".concat(prop, ":\\s*(.*?)\\s*;"));
return [prop, regexp];
})
: null;
function iterateCSSDeclarations(style, iterate) {
forEach(style, function (property) {
var value = style.getPropertyValue(property).trim();
if (!value) {
return;
}
iterate(property, value);
});
var cssText = style.cssText;
if (cssText.includes("var(")) {
if (isSafari) {
shorthandVarDepPropRegexps.forEach(function (_a) {
var _b = __read(_a, 2),
prop = _b[0],
regexp = _b[1];
var match = cssText.match(regexp);
if (match && match[1]) {
var val = match[1].trim();
iterate(prop, val);
}
});
} else {
shorthandVarDependantProperties.forEach(function (prop) {
var val = style.getPropertyValue(prop);
if (val && val.includes("var(")) {
iterate(prop, val);
}
});
}
}
}
var cssURLRegex = /url\((('.*?')|(".*?")|([^\)]*?))\)/g;
var cssImportRegex =
/@import\s*(url\()?(('.+?')|(".+?")|([^\)]*?))\)? ?(screen)?;?/gi;
function getCSSURLValue(cssURL) {
return cssURL
.trim()
.replace(/[\n\r\\]+/g, "")
.replace(/^url\((.*)\)$/, "$1")
.trim()
.replace(/^"(.*)"$/, "$1")
.replace(/^'(.*)'$/, "$1")
.replace(/(?:\\(.))/g, "$1");
}
function getCSSBaseBath(url) {
var cssURL = parseURL(url);
return ""
.concat(cssURL.origin)
.concat(
cssURL.pathname
.replace(/\?.*$/, "")
.replace(/(\/)([^\/]+)$/i, "$1")
);
}
function replaceCSSRelativeURLsWithAbsolute($css, cssBasePath) {
return $css.replace(cssURLRegex, function (match) {
var pathValue = getCSSURLValue(match);
try {
return "url('".concat(
getAbsoluteURL(cssBasePath, pathValue),
"')"
);
} catch (err) {
return match;
}
});
}
var cssCommentsRegex = /\/\*[\s\S]*?\*\//g;
function removeCSSComments($css) {
return $css.replace(cssCommentsRegex, "");
}
var fontFaceRegex = /@font-face\s*{[^}]*}/g;
function replaceCSSFontFace($css) {
return $css.replace(fontFaceRegex, "");
}
function evalMath(expression) {
var rpnStack = [];
var workingStack = [];
var lastToken;
for (var i = 0, len = expression.length; i < len; i++) {
var token = expression[i];
if (!token || token === " ") {
continue;
}
if (operators.has(token)) {
var op = operators.get(token);
while (workingStack.length) {
var currentOp = operators.get(workingStack[0]);
if (!currentOp) {
break;
}
if (op.lessOrEqualThan(currentOp)) {
rpnStack.push(workingStack.shift());
} else {
break;
}
}
workingStack.unshift(token);
} else if (!lastToken || operators.has(lastToken)) {
rpnStack.push(token);
} else {
rpnStack[rpnStack.length - 1] += token;
}
lastToken = token;
}
rpnStack.push.apply(
rpnStack,
__spreadArray([], __read(workingStack), false)
);
var stack = [];
for (var i = 0, len = rpnStack.length; i < len; i++) {
var op = operators.get(rpnStack[i]);
if (op) {
var args = stack.splice(0, 2);
stack.push(op.exec(args[1], args[0]));
} else {
stack.unshift(parseFloat(rpnStack[i]));
}
}
return stack[0];
}
var Operator = (function () {
function Operator(precedence, method) {
this.precendce = precedence;
this.execMethod = method;
}
Operator.prototype.exec = function (left, right) {
return this.execMethod(left, right);
};
Operator.prototype.lessOrEqualThan = function (op) {
return this.precendce <= op.precendce;
};
return Operator;
})();
var operators = new Map([
[
"+",
new Operator(1, function (left, right) {
return left + right;
})
],
[
"-",
new Operator(1, function (left, right) {
return left - right;
})
],
[
"*",
new Operator(2, function (left, right) {
return left * right;
})
],
[
"/",
new Operator(2, function (left, right) {
return left / right;
})
]
]);
function getMatches(regex, input, group) {
if (group === void 0) {
group = 0;
}
var matches = [];
var m;
while ((m = regex.exec(input))) {
matches.push(m[group]);
}
return m