/**
 * TinyMCE version 7.7.1 (2025-03-05)
 */

(function () {
    "use strict";

    var global$1 = tinymce.util.Tools.resolve("tinymce.PluginManager");

    const eq = t => a => t === a;
    const isUndefined = eq(undefined);
    const isNullable = a => a === null || a === undefined;
    const isNonNullable = a => !isNullable(a);

    class Optional {
        constructor(tag, value) {
            this.tag = tag;
            this.value = value;
        }

        static some(value) {
            return new Optional(true, value);
        }

        static none() {
            return Optional.singletonNone;
        }

        static from(value) {
            return isNonNullable(value) ? Optional.some(value) : Optional.none();
        }

        fold(onNone, onSome) {
            if (this.tag) {
                return onSome(this.value);
            } else {
                return onNone();
            }
        }

        isSome() {
            return this.tag;
        }

        isNone() {
            return !this.tag;
        }

        map(mapper) {
            if (this.tag) {
                return Optional.some(mapper(this.value));
            } else {
                return Optional.none();
            }
        }

        bind(binder) {
            if (this.tag) {
                return binder(this.value);
            } else {
                return Optional.none();
            }
        }

        exists(predicate) {
            return this.tag && predicate(this.value);
        }

        forall(predicate) {
            return !this.tag || predicate(this.value);
        }

        filter(predicate) {
            if (!this.tag || predicate(this.value)) {
                return this;
            } else {
                return Optional.none();
            }
        }

        getOr(replacement) {
            return this.tag ? this.value : replacement;
        }

        or(replacement) {
            return this.tag ? this : replacement;
        }

        getOrThunk(thunk) {
            return this.tag ? this.value : thunk();
        }

        orThunk(thunk) {
            return this.tag ? this : thunk();
        }

        getOrDie(message) {
            if (!this.tag) {
                throw new Error(message !== null && message !== void 0 ? message : "Called getOrDie on None");
            } else {
                return this.value;
            }
        }

        getOrNull() {
            return this.tag ? this.value : null;
        }

        getOrUndefined() {
            return this.value;
        }

        each(worker) {
            if (this.tag) {
                worker(this.value);
            }
        }

        toArray() {
            return this.tag ? [this.value] : [];
        }

        toString() {
            return this.tag ? `some(${this.value})` : "none()";
        }
    }

    Optional.singletonNone = new Optional(false);

    const constant = value => {
        return () => {
            return value;
        };
    };
    const never = constant(false);

    const findUntil = (xs, pred, until) => {
        for (let i = 0, len = xs.length; i < len; i++) {
            const x = xs[i];
            if (pred(x, i)) {
                return Optional.some(x);
            } else if (until(x, i)) {
                break;
            }
        }
        return Optional.none();
    };
    const find$1 = (xs, pred) => {
        return findUntil(xs, pred, never);
    };
    const findMap = (arr, f) => {
        for (let i = 0; i < arr.length; i++) {
            const r = f(arr[i], i);
            if (r.isSome()) {
                return r;
            }
        }
        return Optional.none();
    };

    typeof window !== "undefined" ? window : Function("return this;")();

    const cached = f => {
        let called = false;
        let r;
        return (...args) => {
            if (!called) {
                called = true;
                r = f.apply(null, args);
            }
            return r;
        };
    };

    const DeviceType = (os, browser, userAgent, mediaMatch) => {
        const isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
        const isiPhone = os.isiOS() && !isiPad;
        const isMobile = os.isiOS() || os.isAndroid();
        const isTouch = isMobile || mediaMatch("(pointer:coarse)");
        const isTablet = isiPad || !isiPhone && isMobile && mediaMatch("(min-device-width:768px)");
        const isPhone = isiPhone || isMobile && !isTablet;
        const iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
        const isDesktop = !isPhone && !isTablet && !iOSwebview;
        return {
            isiPad: constant(isiPad),
            isiPhone: constant(isiPhone),
            isTablet: constant(isTablet),
            isPhone: constant(isPhone),
            isTouch: constant(isTouch),
            isAndroid: os.isAndroid,
            isiOS: os.isiOS,
            isWebView: constant(iOSwebview),
            isDesktop: constant(isDesktop)
        };
    };

    const firstMatch = (regexes, s) => {
        for (let i = 0; i < regexes.length; i++) {
            const x = regexes[i];
            if (x.test(s)) {
                return x;
            }
        }
        return undefined;
    };
    const find = (regexes, agent) => {
        const r = firstMatch(regexes, agent);
        if (!r) {
            return {
                major: 0,
                minor: 0
            };
        }
        const group = i => {
            return Number(agent.replace(r, "$" + i));
        };
        return nu$2(group(1), group(2));
    };
    const detect$3 = (versionRegexes, agent) => {
        const cleanedAgent = String(agent).toLowerCase();
        if (versionRegexes.length === 0) {
            return unknown$2();
        }
        return find(versionRegexes, cleanedAgent);
    };
    const unknown$2 = () => {
        return nu$2(0, 0);
    };
    const nu$2 = (major, minor) => {
        return {
            major,
            minor
        };
    };
    const Version = {
        nu: nu$2,
        detect: detect$3,
        unknown: unknown$2
    };

    const detectBrowser$1 = (browsers, userAgentData) => {
        return findMap(userAgentData.brands, uaBrand => {
            const lcBrand = uaBrand.brand.toLowerCase();
            return find$1(browsers, browser => {
                var _a;
                return lcBrand === ((_a = browser.brand) === null || _a === void 0 ? void 0 : _a.toLowerCase());
            }).map(info => ({
                current: info.name,
                version: Version.nu(parseInt(uaBrand.version, 10), 0)
            }));
        });
    };

    const detect$2 = (candidates, userAgent) => {
        const agent = String(userAgent).toLowerCase();
        return find$1(candidates, candidate => {
            return candidate.search(agent);
        });
    };
    const detectBrowser = (browsers, userAgent) => {
        return detect$2(browsers, userAgent).map(browser => {
            const version = Version.detect(browser.versionRegexes, userAgent);
            return {
                current: browser.name,
                version
            };
        });
    };
    const detectOs = (oses, userAgent) => {
        return detect$2(oses, userAgent).map(os => {
            const version = Version.detect(os.versionRegexes, userAgent);
            return {
                current: os.name,
                version
            };
        });
    };

    const contains = (str, substr, start = 0, end) => {
        const idx = str.indexOf(substr, start);
        if (idx !== -1) {
            return isUndefined(end) ? true : idx + substr.length <= end;
        } else {
            return false;
        }
    };

    const normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
    const checkContains = target => {
        return uastring => {
            return contains(uastring, target);
        };
    };
    const browsers = [
        {
            name: "Edge",
            versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
            search: uastring => {
                return contains(uastring, "edge/") && contains(uastring, "chrome") && contains(uastring, "safari") && contains(uastring, "applewebkit");
            }
        },
        {
            name: "Chromium",
            brand: "Chromium",
            versionRegexes: [
                /.*?chrome\/([0-9]+)\.([0-9]+).*/,
                normalVersionRegex
            ],
            search: uastring => {
                return contains(uastring, "chrome") && !contains(uastring, "chromeframe");
            }
        },
        {
            name: "IE",
            versionRegexes: [
                /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
                /.*?rv:([0-9]+)\.([0-9]+).*/
            ],
            search: uastring => {
                return contains(uastring, "msie") || contains(uastring, "trident");
            }
        },
        {
            name: "Opera",
            versionRegexes: [
                normalVersionRegex,
                /.*?opera\/([0-9]+)\.([0-9]+).*/
            ],
            search: checkContains("opera")
        },
        {
            name: "Firefox",
            versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
            search: checkContains("firefox")
        },
        {
            name: "Safari",
            versionRegexes: [
                normalVersionRegex,
                /.*?cpu os ([0-9]+)_([0-9]+).*/
            ],
            search: uastring => {
                return (contains(uastring, "safari") || contains(uastring, "mobile/")) && contains(uastring, "applewebkit");
            }
        }
    ];
    const oses = [
        {
            name: "Windows",
            search: checkContains("win"),
            versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
        },
        {
            name: "iOS",
            search: uastring => {
                return contains(uastring, "iphone") || contains(uastring, "ipad");
            },
            versionRegexes: [
                /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
                /.*cpu os ([0-9]+)_([0-9]+).*/,
                /.*cpu iphone os ([0-9]+)_([0-9]+).*/
            ]
        },
        {
            name: "Android",
            search: checkContains("android"),
            versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
        },
        {
            name: "macOS",
            search: checkContains("mac os x"),
            versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
        },
        {
            name: "Linux",
            search: checkContains("linux"),
            versionRegexes: []
        },
        {
            name: "Solaris",
            search: checkContains("sunos"),
            versionRegexes: []
        },
        {
            name: "FreeBSD",
            search: checkContains("freebsd"),
            versionRegexes: []
        },
        {
            name: "ChromeOS",
            search: checkContains("cros"),
            versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
        }
    ];
    const PlatformInfo = {
        browsers: constant(browsers),
        oses: constant(oses)
    };

    const edge = "Edge";
    const chromium = "Chromium";
    const ie = "IE";
    const opera = "Opera";
    const firefox = "Firefox";
    const safari = "Safari";
    const unknown$1 = () => {
        return nu$1({
            current: undefined,
            version: Version.unknown()
        });
    };
    const nu$1 = info => {
        const current = info.current;
        const version = info.version;
        const isBrowser = name => () => current === name;
        return {
            current,
            version,
            isEdge: isBrowser(edge),
            isChromium: isBrowser(chromium),
            isIE: isBrowser(ie),
            isOpera: isBrowser(opera),
            isFirefox: isBrowser(firefox),
            isSafari: isBrowser(safari)
        };
    };
    const Browser = {
        unknown: unknown$1,
        nu: nu$1,
        edge: constant(edge),
        chromium: constant(chromium),
        ie: constant(ie),
        opera: constant(opera),
        firefox: constant(firefox),
        safari: constant(safari)
    };

    const windows = "Windows";
    const ios = "iOS";
    const android = "Android";
    const linux = "Linux";
    const macos = "macOS";
    const solaris = "Solaris";
    const freebsd = "FreeBSD";
    const chromeos = "ChromeOS";
    const unknown = () => {
        return nu({
            current: undefined,
            version: Version.unknown()
        });
    };
    const nu = info => {
        const current = info.current;
        const version = info.version;
        const isOS = name => () => current === name;
        return {
            current,
            version,
            isWindows: isOS(windows),
            isiOS: isOS(ios),
            isAndroid: isOS(android),
            isMacOS: isOS(macos),
            isLinux: isOS(linux),
            isSolaris: isOS(solaris),
            isFreeBSD: isOS(freebsd),
            isChromeOS: isOS(chromeos)
        };
    };
    const OperatingSystem = {
        unknown,
        nu,
        windows: constant(windows),
        ios: constant(ios),
        android: constant(android),
        linux: constant(linux),
        macos: constant(macos),
        solaris: constant(solaris),
        freebsd: constant(freebsd),
        chromeos: constant(chromeos)
    };

    const detect$1 = (userAgent, userAgentDataOpt, mediaMatch) => {
        const browsers = PlatformInfo.browsers();
        const oses = PlatformInfo.oses();
        const browser = userAgentDataOpt.bind(userAgentData => detectBrowser$1(browsers, userAgentData)).orThunk(() => detectBrowser(browsers, userAgent)).fold(Browser.unknown, Browser.nu);
        const os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
        const deviceType = DeviceType(os, browser, userAgent, mediaMatch);
        return {
            browser,
            os,
            deviceType
        };
    };
    const PlatformDetection = {detect: detect$1};

    const mediaMatch = query => window.matchMedia(query).matches;
    let platform = cached(() => PlatformDetection.detect(window.navigator.userAgent, Optional.from(window.navigator.userAgentData), mediaMatch));
    const detect = () => platform();

    const isMacOS = () => detect().os.isMacOS();
    const isiOS = () => detect().os.isiOS();

    const getPreventClicksOnLinksScript = () => {
        const isMacOSOrIOS = isMacOS() || isiOS();
        const fn = isMacOSOrIOS => {
            document.addEventListener("click", e => {
                for (let elm = e.target; elm; elm = elm.parentNode) {
                    if (elm.nodeName === "A") {
                        const anchor = elm;
                        const href = anchor.getAttribute("href");
                        if (href && href.startsWith("#")) {
                            e.preventDefault();
                            const targetElement = document.getElementById(href.substring(1));
                            if (targetElement) {
                                targetElement.scrollIntoView({behavior: "smooth"});
                            }
                            return;
                        }
                        const isMetaKeyPressed = isMacOSOrIOS ? e.metaKey : e.ctrlKey && !e.altKey;
                        if (!isMetaKeyPressed) {
                            e.preventDefault();
                        }
                    }
                }
            }, false);
        };
        return `<script>(${fn.toString()})(${isMacOSOrIOS})</script>`;
    };

    var global = tinymce.util.Tools.resolve("tinymce.util.Tools");

    const option = name => editor => editor.options.get(name);
    const getContentStyle = option("content_style");
    const shouldUseContentCssCors = option("content_css_cors");
    const getBodyClass = option("body_class");
    const getBodyId = option("body_id");

    const getPreviewHtml = editor => {
        var _a;
        let headHtml = "";
        const encode = editor.dom.encode;
        const contentStyle = (_a = getContentStyle(editor)) !== null && _a !== void 0 ? _a : "";
        headHtml += `<base href="${encode(editor.documentBaseURI.getURI())}">`;
        const cors = shouldUseContentCssCors(editor) ? " crossorigin=\"anonymous\"" : "";
        global.each(editor.contentCSS, url => {
            headHtml += "<link type=\"text/css\" rel=\"stylesheet\" href=\"" + encode(editor.documentBaseURI.toAbsolute(url)) + "\"" + cors + ">";
        });
        if (contentStyle) {
            headHtml += "<style type=\"text/css\">" + contentStyle + "</style>";
        }
        const bodyId = getBodyId(editor);
        const bodyClass = getBodyClass(editor);
        const directionality = editor.getBody().dir;
        const dirAttr = directionality ? " dir=\"" + encode(directionality) + "\"" : "";
        const previewHtml = "<!DOCTYPE html>" + "<html>" + "<head>" + headHtml + "</head>" + "<body id=\"" + encode(bodyId) + "\" class=\"mce-content-body " + encode(bodyClass) + "\"" + dirAttr + ">" + editor.getContent() + getPreventClicksOnLinksScript() + "</body>" + "</html>";
        return previewHtml;
    };

    const open = editor => {
        const content = getPreviewHtml(editor);
        const dataApi = editor.windowManager.open({
            title: "Preview",
            size: "large",
            body: {
                type: "panel",
                items: [{
                    name: "preview",
                    type: "iframe",
                    sandboxed: true,
                    transparent: false
                }]
            },
            buttons: [{
                type: "cancel",
                name: "close",
                text: "Close",
                primary: true
            }],
            initialData: {preview: content}
        });
        dataApi.focus("close");
    };

    const register$1 = editor => {
        editor.addCommand("mcePreview", () => {
            open(editor);
        });
    };

    const register = editor => {
        const onAction = () => editor.execCommand("mcePreview");
        editor.ui.registry.addButton("preview", {
            icon: "preview",
            tooltip: "Preview",
            onAction,
            context: "any"
        });
        editor.ui.registry.addMenuItem("preview", {
            icon: "preview",
            text: "Preview",
            onAction,
            context: "any"
        });
    };

    var Plugin = () => {
        global$1.add("preview", editor => {
            register$1(editor);
            register(editor);
        });
    };

    Plugin();

})();
