@moezx/react-darkreader
Version:
A React Hook for adding a dark / night mode to your site inspired by darkreader
1,221 lines (1,172 loc) • 322 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.reactDarkreader = {}, global.React));
}(this, (function (exports, React) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
if (i % 2) {
ownKeys(Object(source), true).forEach(function (key) {
_defineProperty(target, key, source[key]);
});
} else if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
}
return target;
}
function _slicedToArray(arr, i) {
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
function _iterableToArrayLimit(arr, i) {
if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
try {
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function createCommonjsModule(fn, basedir, module) {
return module = {
path: basedir,
exports: {},
require: function (path, base) {
return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
}
}, fn(module, module.exports), module.exports;
}
function commonjsRequire () {
throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
}
var darkreader = createCommonjsModule(function (module, exports) {
/**
* Dark Reader v4.9.43
* https://darkreader.org/
*/
(function (global, factory) {
factory(exports) ;
})(commonjsGlobal, (function (exports) {
/*! *****************************************************************************
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 = {
UI_GET_DATA: 'ui-get-data',
UI_GET_ACTIVE_TAB_INFO: 'ui-get-active-tab-info',
UI_SUBSCRIBE_TO_CHANGES: 'ui-subscribe-to-changes',
UI_UNSUBSCRIBE_FROM_CHANGES: 'ui-unsubscribe-from-changes',
UI_CHANGE_SETTINGS: 'ui-change-settings',
UI_SET_THEME: 'ui-set-theme',
UI_SET_SHORTCUT: 'ui-set-shortcut',
UI_TOGGLE_URL: 'ui-toggle-url',
UI_MARK_NEWS_AS_READ: 'ui-mark-news-as-read',
UI_LOAD_CONFIG: 'ui-load-config',
UI_APPLY_DEV_DYNAMIC_THEME_FIXES: 'ui-apply-dev-dynamic-theme-fixes',
UI_RESET_DEV_DYNAMIC_THEME_FIXES: 'ui-reset-dev-dynamic-theme-fixes',
UI_APPLY_DEV_INVERSION_FIXES: 'ui-apply-dev-inversion-fixes',
UI_RESET_DEV_INVERSION_FIXES: 'ui-reset-dev-inversion-fixes',
UI_APPLY_DEV_STATIC_THEMES: 'ui-apply-dev-static-themes',
UI_RESET_DEV_STATIC_THEMES: 'ui-reset-dev-static-themes',
UI_SAVE_FILE: 'ui-save-file',
UI_REQUEST_EXPORT_CSS: 'ui-request-export-css',
BG_CHANGES: 'bg-changes',
BG_ADD_CSS_FILTER: 'bg-add-css-filter',
BG_ADD_STATIC_THEME: 'bg-add-static-theme',
BG_ADD_SVG_FILTER: 'bg-add-svg-filter',
BG_ADD_DYNAMIC_THEME: 'bg-add-dynamic-theme',
BG_EXPORT_CSS: 'bg-export-css',
BG_UNSUPPORTED_SENDER: 'bg-unsupported-sender',
BG_CLEAN_UP: 'bg-clean-up',
BG_RELOAD: 'bg-reload',
BG_FETCH_RESPONSE: 'bg-fetch-response',
BG_UI_UPDATE: 'bg-ui-update',
BG_CSS_UPDATE: 'bg-css-update',
CS_COLOR_SCHEME_CHANGE: 'cs-color-scheme-change',
CS_FRAME_CONNECT: 'cs-frame-connect',
CS_FRAME_FORGET: 'cs-frame-forget',
CS_FRAME_FREEZE: 'cs-frame-freeze',
CS_FRAME_RESUME: 'cs-frame-resume',
CS_EXPORT_CSS_RESPONSE: 'cs-export-css-response',
CS_FETCH: 'cs-fetch',
};
var userAgent = typeof navigator === 'undefined' ? 'some useragent' : navigator.userAgent.toLowerCase();
var platform = typeof navigator === 'undefined' ? 'some platform' : navigator.platform.toLowerCase();
var isChromium = userAgent.includes('chrome') || userAgent.includes('chromium');
var isThunderbird = userAgent.includes('thunderbird');
var isFirefox = userAgent.includes('firefox') || 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');
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 '';
}))();
var isDefinedSelectorSupported = (function () {
try {
document.querySelector(':defined');
return true;
}
catch (err) {
return false;
}
})();
globalThis.chrome && globalThis.chrome.runtime && globalThis.chrome.runtime.getManifest && globalThis.chrome.runtime.getManifest().manifest_version === 3;
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 " + url);
}
if (!response.ok) {
throw new Error("Unable to load " + url + " " + response.status + " " + 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 ThemeEngines = {
cssFilter: 'cssFilter',
svgFilter: 'svgFilter',
staticTheme: 'staticTheme',
dynamicTheme: 'dynamicTheme',
};
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: ThemeEngines.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: true,
lightColorScheme: 'Default',
darkColorScheme: 'Default',
};
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() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
}
function logWarn() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
}
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) {
logWarn("Node position watcher paused: retry in " + RETRY_TIMEOUT + "ms", node, prevSibling);
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) {
logWarn('Unable to restore node position: sibling parent changed', node, prevSibling, parent);
stop();
return;
}
}
if (mode === 'prev-sibling') {
if (prevSibling.parentNode == null) {
logWarn('Unable to restore node position: sibling was removed', node, prevSibling, parent);
stop();
return;
}
if (prevSibling.parentNode !== parent) {
logWarn('Style was moved to another parent', node, prevSibling, parent);
updateParent(prevSibling.parentNode);
}
}
logWarn('Restoring node position', node, prevSibling, parent);
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()) {
iterator(node);
iterateShadowHosts(node.shadowRoot, iterator);
}
}
function isDOMReady() {
return document.readyState === 'complete' || document.readyState === 'interactive';
}
var readyStateListeners = new Set();
function addDOMReadyListener(listener) {
readyStateListeners.add(listener);
}
function removeDOMReadyListener(listener) {
readyStateListeners.delete(listener);
}
function isReadyStateComplete() {
return document.readyState === 'complete';
}
var readyStateCompleteListeners = new Set();
function addReadyStateCompleteListener(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 = "" + $url + ($base ? ";" + $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 "" + location.protocol + $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(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)?;?/g;
function getCSSURLValue(cssURL) {
return cssURL.replace(/^url\((.*)\)$/, '$1').trim().replace(/^"(.*)"$/, '$1').replace(/^'(.*)'$/, '$1');
}
function getCSSBaseBath(url) {
var cssURL = parseURL(url);
return "" + cssURL.origin + cssURL.pathname.replace(/\?.*$/, '').replace(/(\/)([^\/]+)$/i, '$1');
}
function replaceCSSRelativeURLsWithAbsolute($css, cssBasePath) {
return $css.replace(cssURLRegex, function (match) {
var pathValue = getCSSURLValue(match);
try {
return "url(\"" + getAbsoluteURL(cssBasePath, pathValue) + "\")";
}
catch (err) {
logWarn('Not able to replace relative URL with Absolute URL, skipping');
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 hslToRGB(_a) {
var h = _a.h, s = _a.s, l = _a.l, _b = _a.a, a = _b === void 0 ? 1 : _b;
if (s === 0) {
var _c = __read([l, l, l].map(function (x) { return Math.round(x * 255); }), 3), r_1 = _c[0], b_1 = _c[1], g_1 = _c[2];
return { r: r_1, g: g_1, b: b_1, a: a };
}
var c = (1 - Math.abs(2 * l - 1)) * s;
var x = c * (1 - Math.abs((h / 60) % 2 - 1));
var m = l - c / 2;
var _d = __read((h < 60 ? [c, x, 0] :
h < 120 ? [x, c, 0] :
h < 180 ? [0, c, x] :
h < 240 ? [0, x, c] :
h < 300 ? [x, 0, c] :
[c, 0, x]).map(function (n) { return Math.round((n + m) * 255); }), 3), r = _d[0], g = _d[1], b = _d[2];
return { r: r, g: g, b: b, a: a };
}
function rgbToHSL(_a) {
var r255 = _a.r, g255 = _a.g, b255 = _a.b, _b = _a.a, a = _b === void 0 ? 1 : _b;
var r = r255 / 255;
var g = g255 / 255;
var b = b255 / 255;
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var c = max - min;
var l = (max + min) / 2;
if (c === 0) {
return { h: 0, s: 0, l: l, a: a };
}
var h = (max === r ? (((g - b) / c) % 6) :
max === g ? ((b - r) / c + 2) :
((r - g) / c + 4)) * 60;
if (h < 0) {
h += 360;
}
var s = c / (1 - Math.abs(2 * l - 1));
return { h: h, s: s, l: l, a: a };
}
function toFixed(n, digits) {
if (digits === void 0) { digits = 0; }
var fixed = n.toFixed(digits);
if (digits === 0) {
return fixed;
}
var dot = fixed.indexOf('.');
if (dot >= 0) {
var zerosMatch = fixed.match(/0+$/);
if (zerosMatch) {
if (zerosMatch.index === dot + 1) {
return fixed.substring(0, dot);
}
return fixed.substring(0, zerosMatch.index);
}
}
return fixed;
}
function rgbToString(rgb) {
var r = rgb.r, g = rgb.g, b = rgb.b, a = rgb.a;
if (a != null && a < 1) {
return "rgba(" + toFixed(r) + ", " + toFixed(g) + ", " + toFixed(b) + ", " + toFixed(a, 2) + ")";
}
return "rgb(" + toFixed(r) + ", " + toFixed(g) + ", " + toFixed(b) + ")";
}
function rgbToHexString(_a) {
var r = _a.r, g = _a.g, b = _a.b, a = _a.a;
return "#" + (a != null && a < 1 ? [r, g, b, Math.round(a * 255)] : [r, g, b]).map(function (x) {
return "" + (x < 16 ? '0' : '') + x.toString(16);
}).join('');
}
function hslToString(hsl) {
var h = hsl.h, s = hsl.s, l = hsl.l, a = hsl.a;
if (a != null && a < 1) {
return "hsla(" + toFixed(h) + ", " + toFixed(s * 100) + "%, " + toFixed(l * 100) + "%, " + toFixed(a, 2) + ")";
}
return "hsl(" + toFixed(h) + ", " + toFixed(s * 100) + "%, " + toFixed(l * 100) + "%)";
}
var rgbMatch = /^rgba?\([^\(\)]+\)$/;
var hslMatch = /^hsla?\([^\(\)]+\)$/;
var hexMatch = /^#[0-9a-f]+$/i;
function parse($color) {
var c = $color.trim().toLowerCase();
if (c.match(rgbMatch)) {
return parseRGB(c);
}
if (c.match(hslMatch)) {
return parseHSL(c);
}
if (c.match(hexMatch)) {
return parseHex(c);
}
if (knownColors.has(c)) {
return getColorByName(c);
}
if (systemColors.has(c)) {
return getSystemColor(c);
}
if ($color === 'transparent') {
return { r: 0, g: 0, b: 0, a: 0 };
}
throw new Error("Unable to parse " + $color);
}
function getNumbers($color) {
var numbers = [];
var prevPos = 0;
var isMining = false;
var startIndex = $color.indexOf('(');
$color = $color.substring(startIndex + 1, $color.length - 1);
for (var i = 0; i < $color.length; i++) {
var c = $color[i];
if (c >= '0' && c <= '9' || c === '.' || c === '+' || c === '-') {
isMining = true;
}
else if (isMining && (c === ' ' || c === ',')) {
numbers.push($color.substring(prevPos, i));
isMining = false;
prevPos = i + 1;
}
else if (!isMining) {
prevPos = i + 1;
}
}
if (isMining) {
numbers.push($color.substring(prevPos, $color.length));
}
return numbers;
}
function getNumbersFromString(str, range, units) {
var raw = getNumbers(str);
var unitsList = Object.entries(units);
var numbers = raw.map(function (r) { return r.trim(); }).map(function (r, i) {
var n;
var unit = unitsList.find(function (_a) {
var _b = __read(_a, 1), u = _b[0];
return r.endsWith(u);
});
if (unit) {
n = parseFloat(r.substring(0, r.length - unit[0].length)) / unit[1] * range[i];
}
else {
n = parseFloat(r);
}
if (range[i] > 1) {
return Math.round(n);
}
return n;
});
return numbers;
}
var rgbRange = [255, 255, 255, 1];
var rgbUnits = { '%': 100 };
function parseRGB($rgb) {
var _a = __read(getNumbersFromString($rgb, rgbRange, rgbUnits), 4), r = _a[0], g = _a[1], b = _a[2], _b = _a[3], a = _b === void 0 ? 1 : _b;