tsreact-darkreader
Version:
A Custom React Hook for adding a dark / night mode to your site inspired by darkreader
1,253 lines (1,202 loc) • 440 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react/jsx-runtime')) :
typeof define === 'function' && define.amd ? define(['exports', 'react', 'react/jsx-runtime'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.tsreactDarkreader = {}, global.React, global._jsxRuntime));
}(this, (function (exports, React, _jsxRuntime) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () {
return e[k];
}
});
}
});
}
n['default'] = e;
return Object.freeze(n);
}
var React__namespace = /*#__PURE__*/_interopNamespace(React);
var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
var _jsxRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_jsxRuntime);
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 getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
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 getAugmentedNamespace(n) {
if (n.__esModule) return n;
var a = Object.defineProperty({}, '__esModule', {value: true});
Object.keys(n).forEach(function (k) {
var d = Object.getOwnPropertyDescriptor(n, k);
Object.defineProperty(a, k, d.get ? d : {
enumerable: true,
get: function () {
return n[k];
}
});
});
return a;
}
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.27
* 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 __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
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;
var isVivaldi = userAgent.includes('vivaldi');
var isYaBrowser = userAgent.includes('yabrowser');
var isOpera = userAgent.includes('opr') || userAgent.includes('opera');
var isEdge = userAgent.includes('edg');
var isSafari = userAgent.includes('safari') && !isChromium;
var isWindows = platform.startsWith('win');
var isMacOS = platform.startsWith('mac');
var isMobile = userAgent.includes('mobile');
var isShadowDomSupported = typeof ShadowRoot === 'function';
var isMatchMediaChangeEventListenerSupported = (typeof MediaQueryList === 'function' &&
typeof MediaQueryList.prototype.addEventListener === 'function');
var chromiumVersion = (function () {
var m = userAgent.match(/chrom[e|ium]\/([^ ]+)/);
if (m && m[1]) {
return m[1];
}
else {
return '';
}
})();
var isDefinedSelectorSupported = (function () {
try {
document.querySelector(':defined');
return true;
}
catch (err) {
return false;
}
})();
var isCSSStyleSheetConstructorSupported = (function () {
try {
new CSSStyleSheet();
return true;
}
catch (err) {
return false;
}
})();
function getOKResponse(url, mimeType) {
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',
})];
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(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, err_1;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (!(args[0] && args[0].type === '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: 'fetch-response', data: text_1, error: null, id: id_1 }); });
return [3, 8];
case 7:
err_1 = _b.sent();
console.error(err_1);
messageListeners.forEach(function (cb) { return cb({ type: 'fetch-response', data: null, err: err_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, __spread(args));
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.apply(void 0, __spread(args));
nativeAddListener_1.apply(chrome.runtime.onMessage, args);
};
}
else {
chrome.runtime.onMessage.addListener = addMessageListener;
}
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,
};
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;
}
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;
}
var b = parseURL($base);
var a = parseURL($relative, b.href);
return a.href;
}
function getURLHostOrProtocol($url) {
var url = new URL($url);
if (url.host) {
return url.host;
}
else {
return url.protocol;
}
}
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 iterateCSSRules(rules, iterate) {
forEach(rules, function (rule) {
if (rule instanceof CSSMediaRule) {
var media = Array.from(rule.media);
if (media.includes('screen') || media.includes('all') || !(media.includes('print') || media.includes('speech'))) {
iterateCSSRules(rule.cssRules, iterate);
}
}
else if (rule instanceof CSSStyleRule) {
iterate(rule);
}
else if (rule instanceof CSSImportRule) {
try {
iterateCSSRules(rule.styleSheet.cssRules, iterate);
}
catch (err) {
logWarn(err);
}
}
else if (rule instanceof CSSSupportsRule) {
if (CSS.supports(rule.conditionText)) {
iterateCSSRules(rule.cssRules, iterate);
}
}
else {
logWarn("CSSRule type not supported", rule);
}
});
}
function iterateCSSDeclarations(style, iterate) {
forEach(style, function (property) {
var value = style.getPropertyValue(property).trim();
if (!value) {
return;
}
iterate(property, value);
});
}
function isCSSVariable(property) {
return property.startsWith('--') && !property.startsWith('--darkreader');
}
function getCSSVariables(rules) {
var variables = new Map();
rules && iterateCSSRules(rules, function (rule) {
rule.style && iterateCSSDeclarations(rule.style, function (property, value) {
if (isCSSVariable(property)) {
variables.set(property, value);
}
});
});
return variables;
}
function getElementCSSVariables(element) {
var variables = new Map();
iterateCSSDeclarations(element.style, function (property, value) {
if (isCSSVariable(property)) {
variables.set(property, value);
}
});
return variables;
}
var cssURLRegex = /url\((('.+?')|(".+?")|([^\)]*?))\)/g;
var cssImportRegex = /@import\s*(url\()?(('.+?')|(".+?")|([^\)]*?))\)?;?/g;
function getCSSURLValue(cssURL) {
return cssURL.replace(/^url\((.*)\)$/, '$1').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);
return "url(\"" + getAbsoluteURL(cssBasePath, pathValue) + "\")";
});
}
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, '');
}
var varRegex = /var\((--[^\s,\(\)]+),?\s*([^\(\)]*(\([^\(\)]*\)[^\(\)]*)*\s*)\)/g;
function replaceCSSVariables(value, variables, stack) {
if (stack === void 0) { stack = new Set(); }
var missing = false;
var unresolvable = new Set();
var result = value.replace(varRegex, function (match, name, fallback) {
if (stack.has(name)) {
logWarn("Circular reference to variable " + name);
if (fallback) {
return fallback;
}
missing = true;
return match;
}
if (variables.has(name)) {
var value_1 = variables.get(name);
if (value_1.match(varRegex)) {
unresolvable.add(name);
}
return value_1;
}
else if (fallback) {
return fallback;
}
else {
logWarn("Variable " + name + " not found");
missing = true;
}
return match;
});
if (missing) {
return result;
}
if (result.match(varRegex)) {
unresolvable.forEach(function (v) { return stack.add(v); });
return replaceCSSVariables(result, variables, stack);
}
return result;
}
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, __spread(lastArgs));
frameId = requestAnimationFrame(function () {
frameId = null;
if (pending) {
callback.apply(void 0, __spread(lastArgs));
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);
}
if (!isDOMReady()) {
var onReadyStateChange_1 = function () {
if (isDOMReady()) {
document.removeEventListener('readystatechange', onReadyStateChange_1);
readyStateListeners.forEach(function (listener) { return listener(); });
readyStateListeners.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);
}
else {
deletions.add(n);
}
}
});
});
moves.forEach(function (n) { return additions.delete(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 tempStyle = null;
function getTempCSSStyleSheet() {
if (tempStyle) {
return tempStyle;
}
if (isCSSStyleSheetConstructorSupported) {
tempStyle = new CSSStyleSheet();
return tempStyle;
}
else {
var tempStyleElement = document.createElement('style');
document.head.append(tempStyleElement);
tempStyle = tempStyleElement.sheet;
document.head.removeChild(tempStyleElement);
return tempStyle;
}
}
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 getNumbersFromString(str, splitter, range, units) {
var raw = str.split(splitter).filter(function (x) { return x; });
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 rgbSplitter = /rgba?|\(|\)|\/|,|\s/ig;
var rgbRange = [255, 255, 255, 1];
var rgbUnits = { '%': 100 };
function parseRGB($rgb) {
var _a = __read(getNumbersFromString($rgb, rgbSplitter, rgbRange, rgbUnits), 4), r = _a[0], g = _a[1], b = _a[2], _b = _a[3], a = _b === void 0 ? 1 : _b;
return { r: r, g: g, b: b, a: a };
}
var hslSplitter = /hsla?|\(|\)|\/|,|\s/ig;
var hslRange = [360, 1, 1, 1];
var hslUnits = { '%': 100, 'deg': 360, 'rad': 2 * Math.PI, 'turn': 1 };
function parseHSL($hsl) {
var _a = __read(getNumbersFromString($hsl, hslSplitter, hslRange, hslUnits), 4), h = _a[0], s = _a[1], l = _a[2], _b = _a[3], a = _b === void 0 ? 1 : _b;
return hslToRGB({ h: h, s: s, l: l, a: a });
}
function parseHex($hex) {
var h = $hex.substring(1);
switch (h.length) {
case 3:
case 4: {
var _a = __read([0, 1, 2].map(function (i) { return parseInt("" + h[i] + h[i], 16); }), 3), r = _a[0], g = _a[1], b = _a[2];
var a = h.length === 3 ? 1 : (parseInt("" + h[3] + h[3], 16) / 255);
return { r: r, g: g, b: b, a: a };
}
case 6:
case 8: {
var _b = __read([0, 2, 4].map(function (i) { return parseInt(h.substring(i, i + 2), 16); }), 3), r = _b[0], g = _b[1], b = _b[2];
var a = h.length === 6 ? 1 : (parseInt(h.substring(6, 8), 16) / 255);
return { r: r, g: g, b: b, a: a };
}
}
throw new Error("Unable to parse " + $hex);
}
function getColorByName($color) {
var n = knownColors.get($color);
return {
r: (n >> 16) & 255,
g: (n >> 8) & 255,
b: (n >> 0) & 255,
a: 1
};
}
function getSystemColor($color) {
var n = systemColors.get($color);
return {
r: (n >> 16) & 255,
g: (n >> 8) & 255,
b: (n >> 0) & 255,
a: 1
};
}
var knownColors =