native-fn 1.0.26 → 1.0.28

package/dist/plugin/theme/index.cjs

@@ -0,0 +1,810 @@
+'use strict';
+
+var USER_AGENT = navigator.userAgent;
+
+var Appearances;
+(function (Appearances) {
+    Appearances["Unknown"] = "unknown";
+    Appearances["Light"] = "light";
+    Appearances["Dark"] = "dark";
+})(Appearances || (Appearances = {}));
+var CHROME_VERSION = (function getChromeVersion() {
+    var matched = USER_AGENT.match(/chrome\/([\w.]+) mobile/i);
+    if (matched === null)
+        return NaN;
+    var version = parseInt(matched[1]);
+    if (isNaN(version))
+        return NaN;
+    return version;
+})();
+var MEDIA_QUERY_LIST = window.matchMedia('(prefers-color-scheme: dark)');
+var SUPPORT_PREFERS_COLOR_SCHEME = MEDIA_QUERY_LIST.media !== 'not all';
+var IS_FULL_SUPPORT_THEME_COLOR = isNaN(CHROME_VERSION) || CHROME_VERSION >= 92;
+var CONTEXT = document.createElement('canvas').getContext('2d', { willReadFrequently: true });
+var SVG_PIXEL_DATA_URL = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMSIgaGVpZ2h0PSIxIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxyZWN0IHdpZHRoPSIxIiBoZWlnaHQ9IjEiIGZpbGw9IndoaXRlIi8+PC9zdmc+';
+var IS_SAMSUNG = /Samsung/i.test(USER_AGENT);
+var IS_IE_MOBILE = /iemobile/i.test(USER_AGENT);
+var IS_WINDOWS_PHONE = /windows phone/i.test(USER_AGENT);
+var ENTRIES = [];
+
+/******************************************************************************
+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.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+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.");
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function createCustomError(name, Base) {
+    if (Base === void 0) { Base = Error; }
+    function CustomError(message) {
+        if (!(this instanceof CustomError))
+            return new CustomError(message);
+        var error = new Base(message || '');
+        if (typeof Object.setPrototypeOf === 'function')
+            Object.setPrototypeOf(error, CustomError.prototype);
+        else
+            error.__proto__ = CustomError.prototype;
+        error.name = name;
+        if (message !== undefined)
+            error.message = message;
+        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+            try {
+                Object.defineProperty(error, Symbol.toStringTag, {
+                    value: name,
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            catch (_) {
+            }
+        }
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(error, CustomError);
+        }
+        else if (Base.captureStackTrace && typeof Base.captureStackTrace === 'function') {
+            Base.captureStackTrace(error, CustomError);
+        }
+        else {
+            try {
+                var tempError = new Base();
+                if (tempError.stack)
+                    error.stack = tempError.stack;
+            }
+            catch (_) {
+            }
+        }
+        return error;
+    }
+    CustomError.prototype = Object.create(Base.prototype, {
+        constructor: {
+            value: CustomError,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        }
+    });
+    try {
+        Object.defineProperty(CustomError.prototype, 'name', {
+            value: name,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+        try {
+            CustomError.prototype.name = name;
+        }
+        catch (_) {
+        }
+    }
+    try {
+        Object.defineProperty(CustomError, 'name', {
+            value: name,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+    }
+    return CustomError;
+}
+
+var EasingError = createCustomError('EasingError');
+var CubicBezierSyntaxError = createCustomError('CubicBezierSyntaxError', EasingError);
+var LinearSyntaxError = createCustomError('LinearSyntaxError', EasingError);
+var StepSyntaxError = createCustomError('StepSyntaxError', EasingError);
+var UnsupportedEasingFunctionError = createCustomError('UnsupportedEasingFunctionError', EasingError);
+
+var EASING_KEYWORD = {
+    'linear': 'linear(0, 1)',
+    'ease': 'cubic-bezier(0.25, 0.1, 0.25, 1)',
+    'ease-in': 'cubic-bezier(0.42, 0, 1, 1)',
+    'ease-out': 'cubic-bezier(0, 0, 0.58, 1)',
+    'ease-in-out': 'cubic-bezier(0.42, 0, 0.58, 1)',
+    'step-start': 'steps(1, jump-start)',
+    'step-end': 'steps(1, jump-end)',
+};
+function clamp(n, min, max) {
+    if (n < min)
+        return min;
+    if (n > max)
+        return max;
+    return n;
+}
+function isEasingKeyword(easingFunction) {
+    return !/(linear|cubic-bezier|steps)\((.*)\)/.test(easingFunction);
+}
+function isCubicBezierString(easingFunction) {
+    return /cubic-bezier\(/.test(easingFunction);
+}
+function isLinearString(easingFunction) {
+    return /linear\(/.test(easingFunction);
+}
+function isStepString(easingFunction) {
+    return /steps\(\s*(\d+)\s*(?:,\s*(jump-start|jump-end|jump-none|jump-both|start|end)\s*)?\)$/.test(easingFunction);
+}
+function parseCubicBezier(easingFunction) {
+    var match = easingFunction.match(/cubic-bezier\((.*)\)/);
+    if (match === null)
+        throw new CubicBezierSyntaxError('Invalid cubic-bezier syntax');
+    var content = match[1].trim();
+    var split = content.split(',');
+    var values = [];
+    if (split.length !== 4)
+        throw new CubicBezierSyntaxError('Cubic-bezier must have exactly 4 numeric values');
+    for (var i = 0; i < 4; i++) {
+        var value = parseFloat(split[i]);
+        if (isNaN(value))
+            throw new CubicBezierSyntaxError('Cubic-bezier must have exactly 4 numeric values');
+        if (i % 2 === 0 && (value < 0 || value > 1))
+            throw new CubicBezierSyntaxError('x1 and x2 must be between 0 and 1');
+        values.push(value);
+    }
+    return {
+        x1: values[0],
+        y1: values[1],
+        x2: values[2],
+        y2: values[3]
+    };
+}
+function getCubicBezierValue(easingFunction) {
+    var cubicBezier = parseCubicBezier(easingFunction);
+    var x1 = cubicBezier.x1;
+    var x2 = cubicBezier.x2;
+    var y1 = cubicBezier.y1;
+    var y2 = cubicBezier.y2;
+    function findT(x, tolerance, maxIterations) {
+        if (tolerance === void 0) { tolerance = 1e-6; }
+        if (maxIterations === void 0) { maxIterations = 50; }
+        if (x <= 0)
+            return 0;
+        if (x >= 1)
+            return 1;
+        var t = x;
+        for (var i = 0; i < maxIterations; i++) {
+            var xt = 3 * (1 - t) * (1 - t) * t * x1 + 3 * (1 - t) * t * t * x2 + t * t * t;
+            var dx = 3 * (1 - t) * (1 - t) * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+            if (Math.abs(dx) < tolerance)
+                break;
+            var newT = t - (xt - x) / dx;
+            if (Math.abs(newT - t) < tolerance) {
+                t = newT;
+                break;
+            }
+            t = Math.max(0, Math.min(1, newT));
+        }
+        return t;
+    }
+    return function (x) {
+        x = clamp(x, 0, 1);
+        if (x === 0 || x === 1)
+            return x;
+        var t = findT(x);
+        return 3 * (1 - t) * (1 - t) * t * y1 + 3 * (1 - t) * t * t * y2 + t * t * t;
+    };
+}
+function parseLinear(easingFunction) {
+    var e_1, _a;
+    var match = easingFunction.match(/linear\((.*)\)/);
+    if (match === null)
+        throw new LinearSyntaxError('Invalid linear syntax');
+    var content = match[1].trim();
+    if (content === '')
+        throw new LinearSyntaxError('Linear function must have at least one point');
+    var split = content.split(',');
+    var points = [];
+    for (var i = 0; i < split.length; i++) {
+        var part = split[i].trim();
+        var percentage2 = part.match(/^([+-]?\d*\.?\d+)((?:\s+[+-]?\d*\.?\d+%){2,})$/);
+        if (percentage2 !== null) {
+            var value = parseFloat(percentage2[1]);
+            var percents = percentage2[2].trim().split(/\s+/);
+            try {
+                for (var percents_1 = (e_1 = void 0, __values(percents)), percents_1_1 = percents_1.next(); !percents_1_1.done; percents_1_1 = percents_1.next()) {
+                    var percent = percents_1_1.value;
+                    points.push({
+                        value: value,
+                        position: parseFloat(percent) / 100,
+                    });
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (percents_1_1 && !percents_1_1.done && (_a = percents_1.return)) _a.call(percents_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            continue;
+        }
+        var percentage1 = part.match(/^([+-]?\d*\.?\d+)\s+([+-]?\d*\.?\d+)%$/);
+        if (percentage1 !== null) {
+            points.push({
+                position: parseFloat(percentage1[2]) / 100,
+                value: parseFloat(percentage1[1])
+            });
+            continue;
+        }
+        var number = part.match(/^([+-]?\d*\.?\d+)$/);
+        if (number !== null) {
+            points.push({
+                position: split.length === 1 ? 0 : i / (split.length - 1),
+                value: parseFloat(number[1])
+            });
+            continue;
+        }
+        throw new LinearSyntaxError('Invalid linear point format: \"' + part + '\"');
+    }
+    if (points.length === 0)
+        throw new LinearSyntaxError('No valid points found in linear function');
+    points.sort(function (a, b) { return a.position - b.position; });
+    if (points[0].position > 0)
+        points.unshift({ position: 0, value: 0 });
+    if (points[points.length - 1].position < 1)
+        points.push({ position: 1, value: 1 });
+    return points;
+}
+function getLinearValue(str) {
+    var points = parseLinear(str);
+    return function (t) {
+        t = clamp(t, 0, 1);
+        if (t <= points[0].position)
+            return points[0].value;
+        if (t >= points[points.length - 1].position)
+            return points[points.length - 1].value;
+        for (var i = 0; i < points.length - 1; i++) {
+            var p1 = points[i];
+            var p2 = points[i + 1];
+            if (t >= p1.position && t <= p2.position) {
+                if (p1.position === p2.position)
+                    return p2.value;
+                var ratio = (t - p1.position) / (p2.position - p1.position);
+                return p1.value + (p2.value - p1.value) * ratio;
+            }
+        }
+        return points[points.length - 1].value;
+    };
+}
+function getStepValue(easingFunction) {
+    var match = easingFunction.match(/steps\(\s*(\d+)\s*(?:,\s*(jump-start|jump-end|jump-none|jump-both|start|end)\s*)?\)$/);
+    if (match === null)
+        throw new StepSyntaxError('Invalid steps syntax');
+    var count = parseInt(match[1], 10);
+    var position = match[2];
+    if (count <= 0)
+        throw new StepSyntaxError('Steps count must be a positive integer');
+    if (position === 'jump-none' && count < 2)
+        throw new StepSyntaxError('jump-none requires at least 2 steps');
+    return function (t) {
+        t = clamp(t, 0, 1);
+        switch (position) {
+            case 'start':
+            case 'jump-start':
+                if (t === 0)
+                    return 1 / count;
+                if (t === 1)
+                    return 1;
+                return Math.ceil(t * count) / count;
+            case undefined:
+            case 'end':
+            case 'jump-end':
+                if (t === 1)
+                    return 1;
+                return Math.floor(t * count) / count;
+            case 'jump-both':
+                if (t === 0)
+                    return 0;
+                if (t === 1)
+                    return 1;
+                return Math.round(t * (count + 1)) / (count + 1);
+            case 'jump-none':
+                if (t === 0)
+                    return 0;
+                if (t === 1)
+                    return 1;
+                return Math.floor(t * (count - 1)) / (count - 1);
+            default:
+                throw new StepSyntaxError('Unsupported step position: \"' + position + '\"');
+        }
+    };
+}
+function parseEasingFunction(easingFunction) {
+    if (isEasingKeyword(easingFunction))
+        easingFunction = EASING_KEYWORD[easingFunction];
+    if (isCubicBezierString(easingFunction))
+        return getCubicBezierValue(easingFunction);
+    if (isLinearString(easingFunction))
+        return getLinearValue(easingFunction);
+    if (isStepString(easingFunction))
+        return getStepValue(easingFunction);
+    throw new UnsupportedEasingFunctionError('Unsupported easing function: \"' + easingFunction + '\"');
+}
+
+var UnsupportedColorError = createCustomError('UnsupportedColorError');
+
+function parseColor(color) {
+    if (typeof CSS !== 'undefined' && CSS.supports && !CSS.supports('color', color))
+        throw new UnsupportedColorError('Unsupported color: \"' + color + '\".');
+    if (CONTEXT !== null) {
+        try {
+            CONTEXT.clearRect(0, 0, 1, 1);
+            CONTEXT.fillStyle = color;
+            CONTEXT.fillRect(0, 0, 1, 1);
+            var data = CONTEXT.getImageData(0, 0, 1, 1).data;
+            return {
+                red: data[0],
+                green: data[1],
+                blue: data[2],
+                alpha: parseFloat((data[3] / 255).toFixed(2))
+            };
+        }
+        catch (_) {
+        }
+    }
+    var div = document.createElement('div');
+    div.style.position = 'absolute';
+    div.style.top = '-9999px';
+    div.style.left = '-9999px';
+    div.style.width = '1px';
+    div.style.height = '1px';
+    div.style.color = color;
+    document.body.appendChild(div);
+    try {
+        var computedColor = window.getComputedStyle(div).color;
+        var legacyMatch = computedColor.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)/);
+        var modernMatch = computedColor.match(/rgba?\(\s*(\d+)\s+(\d+)\s+(\d+)\s*(?:\/\s*([\d.]+%?))?\s*\)/);
+        var matched = legacyMatch || modernMatch;
+        if (matched === null)
+            throw new UnsupportedColorError('Unsupported color: \"' + color + '\".');
+        var red = parseInt(matched[1], 10);
+        var green = parseInt(matched[2], 10);
+        var blue = parseInt(matched[3], 10);
+        var alpha = 1;
+        if (matched[4] !== undefined) {
+            var alphaStr = matched[4];
+            if (alphaStr.charAt(alphaStr.length - 1) === '%')
+                alpha = parseFloat((parseFloat(alphaStr) / 100).toFixed(2));
+            else
+                alpha = parseFloat(parseFloat(alphaStr).toFixed(2));
+        }
+        if (isNaN(red) || isNaN(green) || isNaN(blue) || isNaN(alpha))
+            throw new UnsupportedColorError('Failed to parse color values from: \"' + color + '\".');
+        return {
+            red: red,
+            green: green,
+            blue: blue,
+            alpha: alpha
+        };
+    }
+    finally {
+        document.body.removeChild(div);
+    }
+}
+
+var themeColorMetaGroup = {};
+var themeIntervalId = null;
+var currentResolve = null;
+var currentAppearance = null;
+var appearanceIntervalId = null;
+var Theme = {
+    setThemeColor: setThemeColor,
+    getThemeColor: getThemeColor,
+    removeThemeColor: removeThemeColor,
+    detectAppearance: detectAppearance,
+    onAppearanceChange: onAppearanceChange,
+};
+function getThemeColorMeta(appearance) {
+    if (appearance === void 0) { appearance = 'default'; }
+    var effective;
+    if (!IS_FULL_SUPPORT_THEME_COLOR || !SUPPORT_PREFERS_COLOR_SCHEME || IS_IE_MOBILE || IS_WINDOWS_PHONE)
+        effective = 'default';
+    else
+        effective = appearance;
+    var meta = themeColorMetaGroup[effective];
+    if (meta !== undefined)
+        return meta;
+    meta = document.createElement('meta');
+    if (IS_IE_MOBILE)
+        meta.setAttribute('name', 'msapplication-navbutton-color');
+    else if (IS_WINDOWS_PHONE)
+        meta.setAttribute('name', 'msapplication-TileColor');
+    else
+        meta.setAttribute('name', 'theme-color');
+    if (appearance !== 'default')
+        meta.setAttribute('media', '(prefers-color-scheme: ' + effective + ')');
+    document.head.prepend(meta);
+    return themeColorMetaGroup[appearance] = meta;
+}
+function estimateDefaultThemeColor() {
+    if (/version\/[\w.,]+ .*safari/i.test(USER_AGENT)) {
+        if (navigator.standalone) {
+            if (detectFromMediaQuery() === Appearances.Dark)
+                return '#ffffffff';
+            else
+                return '#000000ff';
+        }
+        return rgbaToHex(parseColor(window.getComputedStyle(document.body).backgroundColor));
+    }
+    if (/\b(?:crmo|crios)\/[\w.]+/i.test(USER_AGENT) || /chrome\/[\w.]+ mobile/i.test(USER_AGENT)) {
+        if (detectFromMediaQuery() === Appearances.Dark)
+            return '#28292cff';
+        else
+            return '#ffffffff';
+    }
+    return undefined;
+}
+function toHex(n) {
+    var hex = n.toString(16);
+    switch (hex.length) {
+        case 0: return '00';
+        case 1: return '0' + hex;
+        default: return hex;
+    }
+}
+function rgbaToHex(rgba) {
+    return '#'
+        + toHex(rgba.red)
+        + toHex(rgba.green)
+        + toHex(rgba.blue)
+        + toHex(Math.round(rgba.alpha * 255));
+}
+function detectFromEngine() {
+    return new Promise(function (resolve) {
+        var img = new Image();
+        img.onload = function () {
+            if (CONTEXT === null)
+                return resolve(Appearances.Light);
+            CONTEXT.drawImage(img, 0, 0);
+            var data = CONTEXT.getImageData(0, 0, 1, 1).data;
+            if ((data[0] & data[1] & data[2]) < 255)
+                resolve(Appearances.Dark);
+            else
+                resolve(Appearances.Light);
+        };
+        img.onerror = function () {
+            resolve(Appearances.Unknown);
+        };
+        img.src = SVG_PIXEL_DATA_URL;
+    });
+}
+function detectFromMediaQuery() {
+    if (!SUPPORT_PREFERS_COLOR_SCHEME)
+        return Appearances.Unknown;
+    if (MEDIA_QUERY_LIST.matches)
+        return Appearances.Dark;
+    return Appearances.Light;
+}
+function startPolling() {
+    detectFromEngine()
+        .then(function (appearance) {
+        currentAppearance = appearance;
+    });
+    appearanceIntervalId = window.setInterval(function () {
+        detectFromEngine()
+            .then(function (appearance) {
+            if (appearance !== currentAppearance) {
+                currentAppearance = appearance;
+                notify(appearance);
+            }
+        });
+    }, 2000);
+}
+function stopPolling() {
+    currentAppearance = null;
+    if (appearanceIntervalId !== null) {
+        clearInterval(appearanceIntervalId);
+        appearanceIntervalId = null;
+    }
+}
+function addListener(capture) {
+    currentAppearance = detectFromMediaQuery();
+    if (typeof MEDIA_QUERY_LIST.addEventListener === 'function')
+        MEDIA_QUERY_LIST.addEventListener('change', onMediaChange, capture);
+    else if (typeof MEDIA_QUERY_LIST.addListener === 'function')
+        MEDIA_QUERY_LIST.addListener(onMediaChange);
+}
+function removeListener(capture) {
+    currentAppearance = null;
+    if (typeof MEDIA_QUERY_LIST.removeEventListener === 'function')
+        MEDIA_QUERY_LIST.removeEventListener('change', onMediaChange, capture);
+    else if (typeof MEDIA_QUERY_LIST.removeListener === 'function')
+        MEDIA_QUERY_LIST.removeListener(onMediaChange);
+}
+function onMediaChange(ev) {
+    var appearance;
+    if (ev.matches)
+        appearance = Appearances.Dark;
+    else
+        appearance = Appearances.Light;
+    if (appearance !== currentAppearance)
+        notify(currentAppearance = appearance);
+}
+function notify(appearance) {
+    for (var i = 0; i < ENTRIES.length; i++) {
+        var entry = ENTRIES[i];
+        entry.fn(appearance);
+        if (entry.once)
+            removeEntry(entry);
+    }
+}
+function removeEntry(entry) {
+    var index = indexOfEntry(entry);
+    if (index !== -1)
+        ENTRIES.splice(index, 1);
+    if (ENTRIES.length === 0) {
+        if (IS_SAMSUNG)
+            stopPolling();
+        else
+            removeListener(entry.capture);
+    }
+}
+function indexOfEntry(entry) {
+    for (var i = 0; i < ENTRIES.length; i++)
+        if (ENTRIES[i].fn === entry.fn && ENTRIES[i].capture === entry.capture)
+            return i;
+    return -1;
+}
+function syncThemeColorMeta() {
+    themeColorMetaGroup = {};
+    var selector;
+    if (IS_IE_MOBILE)
+        selector = 'meta[name=\"msapplication-navbutton-color\"]';
+    else if (IS_WINDOWS_PHONE)
+        selector = 'meta[name=\"msapplication-TileColor\"]';
+    else
+        selector = 'meta[name=\"theme-color\"]';
+    var nodes = document.querySelectorAll(selector);
+    if (!IS_FULL_SUPPORT_THEME_COLOR || !SUPPORT_PREFERS_COLOR_SCHEME || IS_IE_MOBILE || IS_WINDOWS_PHONE) {
+        themeColorMetaGroup.default = nodes[0];
+        return;
+    }
+    for (var i = 0; i < nodes.length; i++) {
+        var element = nodes.item(i);
+        var media = element.getAttribute('media');
+        if (media === '(prefers-color-scheme: dark)' && themeColorMetaGroup.dark === undefined)
+            themeColorMetaGroup.dark = element;
+        else if (media === '(prefers-color-scheme: light)' && themeColorMetaGroup.light === undefined)
+            themeColorMetaGroup.light = element;
+        else if (media === null && themeColorMetaGroup.default === undefined)
+            themeColorMetaGroup.default = element;
+        if (themeColorMetaGroup.dark !== undefined && themeColorMetaGroup.light !== undefined && themeColorMetaGroup.default !== undefined)
+            return;
+    }
+}
+function getCurrentAppliedThemeColorMeta() {
+    if (IS_IE_MOBILE)
+        return document.querySelector('meta[name=\"msapplication-navbutton-color\"]');
+    if (IS_WINDOWS_PHONE)
+        return document.querySelector('meta[name=\"msapplication-TileColor\"]');
+    if (!IS_FULL_SUPPORT_THEME_COLOR || !SUPPORT_PREFERS_COLOR_SCHEME)
+        return document.querySelector('meta[name=\"theme-color\"]');
+    var nodes = document.querySelectorAll('meta[name=\"theme-color\"]');
+    var isDark = detectFromMediaQuery() === Appearances.Dark;
+    var query;
+    if (isDark)
+        query = '(prefers-color-scheme: dark)';
+    else
+        query = '(prefers-color-scheme: light)';
+    for (var i = 0; i < nodes.length; i++) {
+        var element = nodes.item(i);
+        if (!element.hasAttribute('content'))
+            continue;
+        var media = element.getAttribute('media');
+        if (media === null || media === query)
+            return element;
+    }
+    return null;
+}
+function init() {
+    var observer = new MutationObserver(function (mutations) {
+        for (var i = 0; i < mutations.length; i++) {
+            var mutation = mutations[i];
+            var addedNodes = mutation.addedNodes;
+            var removedNodes = mutation.removedNodes;
+            for (var j = 0; j < addedNodes.length; j++)
+                if (addedNodes[j] instanceof HTMLMetaElement)
+                    return syncThemeColorMeta();
+            for (var j = 0; j < removedNodes.length; j++)
+                if (removedNodes[j] instanceof HTMLMetaElement)
+                    return syncThemeColorMeta();
+        }
+    });
+    if (typeof MEDIA_QUERY_LIST.addEventListener === 'function')
+        MEDIA_QUERY_LIST.addEventListener('change', syncThemeColorMeta);
+    else if (typeof MEDIA_QUERY_LIST.addListener === 'function')
+        MEDIA_QUERY_LIST.addListener(syncThemeColorMeta);
+    observer.observe(document.head, { childList: true });
+    syncThemeColorMeta();
+}
+init();
+function setThemeColor(color, options) {
+    if (options === void 0) { options = { duration: 0, easingFunction: 'linear', appearance: 'default' }; }
+    var duration = options.duration;
+    var easingFn = parseEasingFunction(options.easingFunction);
+    var appearance = options.appearance;
+    if (themeIntervalId !== null) {
+        window.cancelAnimationFrame(themeIntervalId);
+        themeIntervalId = null;
+        if (currentResolve !== null) {
+            currentResolve(getThemeColor());
+            currentResolve = null;
+        }
+    }
+    var themeColor = getThemeColor();
+    if (themeColor === undefined) {
+        if (options.defaultColor !== undefined) {
+            themeColor = options.defaultColor;
+        }
+        else {
+            if (detectFromMediaQuery() === Appearances.Dark)
+                themeColor = '#181818ff';
+            else
+                themeColor = '#dcdcdcff';
+        }
+    }
+    var startColor = parseColor(themeColor);
+    var endColor = parseColor(color);
+    return new Promise(function (resolve) {
+        currentResolve = resolve;
+        var startTime = null;
+        function animate(timestamp) {
+            if (startTime === null)
+                startTime = timestamp;
+            var elapsed = timestamp - startTime;
+            var t;
+            if (duration === 0)
+                t = 1;
+            else
+                t = Math.min(elapsed / duration, 1);
+            var easedT = easingFn(t);
+            var current = {
+                red: Math.round(startColor.red + (endColor.red - startColor.red) * easedT),
+                green: Math.round(startColor.green + (endColor.green - startColor.green) * easedT),
+                blue: Math.round(startColor.blue + (endColor.blue - startColor.blue) * easedT),
+                alpha: +(startColor.alpha + (endColor.alpha - startColor.alpha) * easedT).toFixed(2),
+            };
+            getThemeColorMeta(appearance).setAttribute('content', rgbaToHex(current));
+            if (t < 1) {
+                themeIntervalId = window.requestAnimationFrame(animate);
+            }
+            else {
+                themeIntervalId = null;
+                if (currentResolve !== null) {
+                    resolve(getThemeColor());
+                    themeIntervalId = null;
+                }
+            }
+        }
+        themeIntervalId = window.requestAnimationFrame(animate);
+    });
+}
+function getThemeColor() {
+    var meta = getCurrentAppliedThemeColorMeta();
+    if (meta !== null)
+        return meta.getAttribute('content');
+    return estimateDefaultThemeColor();
+}
+function removeThemeColor(appearance) {
+    if (appearance === void 0) { appearance = 'default'; }
+    var meta = themeColorMetaGroup[appearance];
+    if (meta !== undefined)
+        meta.remove();
+    themeColorMetaGroup[appearance] = undefined;
+}
+function detectAppearance() {
+    if (IS_SAMSUNG)
+        return detectFromEngine();
+    else
+        return Promise.resolve(detectFromMediaQuery());
+}
+function onAppearanceChange(listener, options) {
+    if (options === void 0) { options = false; }
+    var entry = { fn: listener, capture: false, once: false };
+    if (typeof options === 'boolean')
+        options = { capture: options };
+    if (options.capture !== undefined)
+        entry.capture = options.capture;
+    if (options.once !== undefined)
+        entry.once = options.once;
+    if (options.signal !== undefined)
+        entry.signal = options.signal;
+    var index = indexOfEntry(entry);
+    if (index === -1) {
+        ENTRIES.push(entry);
+        if (ENTRIES.length === 1) {
+            if (IS_SAMSUNG)
+                startPolling();
+            else
+                addListener(entry.capture);
+        }
+        this.detectAppearance()
+            .then(notify);
+    }
+    else if (ENTRIES[index].once && !entry.once) {
+        ENTRIES[index].once = false;
+    }
+    if (entry.signal !== undefined) {
+        if (entry.signal.aborted) {
+            removeEntry(entry);
+        }
+        else {
+            entry.signal.addEventListener('abort', function onAbort() {
+                if (entry.signal !== undefined)
+                    entry.signal.removeEventListener('abort', onAbort);
+                removeEntry(entry);
+            });
+        }
+    }
+    return function () {
+        removeEntry(entry);
+    };
+}
+
+var ThemePlugin = {
+    installed: false,
+    name: 'Theme',
+    module: Theme,
+    constants: {
+        Appearances: Appearances
+    },
+    errors: {
+        EasingError: EasingError,
+        UnsupportedEasingFunctionError: UnsupportedEasingFunctionError,
+        StepSyntaxError: StepSyntaxError,
+        LinearSyntaxError: LinearSyntaxError,
+        CubicBezierSyntaxError: CubicBezierSyntaxError,
+        UnsupportedColorError: UnsupportedColorError
+    }
+};
+
+module.exports = ThemePlugin;