AnonymousFox

/home/develito/.trash/v6/media/vendor/tinymce/tinymce.js

/**
 * TinyMCE version 8.3.2 (2026-01-14)
 */

(function () {
    'use strict';

var sort$1 = function (xs, compareFn) {
        var clone = Array.prototype.slice.call(xs);
        return clone.sort(compareFn);
    };

/* eslint-disable @typescript-eslint/no-wrapper-object-types */
 const getPrototypeOf$2 = Object.getPrototypeOf;
 const hasProto = (v, constructor, predicate) => {
 if (predicate(v, constructor.prototype)) {
 return true;
 }
 else {
 // String-based fallback time
 return v.constructor?.name === constructor.name;
 }
 };
 const typeOf = (x) => {
 const t = typeof x;
 if (x === null) {
 return 'null';
 }
 else if (t === 'object' && Array.isArray(x)) {
 return 'array';
 }
 else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
 return 'string';
 }
 else {
 return t;
 }
 };
 const isType$1 = (type) => (value) => typeOf(value) === type;
 const isSimpleType = (type) => (value) => typeof value === type;
 const eq$1 = (t) => (a) => t === a;
 const is$5 = (value, constructor) => isObject(value) && hasProto(value, constructor, (o, proto) => getPrototypeOf$2(o) === proto);
 const isString = isType$1('string');
 const isObject = isType$1('object');
 const isPlainObject = (value) => is$5(value, Object);
 const isArray$1 = isType$1('array');
 const isNull = eq$1(null);
 const isBoolean = isSimpleType('boolean');
 const isUndefined = eq$1(undefined);
 const isNullable = (a) => a === null || a === undefined;
 const isNonNullable = (a) => !isNullable(a);
 const isFunction = isSimpleType('function');
 const isNumber = isSimpleType('number');
 const isArrayOf = (value, pred) => {
 if (isArray$1(value)) {
 for (let i = 0, len = value.length; i < len; ++i) {
 if (!(pred(value[i]))) {
 return false;
 }
 }
 return true;
 }
 return false;
 };

/**
 * The `Optional` type represents a value (of any type) that potentially does
 * not exist. Any `Optional<T>` can either be a `Some<T>` (in which case the
 * value does exist) or a `None` (in which case the value does not exist). This
 * module defines a whole lot of FP-inspired utility functions for dealing with
 * `Optional` objects.
 *
 * Comparison with null or undefined:
 * - We don't get fancy null coalescing operators with `Optional`
 * - We do get fancy helper functions with `Optional`
 * - `Optional` support nesting, and allow for the type to still be nullable (or
 * another `Optional`)
 * - There is no option to turn off strict-optional-checks like there is for
 * strict-null-checks
 */
 class Optional {
 tag;
 value;
 // Sneaky optimisation: every instance of Optional.none is identical, so just
 // reuse the same object
 static singletonNone = new Optional(false);
 // The internal representation has a `tag` and a `value`, but both are
 // private: able to be console.logged, but not able to be accessed by code
 constructor(tag, value) {
 this.tag = tag;
 this.value = value;
 }
 // --- Identities ---
 /**
 * Creates a new `Optional<T>` that **does** contain a value.
 */
 static some(value) {
 return new Optional(true, value);
 }
 /**
 * Create a new `Optional<T>` that **does not** contain a value. `T` can be
 * any type because we don't actually have a `T`.
 */
 static none() {
 return Optional.singletonNone;
 }
 /**
 * Perform a transform on an `Optional` type. Regardless of whether this
 * `Optional` contains a value or not, `fold` will return a value of type `U`.
 * If this `Optional` does not contain a value, the `U` will be created by
 * calling `onNone`. If this `Optional` does contain a value, the `U` will be
 * created by calling `onSome`.
 *
 * For the FP enthusiasts in the room, this function:
 * 1. Could be used to implement all of the functions below
 * 2. Forms a catamorphism
 */
 fold(onNone, onSome) {
 if (this.tag) {
 return onSome(this.value);
 }
 else {
 return onNone();
 }
 }
 /**
 * Determine if this `Optional` object contains a value.
 */
 isSome() {
 return this.tag;
 }
 /**
 * Determine if this `Optional` object **does not** contain a value.
 */
 isNone() {
 return !this.tag;
 }
 // --- Functor (name stolen from Haskell / maths) ---
 /**
 * Perform a transform on an `Optional` object, **if** there is a value. If
 * you provide a function to turn a T into a U, this is the function you use
 * to turn an `Optional<T>` into an `Optional`. If this **does** contain
 * a value then the output will also contain a value (that value being the
 * output of `mapper(this.value)`), and if this **does not** contain a value
 * then neither will the output.
 */
 map(mapper) {
 if (this.tag) {
 return Optional.some(mapper(this.value));
 }
 else {
 return Optional.none();
 }
 }
 // --- Monad (name stolen from Haskell / maths) ---
 /**
 * Perform a transform on an `Optional` object, **if** there is a value.
 * Unlike `map`, here the transform itself also returns an `Optional`.
 */
 bind(binder) {
 if (this.tag) {
 return binder(this.value);
 }
 else {
 return Optional.none();
 }
 }
 // --- Traversable (name stolen from Haskell / maths) ---
 /**
 * For a given predicate, this function finds out if there **exists** a value
 * inside this `Optional` object that meets the predicate. In practice, this
 * means that for `Optional`s that do not contain a value it returns false (as
 * no predicate-meeting value exists).
 */
 exists(predicate) {
 return this.tag && predicate(this.value);
 }
 /**
 * For a given predicate, this function finds out if **all** the values inside
 * this `Optional` object meet the predicate. In practice, this means that
 * for `Optional`s that do not contain a value it returns true (as all 0
 * objects do meet the predicate).
 */
 forall(predicate) {
 return !this.tag || predicate(this.value);
 }
 filter(predicate) {
 if (!this.tag || predicate(this.value)) {
 return this;
 }
 else {
 return Optional.none();
 }
 }
 // --- Getters ---
 /**
 * Get the value out of the inside of the `Optional` object, using a default
 * `replacement` value if the provided `Optional` object does not contain a
 * value.
 */
 getOr(replacement) {
 return this.tag ? this.value : replacement;
 }
 /**
 * Get the value out of the inside of the `Optional` object, using a default
 * `replacement` value if the provided `Optional` object does not contain a
 * value. Unlike `getOr`, in this method the `replacement` object is also
 * `Optional` - meaning that this method will always return an `Optional`.
 */
 or(replacement) {
 return this.tag ? this : replacement;
 }
 /**
 * Get the value out of the inside of the `Optional` object, using a default
 * `replacement` value if the provided `Optional` object does not contain a
 * value. Unlike `getOr`, in this method the `replacement` value is
 * "thunked" - that is to say that you don't pass a value to `getOrThunk`, you
 * pass a function which (if called) will **return** the `value` you want to
 * use.
 */
 getOrThunk(thunk) {
 return this.tag ? this.value : thunk();
 }
 /**
 * Get the value out of the inside of the `Optional` object, using a default
 * `replacement` value if the provided Optional object does not contain a
 * value.
 *
 * Unlike `or`, in this method the `replacement` value is "thunked" - that is
 * to say that you don't pass a value to `orThunk`, you pass a function which
 * (if called) will **return** the `value` you want to use.
 *
 * Unlike `getOrThunk`, in this method the `replacement` value is also
 * `Optional`, meaning that this method will always return an `Optional`.
 */
 orThunk(thunk) {
 return this.tag ? this : thunk();
 }
 /**
 * Get the value out of the inside of the `Optional` object, throwing an
 * exception if the provided `Optional` object does not contain a value.
 *
 * WARNING:
 * You should only be using this function if you know that the `Optional`
 * object **is not** empty (otherwise you're throwing exceptions in production
 * code, which is bad).
 *
 * In tests this is more acceptable.
 *
 * Prefer other methods to this, such as `.each`.
 */
 getOrDie(message) {
 if (!this.tag) {
 throw new Error(message ?? 'Called getOrDie on None');
 }
 else {
 return this.value;
 }
 }
 // --- Interop with null and undefined ---
 /**
 * Creates an `Optional` value from a nullable (or undefined-able) input.
 * Null, or undefined, is converted to `None`, and anything else is converted
 * to `Some`.
 */
 static from(value) {
 return isNonNullable(value) ? Optional.some(value) : Optional.none();
 }
 /**
 * Converts an `Optional` to a nullable type, by getting the value if it
 * exists, or returning `null` if it does not.
 */
 getOrNull() {
 return this.tag ? this.value : null;
 }
 /**
 * Converts an `Optional` to an undefined-able type, by getting the value if
 * it exists, or returning `undefined` if it does not.
 */
 getOrUndefined() {
 return this.value;
 }
 // --- Utilities ---
 /**
 * If the `Optional` contains a value, perform an action on that value.
 * Unlike the rest of the methods on this type, `.each` has side-effects. If
 * you want to transform an `Optional<T>` **into** something, then this is not
 * the method for you. If you want to use an `Optional<T>` to **do**
 * something, then this is the method for you - provided you're okay with not
 * doing anything in the case where the `Optional` doesn't have a value inside
 * it. If you're not sure whether your use-case fits into transforming
 * **into** something or **doing** something, check whether it has a return
 * value. If it does, you should be performing a transform.
 */
 each(worker) {
 if (this.tag) {
 worker(this.value);
 }
 }
 /**
 * Turn the `Optional` object into an array that contains all of the values
 * stored inside the `Optional`. In practice, this means the output will have
 * either 0 or 1 elements.
 */
 toArray() {
 return this.tag ? [this.value] : [];
 }
 /**
 * Turn the `Optional` object into a string for debugging or printing. Not
 * recommended for production code, but good for debugging. Also note that
 * these days an `Optional` object can be logged to the console directly, and
 * its inner value (if it exists) will be visible.
 */
 toString() {
 return this.tag ? `some(${this.value})` : 'none()';
 }
 }

// There are many variations of Object iteration that are faster than the 'for-in' style:
 // http://jsperf.com/object-keys-iteration/107
 //
 // Use the native keys if it is available (IE9+), otherwise fall back to manually filtering
 const keys = Object.keys;
 const hasOwnProperty$1 = Object.hasOwnProperty;
 const each$d = (obj, f) => {
 const props = keys(obj);
 for (let k = 0, len = props.length; k < len; k++) {
 const i = props[k];
 const x = obj[i];
 f(x, i);
 }
 };
 const map$2 = (obj, f) => {
 return tupleMap(obj, (x, i) => ({
 k: i,
 v: f(x, i)
 }));
 };
 const tupleMap = (obj, f) => {
 const r = {};
 each$d(obj, (x, i) => {
 const tuple = f(x, i);
 r[tuple.k] = tuple.v;
 });
 return r;
 };
 const objAcc = (r) => (x, i) => {
 r[i] = x;
 };
 const internalFilter = (obj, pred, onTrue, onFalse) => {
 each$d(obj, (x, i) => {
 (pred(x, i) ? onTrue : onFalse)(x, i);
 });
 };
 const bifilter = (obj, pred) => {
 const t = {};
 const f = {};
 internalFilter(obj, pred, objAcc(t), objAcc(f));
 return { t, f };
 };
 const filter$4 = (obj, pred) => {
 const t = {};
 internalFilter(obj, pred, objAcc(t), noop);
 return t;
 };
 const mapToArray = (obj, f) => {
 const r = [];
 each$d(obj, (value, name) => {
 r.push(f(value, name));
 });
 return r;
 };
 const values = (obj) => {
 return mapToArray(obj, identity);
 };
 const get$a = (obj, key) => {
 return has$2(obj, key) ? Optional.from(obj[key]) : Optional.none();
 };
 const has$2 = (obj, key) => hasOwnProperty$1.call(obj, key);
 const hasNonNullableKey = (obj, key) => has$2(obj, key) && obj[key] !== undefined && obj[key] !== null;
 const equal$1 = (a1, a2, eq = eqAny) => eqRecord(eq).eq(a1, a2);

/*
     * Generates a church encoded ADT (https://en.wikipedia.org/wiki/Church_encoding)
     * For syntax and use, look at the test code.
     */
    const generate$1 = (cases) => {
        // validation
        if (!isArray$1(cases)) {
            throw new Error('cases must be an array');
        }
        if (cases.length === 0) {
            throw new Error('there must be at least one case');
        }
        const constructors = [];
        // adt is mutated to add the individual cases
        const adt = {};
        each$e(cases, (acase, count) => {
            const keys$1 = keys(acase);
            // validation
            if (keys$1.length !== 1) {
                throw new Error('one and only one name per case');
            }
            const key = keys$1[0];
            const value = acase[key];
            // validation
            if (adt[key] !== undefined) {
                throw new Error('duplicate key detected:' + key);
            }
            else if (key === 'cata') {
                throw new Error('cannot have a case named cata (sorry)');
            }
            else if (!isArray$1(value)) {
                // this implicitly checks if acase is an object
                throw new Error('case arguments must be an array');
            }
            constructors.push(key);
            //
            // constructor for key
            //
            adt[key] = (...args) => {
                const argLength = args.length;
                // validation
                if (argLength !== value.length) {
                    throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
                }
                const match = (branches) => {
                    const branchKeys = keys(branches);
                    if (constructors.length !== branchKeys.length) {
                        throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
                    }
                    const allReqd = forall(constructors, (reqKey) => {
                        return contains$2(branchKeys, reqKey);
                    });
                    if (!allReqd) {
                        throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
                    }
                    return branches[key].apply(null, args);
                };
                //
                // the fold function for key
                //
                return {
                    fold: (...foldArgs) => {
                        // runtime validation
                        if (foldArgs.length !== cases.length) {
                            throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
                        }
                        const target = foldArgs[count];
                        return target.apply(null, args);
                    },
                    match,
                    // NOTE: Only for debugging.
                    log: (label) => {
                        // eslint-disable-next-line no-console
                        console.log(label, {
                            constructors,
                            constructor: key,
                            params: args
                        });
                    }
                };
            };
        });
        return adt;
    };
    const Adt = {
        generate: generate$1
    };

/**
 * Creates a new `Result<T, E>` that **does** contain a value.
 */
 const value$2 = (value) => {
 const applyHelper = (fn) => fn(value);
 const constHelper = constant(value);
 const outputHelper = () => output;
 const output = {
 // Debug info
 tag: true,
 inner: value,
 // Actual Result methods
 fold: (_onError, onValue) => onValue(value),
 isValue: always,
 isError: never,
 map: (mapper) => Result.value(mapper(value)),
 mapError: outputHelper,
 bind: applyHelper,
 exists: applyHelper,
 forall: applyHelper,
 getOr: constHelper,
 or: outputHelper,
 getOrThunk: constHelper,
 orThunk: outputHelper,
 getOrDie: constHelper,
 each: (fn) => {
 // Can't write the function inline because we don't want to return something by mistake
 fn(value);
 },
 toOptional: () => Optional.some(value),
 };
 return output;
 };
 /**
 * Creates a new `Result<T, E>` that **does not** contain a value, and therefore
 * contains an error.
 */
 const error = (error) => {
 const outputHelper = () => output;
 const output = {
 // Debug info
 tag: false,
 inner: error,
 // Actual Result methods
 fold: (onError, _onValue) => onError(error),
 isValue: never,
 isError: always,
 map: outputHelper,
 mapError: (mapper) => Result.error(mapper(error)),
 bind: outputHelper,
 exists: never,
 forall: always,
 getOr: identity,
 or: identity,
 getOrThunk: apply$1,
 orThunk: apply$1,
 getOrDie: die(String(error)),
 each: noop,
 toOptional: Optional.none,
 };
 return output;
 };
 /**
 * Creates a new `Result<T, E>` from an `Optional<T>` and an `E`. If the
 * `Optional` contains a value, so will the outputted `Result`. If it does not,
 * the outputted `Result` will contain an error (and that error will be the
 * error passed in).
 */
 const fromOption = (optional, err) => optional.fold(() => error(err), value$2);
 const Result = {
 value: value$2,
 error,
 fromOption
 };

// Use window object as the global if it's available since CSP will block script evals
    // eslint-disable-next-line @typescript-eslint/no-implied-eval
    const Global = typeof window !== 'undefined' ? window : Function('return this;')();

/* eslint-disable no-bitwise */
 const uuidV4Bytes = () => {
 const bytes = window.crypto.getRandomValues(new Uint8Array(16));
 // https://tools.ietf.org/html/rfc4122#section-4.1.3
 // This will first bit mask away the most significant 4 bits (version octet)
 // then mask in the v4 number we only care about v4 random version at this point so (byte & 0b00001111 | 0b01000000)
 bytes[6] = bytes[6] & 15 | 64;
 // https://tools.ietf.org/html/rfc4122#section-4.1.1
 // This will first bit mask away the highest two bits then masks in the highest bit so (byte & 0b00111111 | 0b10000000)
 // So it will set the Msb0=1 & Msb1=0 described by the "The variant specified in this document." row in the table
 bytes[8] = bytes[8] & 63 | 128;
 return bytes;
 };
 const uuidV4String = () => {
 const uuid = uuidV4Bytes();
 const getHexRange = (startIndex, endIndex) => {
 let buff = '';
 for (let i = startIndex; i <= endIndex; ++i) {
 const hexByte = uuid[i].toString(16).padStart(2, '0');
 buff += hexByte;
 }
 return buff;
 };
 // RFC 4122 UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 return `${getHexRange(0, 3)}-${getHexRange(4, 5)}-${getHexRange(6, 7)}-${getHexRange(8, 9)}-${getHexRange(10, 15)}`;
 };

/**
     * Adds two numbers, and wrap to a range.
     * If the result overflows to the right, snap to the left.
     * If the result overflows to the left, snap to the right.
     */
    // ASSUMPTION: Max will always be larger than min
    const clamp$2 = (value, min, max) => Math.min(Math.max(value, min), max);
    // the division is meant to get a number between 0 and 1 for more information check this discussion: https://stackoverflow.com/questions/58285941/how-to-replace-math-random-with-crypto-getrandomvalues-and-keep-same-result
    const random = () => window.crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;

/**
     * Generate a unique identifier.
     *
     * The unique portion of the identifier only contains an underscore
     * and digits, so that it may safely be used within HTML attributes.
     *
     * The chance of generating a non-unique identifier has been minimized
     * by combining the current time, a random number and a one-up counter.
     *
     * generate :: String -> String
     */
    let unique = 0;
    const generate = (prefix) => {
        const date = new Date();
        const time = date.getTime();
        const random$1 = Math.floor(random() * 1000000000);
        unique++;
        return prefix + '_' + random$1 + unique + String(time);
    };
    /**
     * Generate a uuidv4 string
     * In accordance with RFC 4122 (https://datatracker.ietf.org/doc/html/rfc4122)
     */
    const uuidV4 = () => {
        if (window.isSecureContext) {
            return window.crypto.randomUUID();
        }
        else {
            return uuidV4String();
        }
    };

/**
 * **Is** the value stored inside this Optional object equal to `rhs`?
 */
 const is$4 = (lhs, rhs, comparator = tripleEquals) => lhs.exists((left) => comparator(left, rhs));
 /**
 * Are these two Optional objects equal? Equality here means either they're both
 * `Some` (and the values are equal under the comparator) or they're both `None`.
 */
 const equals = (lhs, rhs, comparator = tripleEquals) => lift2(lhs, rhs, comparator).getOr(lhs.isNone() && rhs.isNone());
 const cat = (arr) => {
 const r = [];
 const push = (x) => {
 r.push(x);
 };
 for (let i = 0; i < arr.length; i++) {
 arr[i].each(push);
 }
 return r;
 };
 /*
 Notes on the lift functions:
 - We used to have a generic liftN, but we were concerned about its type-safety, and the below variants were faster in microbenchmarks.
 - The getOrDie calls are partial functions, but are checked beforehand. This is faster and more convenient (but less safe) than folds.
 - && is used instead of a loop for simplicity and performance.
 */
 const lift2 = (oa, ob, f) => oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none();
 const lift3 = (oa, ob, oc, f) => oa.isSome() && ob.isSome() && oc.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie(), oc.getOrDie())) : Optional.none();
 const flatten = (oot) => oot.bind(identity);
 // This can help with type inference, by specifying the type param on the none case, so the caller doesn't have to.
 const someIf = (b, a) => b ? Optional.some(a) : Optional.none();

/** path :: ([String], JsObj?) -> JsObj */
 const path = (parts, scope) => {
 let o = scope !== undefined && scope !== null ? scope : Global;
 for (let i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
 o = o[parts[i]];
 }
 return o;
 };
 /** resolve :: (String, JsObj?) -> JsObj */
 const resolve$3 = (p, scope) => {
 const parts = p.split('.');
 return path(parts, scope);
 };

Adt.generate([
        { bothErrors: ['error1', 'error2'] },
        { firstError: ['error1', 'value2'] },
        { secondError: ['value1', 'error2'] },
        { bothValues: ['value1', 'value2'] }
    ]);
    /** partition :: [Result a] -> { errors: [String], values: [a] } */
    const partition$1 = (results) => {
        const errors = [];
        const values = [];
        each$e(results, (result) => {
            result.fold((err) => {
                errors.push(err);
            }, (value) => {
                values.push(value);
            });
        });
        return { errors, values };
    };

const removeFromStart = (str, numChars) => {
        return str.substring(numChars);
    };

// Run a function fn after rate ms. If another invocation occurs
    // during the time it is waiting, ignore it completely.
    const first$1 = (fn, rate) => {
        let timer = null;
        const cancel = () => {
            if (!isNull(timer)) {
                clearTimeout(timer);
                timer = null;
            }
        };
        const throttle = (...args) => {
            if (isNull(timer)) {
                timer = setTimeout(() => {
                    timer = null;
                    fn.apply(null, args);
                }, rate);
            }
        };
        return {
            cancel,
            throttle
        };
    };
    // Run a function fn after rate ms. If another invocation occurs
    // during the time it is waiting, reschedule the function again
    // with the new arguments.
    const last$1 = (fn, rate) => {
        let timer = null;
        const cancel = () => {
            if (!isNull(timer)) {
                clearTimeout(timer);
                timer = null;
            }
        };
        const throttle = (...args) => {
            cancel();
            timer = setTimeout(() => {
                timer = null;
                fn.apply(null, args);
            }, rate);
        };
        return {
            cancel,
            throttle
        };
    };

const zeroWidth = '\uFEFF';
    const nbsp = '\u00A0';
    const ellipsis = '\u2026';
    const isZwsp$2 = (char) => char === zeroWidth;
    const removeZwsp = (s) => s.replace(/\uFEFF/g, '');

const stringArray = (a) => {
        const all = {};
        each$e(a, (key) => {
            all[key] = {};
        });
        return keys(all);
    };

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 mediaMatch = (query) => window.matchMedia(query).matches;
    // IMPORTANT: Must be in a thunk, otherwise rollup thinks calling this immediately
    // causes side effects and won't tree shake this away
    // Note: navigator.userAgentData is not part of the native typescript types yet
    let platform$4 = cached(() => PlatformDetection.detect(window.navigator.userAgent, Optional.from((window.navigator.userAgentData)), mediaMatch));
    const detect$1 = () => platform$4();

const getPrototypeOf$1 = Object.getPrototypeOf;
    /*
     * IE9 and above
     *
     * MDN no use on this one, but here's the link anyway:
     * https://developer.mozilla.org/en/docs/Web/API/HTMLElement
     */
    const sandHTMLElement = (scope) => {
        return getOrDie('HTMLElement', scope);
    };
    const isPrototypeOf = (x) => {
        // use Resolve to get the window object for x and just return undefined if it can't find it.
        // undefined scope later triggers using the global window.
        const scope = resolve$3('ownerDocument.defaultView', x);
        // TINY-7374: We can't rely on looking at the owner window HTMLElement as the element may have
        // been constructed in a different window and then appended to the current window document.
        return isObject(x) && (sandHTMLElement(scope).prototype.isPrototypeOf(x) || /^HTML\w*Element$/.test(getPrototypeOf$1(x).constructor.name));
    };

/**
     * This class contains various environment constants like browser versions etc.
     * Normally you don't want to sniff specific browser versions but sometimes you have
     * to when it's impossible to feature detect. So use this with care.
     *
     * @class tinymce.Env
     * @static
     */
    const userAgent = window.navigator.userAgent;
    const platform$3 = detect$1();
    const browser$3 = platform$3.browser;
    const os$1 = platform$3.os;
    const deviceType = platform$3.deviceType;
    const windowsPhone = userAgent.indexOf('Windows Phone') !== -1;
    const Env = {
        /**
         * Transparent image data url.
         *
         * @property transparentSrc
         * @type Boolean
         * @final
         */
        transparentSrc: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
        /**
         * Returns the IE document mode. For non IE browsers, this will fake IE 10 document mode.
         *
         * @property documentMode
         * @type Number
         */
        documentMode: browser$3.isIE() ? (document.documentMode || 7) : 10,
        cacheSuffix: null,
        container: null,
        /**
         * Constant if CSP mode is possible or not. Meaning we can't use script urls for the iframe.
         */
        canHaveCSP: !browser$3.isIE(),
        windowsPhone,
        /**
         * @include ../../../../../tools/docs/tinymce.Env.js
         */
        browser: {
            current: browser$3.current,
            version: browser$3.version,
            isChromium: browser$3.isChromium,
            isEdge: browser$3.isEdge,
            isFirefox: browser$3.isFirefox,
            isIE: browser$3.isIE,
            isOpera: browser$3.isOpera,
            isSafari: browser$3.isSafari
        },
        os: {
            current: os$1.current,
            version: os$1.version,
            isAndroid: os$1.isAndroid,
            isChromeOS: os$1.isChromeOS,
            isFreeBSD: os$1.isFreeBSD,
            isiOS: os$1.isiOS,
            isLinux: os$1.isLinux,
            isMacOS: os$1.isMacOS,
            isSolaris: os$1.isSolaris,
            isWindows: os$1.isWindows
        },
        deviceType: {
            isDesktop: deviceType.isDesktop,
            isiPad: deviceType.isiPad,
            isiPhone: deviceType.isiPhone,
            isPhone: deviceType.isPhone,
            isTablet: deviceType.isTablet,
            isTouch: deviceType.isTouch,
            isWebView: deviceType.isWebView
        }
    };

/**
 * This class contains various utility functions. These are also exposed
 * directly on the tinymce namespace.
 *
 * @class tinymce.util.Tools
 */
 /**
 * Removes whitespace from the beginning and end of a string.
 *
 * @method trim
 * @param {String} s String to remove whitespace from.
 * @return {String} New string with removed whitespace.
 */
 const whiteSpaceRegExp$1 = /^\s*|\s*$/g;
 const trim$3 = (str) => {
 return isNullable(str) ? '' : ('' + str).replace(whiteSpaceRegExp$1, '');
 };
 /**
 * Checks if a object is of a specific type for example an array.
 *
 * @method is
 * @param {Object} obj Object to check type of.
 * @param {String} type Optional type to check for.
 * @return {Boolean} true/false if the object is of the specified type.
 */
 const is$3 = (obj, type) => {
 if (!type) {
 return obj !== undefined;
 }
 if (type === 'array' && isArray(obj)) {
 return true;
 }
 return typeof obj === type;
 };
 /**
 * Makes a name/object map out of an array with names.
 *
 * @method makeMap
 * @param {Array/String} items Items to make map out of.
 * @param {String} delim Optional delimiter to split string by.
 * @param {Object} map Optional map to add items to.
 * @return {Object} Name/value map of items.
 */
 const makeMap$4 = (items, delim, map = {}) => {
 const resolvedItems = isString(items) ? items.split(delim || ',') : (items || []);
 let i = resolvedItems.length;
 while (i--) {
 map[resolvedItems[i]] = {};
 }
 return map;
 };
 /**
 * JavaScript does not protect hasOwnProperty method, so it is possible to overwrite it. This is
 * an object independent version.
 * Checks if the input object "<code>obj</code>" has the property "<code>prop</code>".
 *
 * @method hasOwnProperty
 * @param {Object} obj Object to check if the property exists.
 * @param {String} prop Name of a property on the object.
 * @returns {Boolean} true if the object has the specified property.
 */
 const hasOwnProperty = has$2;
 const extend$3 = (obj, ...exts) => {
 for (let i = 0; i < exts.length; i++) {
 const ext = exts[i];
 for (const name in ext) {
 if (has$2(ext, name)) {
 const value = ext[name];
 if (value !== undefined) {
 obj[name] = value;
 }
 }
 }
 }
 return obj;
 };
 /**
 * Executed the specified function for each item in a object tree.
 *
 * @method walk
 * @param {Object} o Object tree to walk though.
 * @param {Function} f Function to call for each item.
 * @param {String} n Optional name of collection inside the objects to walk for example childNodes.
 * @param {String} s Optional scope to execute the function in.
 */
 const walk$4 = function (o, f, n, s) {
 s = s || this;
 if (o) {
 if (n) {
 o = o[n];
 }
 each$c(o, (o, i) => {
 if (f.call(s, o, i, n) === false) {
 return false;
 }
 else {
 walk$4(o, f, n, s);
 return true;
 }
 });
 }
 };
 /**
 * Resolves a string and returns the object from a specific structure.
 *
 * @method resolve
 * @param {String} n Path to resolve for example a.b.c.d.
 * @param {Object} o Optional object to search though, defaults to window.
 * @return {Object} Last object in path or null if it couldn't be resolved.
 * @example
 * // Resolve a path into an object reference
 * const obj = tinymce.resolve('a.b.c.d');
 */
 const resolve$2 = (n, o = window) => {
 const path = n.split('.');
 for (let i = 0, l = path.length; i < l; i++) {
 o = o[path[i]];
 if (!o) {
 break;
 }
 }
 return o;
 };
 /**
 * Splits a string but removes the whitespace before and after each value.
 *
 * @method explode
 * @param {String} s String to split.
 * @param {String} d Delimiter to split by.
 * @example
 * // Split a string into an array with a,b,c
 * const arr = tinymce.explode('a, b, c');
 */
 const explode$3 = (s, d) => {
 if (isArray$1(s)) {
 return s;
 }
 else if (s === '') {
 return [];
 }
 else {
 return map$1(s.split(d || ','), trim$3);
 }
 };
 const _addCacheSuffix = (url) => {
 const cacheSuffix = Env.cacheSuffix;
 if (cacheSuffix) {
 url += (url.indexOf('?') === -1 ? '?' : '&') + cacheSuffix;
 }
 return url;
 };
 const Tools = {
 trim: trim$3,
 /**
 * Returns true/false if the object is an array or not.
 *
 * @method isArray
 * @param {Object} obj Object to check.
 * @return {Boolean} true/false state if the object is an array or not.
 */
 isArray: isArray,
 is: is$3,
 /**
 * Converts the specified object into a real JavaScript array.
 *
 * @method toArray
 * @param {Object} obj Object to convert into array.
 * @return {Array} Array object based in input.
 */
 toArray: toArray$1,
 makeMap: makeMap$4,
 /**
 * Performs an iteration of all items in a collection such as an object or array. This method will execute the
 * callback function for each item in the collection, if the callback returns false the iteration will terminate.
 * The callback has the following format: `cb(value, key_or_index)`.
 *
 * @method each
 * @param {Object} o Collection to iterate.
 * @param {Function} cb Callback function to execute for each item.
 * @param {Object} s Optional scope to execute the callback in.
 * @example
 * // Iterate an array
 * tinymce.each([ 1,2,3 ], (v, i) => {
 * console.debug("Value: " + v + ", Index: " + i);
 * });
 *
 * // Iterate an object
 * tinymce.each({ a: 1, b: 2, c: 3 }, (v, k) => {
 * console.debug("Value: " + v + ", Key: " + k);
 * });
 */
 each: each$c,
 /**
 * Creates a new array by the return value of each iteration function call. This enables you to convert
 * one array list into another.
 *
 * @method map
 * @param {Array} array Array of items to iterate.
 * @param {Function} callback Function to call for each item. It's return value will be the new value.
 * @return {Array} Array with new values based on function return values.
 */
 map: map$1,
 /**
 * Filters out items from the input array by calling the specified function for each item.
 * If the function returns false the item will be excluded if it returns true it will be included.
 *
 * @method grep
 * @param {Array} a Array of items to loop though.
 * @param {Function} f Function to call for each item. Include/exclude depends on it's return value.
 * @return {Array} New array with values imported and filtered based in input.
 * @example
 * // Filter out some items, this will return an array with 4 and 5
 * const items = tinymce.grep([ 1,2,3,4,5 ], (v) => v > 3);
 */
 grep: filter$3,
 /**
 * Returns an index of the item or -1 if item is not present in the array.
 *
 * @method inArray
 * @param {any} item Item to search for.
 * @param {Array} arr Array to search in.
 * @return {Number} index of the item or -1 if item was not found.
 */
 inArray: indexOf,
 hasOwn: hasOwnProperty,
 extend: extend$3,
 walk: walk$4,
 resolve: resolve$2,
 explode: explode$3,
 _addCacheSuffix
 };

// NOTE: Mutates the range.
    const setStart = (rng, situ) => {
        situ.fold((e) => {
            rng.setStartBefore(e.dom);
        }, (e, o) => {
            rng.setStart(e.dom, o);
        }, (e) => {
            rng.setStartAfter(e.dom);
        });
    };
    const setFinish = (rng, situ) => {
        situ.fold((e) => {
            rng.setEndBefore(e.dom);
        }, (e, o) => {
            rng.setEnd(e.dom, o);
        }, (e) => {
            rng.setEndAfter(e.dom);
        });
    };
    const relativeToNative = (win, startSitu, finishSitu) => {
        const range = win.document.createRange();
        setStart(range, startSitu);
        setFinish(range, finishSitu);
        return range;
    };
    const exactToNative = (win, start, soffset, finish, foffset) => {
        const rng = win.document.createRange();
        rng.setStart(start.dom, soffset);
        rng.setEnd(finish.dom, foffset);
        return rng;
    };

const COMMENT = 8;
    const DOCUMENT = 9;
    const DOCUMENT_FRAGMENT = 11;
    const ELEMENT = 1;
    const TEXT = 3;

const eq = (e1, e2) => e1.dom === e2.dom;
    // Returns: true if node e1 contains e2, otherwise false.
    // (returns false if e1===e2: A node does not contain itself).
    const contains = (e1, e2) => {
        const d1 = e1.dom;
        const d2 = e2.dom;
        return d1 === d2 ? false : d1.contains(d2);
    };
    const is$1 = is$2;

/**
     * Applies f repeatedly until it completes (by returning Optional.none()).
     *
     * Normally would just use recursion, but JavaScript lacks tail call optimisation.
     *
     * This is what recursion looks like when manually unravelled :)
     */
    const toArray = (target, f) => {
        const r = [];
        const recurse = (e) => {
            r.push(e);
            return f(e);
        };
        let cur = f(target);
        do {
            cur = cur.bind(recurse);
        } while (cur.isSome());
        return r;
    };

const name = (element) => {
        const r = element.dom.nodeName;
        return r.toLowerCase();
    };
    const type$1 = (element) => element.dom.nodeType;
    const isType = (t) => (element) => type$1(element) === t;
    const isComment$1 = (element) => type$1(element) === COMMENT || name(element) === '#comment';
    const isHTMLElement$1 = (element) => isElement$8(element) && isPrototypeOf(element.dom);
    const isElement$8 = isType(ELEMENT);
    const isText$c = isType(TEXT);
    const isDocument$2 = isType(DOCUMENT);
    const isDocumentFragment$1 = isType(DOCUMENT_FRAGMENT);
    const isTag = (tag) => (e) => isElement$8(e) && name(e) === tag;

/**
     * The document associated with the current element
     * NOTE: this will throw if the owner is null.
     */
    const owner$1 = (element) => SugarElement.fromDom(element.dom.ownerDocument);
    /**
     * If the element is a document, return it. Otherwise, return its ownerDocument.
     * @param dos
     */
    const documentOrOwner = (dos) => isDocument$2(dos) ? dos : owner$1(dos);
    const documentElement = (element) => SugarElement.fromDom(documentOrOwner(element).dom.documentElement);
    /**
     * The window element associated with the element
     * NOTE: this will throw if the defaultView is null.
     */
    const defaultView = (element) => SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
    const parent = (element) => Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
    const parentElement = (element) => Optional.from(element.dom.parentElement).map(SugarElement.fromDom);
    const parents$1 = (element, isRoot) => {
        const stop = isFunction(isRoot) ? isRoot : never;
        // This is used a *lot* so it needs to be performant, not recursive
        let dom = element.dom;
        const ret = [];
        while (dom.parentNode !== null && dom.parentNode !== undefined) {
            const rawParent = dom.parentNode;
            const p = SugarElement.fromDom(rawParent);
            ret.push(p);
            if (stop(p) === true) {
                break;
            }
            else {
                dom = rawParent;
            }
        }
        return ret;
    };
    const siblings = (element) => {
        // TODO: Refactor out children so we can just not add self instead of filtering afterwards
        const filterSelf = (elements) => filter$5(elements, (x) => !eq(element, x));
        return parent(element).map(children$1).map(filterSelf).getOr([]);
    };
    const prevSibling = (element) => Optional.from(element.dom.previousSibling).map(SugarElement.fromDom);
    const nextSibling = (element) => Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
    // This one needs to be reversed, so they're still in DOM order
    const prevSiblings = (element) => reverse(toArray(element, prevSibling));
    const nextSiblings = (element) => toArray(element, nextSibling);
    const children$1 = (element) => map$3(element.dom.childNodes, SugarElement.fromDom);
    const child$1 = (element, index) => {
        const cs = element.dom.childNodes;
        return Optional.from(cs[index]).map(SugarElement.fromDom);
    };
    const firstChild = (element) => child$1(element, 0);
    const lastChild = (element) => child$1(element, element.dom.childNodes.length - 1);
    const childNodesCount = (element) => element.dom.childNodes.length;

const getHead = (doc) => {
        /*
         * IE9 and above per
         * https://developer.mozilla.org/en-US/docs/Web/API/Document/head
         */
        const b = doc.dom.head;
        if (b === null || b === undefined) {
            throw new Error('Head is not available yet');
        }
        return SugarElement.fromDom(b);
    };

/**
     * Is the element a ShadowRoot?
     *
     * Note: this is insufficient to test if any element is a shadow root, but it is sufficient to differentiate between
     * a Document and a ShadowRoot.
     */
    const isShadowRoot = (dos) => isDocumentFragment$1(dos) && isNonNullable(dos.dom.host);
    const getRootNode = (e) => SugarElement.fromDom(e.dom.getRootNode());
    /** Where style tags need to go. ShadowRoot or document head */
    const getStyleContainer = (dos) => isShadowRoot(dos) ? dos : getHead(documentOrOwner(dos));
    /** Where content needs to go. ShadowRoot or document body */
    const getContentContainer = (dos) => 
    // Can't use SugarBody.body without causing a circular module reference (since SugarBody.inBody uses SugarShadowDom)
    isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
    /** If this element is in a ShadowRoot, return it. */
    const getShadowRoot = (e) => {
        const r = getRootNode(e);
        return isShadowRoot(r) ? Optional.some(r) : Optional.none();
    };
    /** Return the host of a ShadowRoot.
     *
     * This function will throw if Shadow DOM is unsupported in the browser, or if the host is null.
     * If you actually have a ShadowRoot, this shouldn't happen.
     */
    const getShadowHost = (e) => SugarElement.fromDom(e.dom.host);
    /**
     * When Events bubble up through a ShadowRoot, the browser changes the target to be the shadow host.
     * This function gets the "original" event target if possible.
     * This only works if the shadow tree is open - if the shadow tree is closed, event.target is returned.
     * See: https://developers.google.com/web/fundamentals/web-components/shadowdom#events
     */
    const getOriginalEventTarget = (event) => {
        if (isNonNullable(event.target)) {
            const el = SugarElement.fromDom(event.target);
            if (isElement$8(el) && isOpenShadowHost(el)) {
                // When target element is inside Shadow DOM we need to take first element from composedPath
                // otherwise we'll get Shadow Root parent, not actual target element.
                if (event.composed && event.composedPath) {
                    const composedPath = event.composedPath();
                    if (composedPath) {
                        return head(composedPath);
                    }
                }
            }
        }
        return Optional.from(event.target);
    };
    /** Return true if the element is a host of an open shadow root.
     *  Return false if the element is a host of a closed shadow root, or if the element is not a host.
     */
    const isOpenShadowHost = (element) => isNonNullable(element.dom.shadowRoot);

const filter$2 = always; // no filter on plain DomEvents
    const bind$1 = (element, event, handler) => bind$2(element, event, filter$2, handler);

const getDocument = () => SugarElement.fromDom(document);

const focus$1 = (element, preventScroll = false) => element.dom.focus({ preventScroll });
    const hasFocus$1 = (element) => {
        const root = getRootNode(element).dom;
        return element.dom === root.activeElement;
    };
    // Note: assuming that activeElement will always be a HTMLElement (maybe we should add a runtime check?)
    const active = (root = getDocument()) => Optional.from(root.dom.activeElement).map(SugarElement.fromDom);
    /**
     * Return the descendant element that has focus.
     * Use instead of SelectorFind.descendant(container, ':focus')
     *  because the :focus selector relies on keyboard focus.
     */
    const search = (element) => active(getRootNode(element))
        .filter((e) => element.dom.contains(e.dom));

const clone$3 = (original, isDeep) => SugarElement.fromDom(original.dom.cloneNode(isDeep));
    /** Shallow clone - just the tag, no children */
    const shallow = (original) => clone$3(original, false);
    /** Deep clone - everything copied including children */
    const deep = (original) => clone$3(original, true);
    /** Shallow clone, with a new tag */
    const shallowAs = (original, tag) => {
        const nu = SugarElement.fromTag(tag);
        const attributes = clone$4(original);
        setAll$1(nu, attributes);
        return nu;
    };
    /** Change the tag name, but keep all children */
    const mutate = (original, tag) => {
        const nu = shallowAs(original, tag);
        after$4(original, nu);
        const children = children$1(original);
        append(nu, children);
        remove$8(original);
        return nu;
    };

const fromHtml = (html, scope) => {
        const doc = scope || document;
        const div = doc.createElement('div');
        div.innerHTML = html;
        return children$1(SugarElement.fromDom(div));
    };
    const fromDom$1 = (nodes) => map$3(nodes, SugarElement.fromDom);

const get$8 = (element) => element.dom.innerHTML;
    const set$3 = (element, content) => {
        const owner = owner$1(element);
        const docDom = owner.dom;
        // FireFox has *terrible* performance when using innerHTML = x
        const fragment = SugarElement.fromDom(docDom.createDocumentFragment());
        const contentElements = fromHtml(content, docDom);
        append(fragment, contentElements);
        empty(element);
        append$1(element, fragment);
    };
    const getOuter = (element) => {
        const container = SugarElement.fromTag('div');
        const clone = SugarElement.fromDom(element.dom.cloneNode(true));
        append$1(container, clone);
        return get$8(container);
    };

// some elements, such as mathml, don't have style attributes
    // others, such as angular elements, have style attributes that aren't a CSSStyleDeclaration
    const isSupported = (dom) => dom.style !== undefined && isFunction(dom.style.getPropertyValue);

// Node.contains() is very, very, very good performance
    // http://jsperf.com/closest-vs-contains/5
    const inBody = (element) => {
        // Technically this is only required on IE, where contains() returns false for text nodes.
        // But it's cheap enough to run everywhere and Sugar doesn't have platform detection (yet).
        const dom = isText$c(element) ? element.dom.parentNode : element.dom;
        // use ownerDocument.body to ensure this works inside iframes.
        // Normally contains is bad because an element "contains" itself, but here we want that.
        if (dom === undefined || dom === null || dom.ownerDocument === null) {
            return false;
        }
        const doc = dom.ownerDocument;
        return getShadowRoot(SugarElement.fromDom(dom)).fold(() => doc.body.contains(dom), compose1(inBody, getShadowHost));
    };

const api$1 = Dimension('height', (element) => {
        // getBoundingClientRect gives better results than offsetHeight for tables with captions on Firefox
        const dom = element.dom;
        return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
    });
    const get$6 = (element) => api$1.get(element);

const r = (left, top) => {
        const translate = (x, y) => r(left + x, top + y);
        return {
            left,
            top,
            translate
        };
    };
    // tslint:disable-next-line:variable-name
    const SugarPosition = r;

// get scroll position (x,y) relative to document _doc (or global if not supplied)
    const get$5 = (_DOC) => {
        const doc = _DOC !== undefined ? _DOC.dom : document;
        // ASSUMPTION: This is for cross-browser support, body works for Safari & EDGE, and when we have an iframe body scroller
        const x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
        const y = doc.body.scrollTop || doc.documentElement.scrollTop;
        return SugarPosition(x, y);
    };
    // Scroll content to (x,y) relative to document _doc (or global if not supplied)
    const to = (x, y, _DOC) => {
        const doc = _DOC !== undefined ? _DOC.dom : document;
        const win = doc.defaultView;
        if (win) {
            win.scrollTo(x, y);
        }
    };
    // TBIO-4472 Safari 10 - Scrolling typeahead with keyboard scrolls page
    const intoView = (element, alignToTop) => {
        const isSafari = detect$1().browser.isSafari();
        // this method isn't in TypeScript
        if (isSafari && isFunction(element.dom.scrollIntoViewIfNeeded)) {
            element.dom.scrollIntoViewIfNeeded(false); // false=align to nearest edge
        }
        else {
            element.dom.scrollIntoView(alignToTop); // true=to top, false=to bottom
        }
    };

const fromElements = (elements, scope) => {
        const doc = scope || document;
        const fragment = doc.createDocumentFragment();
        each$e(elements, (element) => {
            fragment.appendChild(element.dom);
        });
        return SugarElement.fromDom(fragment);
    };

const api = NodeValue(isText$c, 'text');
    const get$4 = (element) => api.get(element);
    const getOption = (element) => api.getOption(element);
    const set$1 = (element, value) => api.set(element, value);

// Methods for handling attributes that contain a list of values <div foo="alpha beta theta">
 const read$4 = (element, attr) => {
 const value = get$9(element, attr);
 return value === undefined || value === '' ? [] : value.split(' ');
 };
 const add$4 = (element, attr, id) => {
 const old = read$4(element, attr);
 const nu = old.concat([id]);
 set$4(element, attr, nu.join(' '));
 return true;
 };
 const remove$6 = (element, attr, id) => {
 const nu = filter$5(read$4(element, attr), (v) => v !== id);
 if (nu.length > 0) {
 set$4(element, attr, nu.join(' '));
 }
 else {
 remove$9(element, attr);
 }
 return false;
 };

const ancestor$4 = (scope, selector, isRoot) => ancestor$5(scope, (e) => is$2(e, selector), isRoot);
    const descendant$1 = (scope, selector) => one(selector, scope);
    // Returns Some(closest ancestor element (sugared)) matching 'selector' up to isRoot, or None() otherwise
    const closest$4 = (scope, selector, isRoot) => {
        const is = (element, selector) => is$2(element, selector);
        return ClosestOrAncestor(is, ancestor$4, scope, selector, isRoot);
    };

// IE11 Can return undefined for a classList on elements such as math, so we make sure it's not undefined before attempting to use it.
    const supports = (element) => element.dom.classList !== undefined;
    const get$3 = (element) => read$4(element, 'class');
    const add$3 = (element, clazz) => add$4(element, 'class', clazz);
    const remove$5 = (element, clazz) => remove$6(element, 'class', clazz);
    const toggle$2 = (element, clazz) => {
        if (contains$2(get$3(element), clazz)) {
            return remove$5(element, clazz);
        }
        else {
            return add$3(element, clazz);
        }
    };

/*
     * ClassList is IE10 minimum:
     * https://developer.mozilla.org/en-US/docs/Web/API/Element.classList
     *
     * Note that IE doesn't support the second argument to toggle (at all).
     * If it did, the toggler could be better.
     */
    const add$2 = (element, clazz) => {
        if (supports(element)) {
            element.dom.classList.add(clazz);
        }
        else {
            add$3(element, clazz);
        }
    };
    const cleanClass = (element) => {
        const classList = supports(element) ? element.dom.classList : get$3(element);
        // classList is a "live list", so this is up to date already
        if (classList.length === 0) {
            // No more classes left, remove the class attribute as well
            remove$9(element, 'class');
        }
    };
    const remove$4 = (element, clazz) => {
        if (supports(element)) {
            const classList = element.dom.classList;
            classList.remove(clazz);
        }
        else {
            remove$5(element, clazz);
        }
        cleanClass(element);
    };
    const toggle$1 = (element, clazz) => {
        const result = supports(element) ? element.dom.classList.toggle(clazz) : toggle$2(element, clazz);
        cleanClass(element);
        return result;
    };
    const has = (element, clazz) => supports(element) && element.dom.classList.contains(clazz);

/*
     * ClassList is IE10 minimum:
     * https://developer.mozilla.org/en-US/docs/Web/API/Element.classList
     */
    const add$1 = (element, classes) => {
        each$e(classes, (x) => {
            add$2(element, x);
        });
    };
    const remove$3 = (element, classes) => {
        each$e(classes, (x) => {
            remove$4(element, x);
        });
    };

// For all of the following:
    //
    // jQuery does siblings of firstChild. IE9+ supports scope.dom.children (similar to Traverse.children but elements only).
    // Traverse should also do this (but probably not by default).
    //
    const ancestors = (scope, selector, isRoot) => 
    // It may surprise you to learn this is exactly what JQuery does
    // TODO: Avoid all this wrapping and unwrapping
    ancestors$1(scope, (e) => is$2(e, selector), isRoot);
    const descendants = (scope, selector) => all(selector, scope);

const ancestor$3 = (scope, predicate, isRoot) => ancestor$5(scope, predicate, isRoot).isSome();
    const sibling = (scope, predicate) => sibling$1(scope, predicate).isSome();
    const descendant = (scope, predicate) => descendant$2(scope, predicate).isSome();

const ancestor$2 = (element, target) => ancestor$3(element, curry(eq, target));

const ancestor$1 = (scope, selector, isRoot) => ancestor$4(scope, selector, isRoot).isSome();
    const closest$2 = (scope, selector, isRoot) => closest$4(scope, selector, isRoot).isSome();

const isTextNodeWithCursorPosition = (el) => getOption(el).filter((text) => 
    // For the purposes of finding cursor positions only allow text nodes with content,
    // but trim removes &nbsp; and that's allowed
    text.trim().length !== 0 || text.indexOf(nbsp) > -1).isSome();
    const isContentEditableFalse$b = (elem) => isHTMLElement$1(elem) && (get$9(elem, 'contenteditable') === 'false');
    const elementsWithCursorPosition = ['img', 'br'];
    const isCursorPosition = (elem) => {
        const hasCursorPosition = isTextNodeWithCursorPosition(elem);
        return hasCursorPosition || contains$2(elementsWithCursorPosition, name(elem)) || isContentEditableFalse$b(elem);
    };

const first = (element) => descendant$2(element, isCursorPosition);

const create$c = (start, soffset, finish, foffset) => ({
        start,
        soffset,
        finish,
        foffset
    });
    // tslint:disable-next-line:variable-name
    const SimRange = {
        create: create$c
    };

// Consider adding a type for "element"
    const adt$1 = Adt.generate([
        { domRange: ['rng'] },
        { relative: ['startSitu', 'finishSitu'] },
        { exact: ['start', 'soffset', 'finish', 'foffset'] }
    ]);
    const exactFromRange = (simRange) => adt$1.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
    const getStart$1 = (selection) => selection.match({
        domRange: (rng) => SugarElement.fromDom(rng.startContainer),
        relative: (startSitu, _finishSitu) => Situ.getStart(startSitu),
        exact: (start, _soffset, _finish, _foffset) => start
    });
    const domRange = adt$1.domRange;
    const relative = adt$1.relative;
    const exact = adt$1.exact;
    const getWin = (selection) => {
        const start = getStart$1(selection);
        return defaultView(start);
    };
    // This is out of place but it's API so I can't remove it
    const range = SimRange.create;
    // tslint:disable-next-line:variable-name
    const SimSelection = {
        domRange,
        relative,
        exact,
        exactFromRange,
        getWin,
        range
    };

const toNative = (selection) => {
        const win = SimSelection.getWin(selection).dom;
        const getDomRange = (start, soffset, finish, foffset) => exactToNative(win, start, soffset, finish, foffset);
        const filtered = preprocess(selection);
        return diagnose(win, filtered).match({
            ltr: getDomRange,
            rtl: getDomRange
        });
    };
    const getAtPoint = (win, x, y) => fromPoint$1(win, x, y);

/**
     * TreeWalker class enables you to walk the DOM in a linear manner.
     *
     * @class tinymce.dom.TreeWalker
     * @example
     * const walker = new tinymce.dom.TreeWalker(startNode);
     *
     * do {
     *   console.log(walker.current());
     * } while (walker.next());
     */
    class DomTreeWalker {
        rootNode;
        node;
        constructor(startNode, rootNode) {
            this.node = startNode;
            this.rootNode = rootNode;
            // This is a bit hacky but needed to ensure the 'this' variable
            // always references the instance and not the caller scope
            this.current = this.current.bind(this);
            this.next = this.next.bind(this);
            this.prev = this.prev.bind(this);
            this.prev2 = this.prev2.bind(this);
        }
        /**
         * Returns the current node.
         *
         * @method current
         * @return {Node/undefined} Current node where the walker is, or undefined if the walker has reached the end.
         */
        current() {
            return this.node;
        }
        /**
         * Walks to the next node in tree.
         *
         * @method next
         * @return {Node/undefined} Current node where the walker is after moving to the next node, or undefined if the walker has reached the end.
         */
        next(shallow) {
            this.node = this.findSibling(this.node, 'firstChild', 'nextSibling', shallow);
            return this.node;
        }
        /**
         * Walks to the previous node in tree.
         *
         * @method prev
         * @return {Node/undefined} Current node where the walker is after moving to the previous node, or undefined if the walker has reached the end.
         */
        prev(shallow) {
            this.node = this.findSibling(this.node, 'lastChild', 'previousSibling', shallow);
            return this.node;
        }
        prev2(shallow) {
            this.node = this.findPreviousNode(this.node, shallow);
            return this.node;
        }
        findSibling(node, startName, siblingName, shallow) {
            if (node) {
                // Walk into nodes if it has a start
                if (!shallow && node[startName]) {
                    return node[startName];
                }
                // Return the sibling if it has one
                if (node !== this.rootNode) {
                    let sibling = node[siblingName];
                    if (sibling) {
                        return sibling;
                    }
                    // Walk up the parents to look for siblings
                    for (let parent = node.parentNode; parent && parent !== this.rootNode; parent = parent.parentNode) {
                        sibling = parent[siblingName];
                        if (sibling) {
                            return sibling;
                        }
                    }
                }
            }
            return undefined;
        }
        findPreviousNode(node, shallow) {
            if (node) {
                const sibling = node.previousSibling;
                if (this.rootNode && sibling === this.rootNode) {
                    return;
                }
                if (sibling) {
                    if (!shallow) {
                        // Walk down to the most distant child
                        for (let child = sibling.lastChild; child; child = child.lastChild) {
                            if (!child.lastChild) {
                                return child;
                            }
                        }
                    }
                    return sibling;
                }
                const parent = node.parentNode;
                if (parent && parent !== this.rootNode) {
                    return parent;
                }
            }
            return undefined;
        }
    }

/**
     * This function is exported for testing purposes only - please use StyleSheetLoader.instance in production code.
     */
    const create$b = () => {
        const map = new WeakMap();
        const forElement = (referenceElement, settings) => {
            const root = getRootNode(referenceElement);
            const rootDom = root.dom;
            return Optional.from(map.get(rootDom)).getOrThunk(() => {
                const sl = StyleSheetLoader(rootDom, settings);
                map.set(rootDom, sl);
                return sl;
            });
        };
        return {
            forElement
        };
    };
    const instance = create$b();

/**
 * Entity encoder class.
 *
 * @class tinymce.html.Entities
 * @static
 * @version 3.4
 */
 const makeMap$3 = Tools.makeMap;
 const attrsCharsRegExp = /[&<>\"\u0060\u007E-\uD7FF\uE000-\uFFEF]|[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
 const textCharsRegExp = /[<>&\u007E-\uD7FF\uE000-\uFFEF]|[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
 const rawCharsRegExp = /[<>&\"\']/g;
 const entityRegExp = /&#([a-z0-9]+);?|&([a-z0-9]+);/gi;
 const asciiMap = {
 128: '\u20AC', 130: '\u201A', 131: '\u0192', 132: '\u201E', 133: '\u2026', 134: '\u2020',
 135: '\u2021', 136: '\u02C6', 137: '\u2030', 138: '\u0160', 139: '\u2039', 140: '\u0152',
 142: '\u017D', 145: '\u2018', 146: '\u2019', 147: '\u201C', 148: '\u201D', 149: '\u2022',
 150: '\u2013', 151: '\u2014', 152: '\u02DC', 153: '\u2122', 154: '\u0161', 155: '\u203A',
 156: '\u0153', 158: '\u017E', 159: '\u0178'
 };
 // Raw entities
 const baseEntities = {
 '\"': '&quot;', // Needs to be escaped since the YUI compressor would otherwise break the code
 '\'': '&#39;',
 '<': '&lt;',
 '>': '&gt;',
 '&': '&amp;',
 '\u0060': '&#96;'
 };
 // Reverse lookup table for raw entities
 const reverseEntities = {
 '&lt;': '<',
 '&gt;': '>',
 '&amp;': '&',
 '&quot;': '"',
 '&apos;': `'`
 };
 // Decodes text by using the browser
 const nativeDecode = (text) => {
 const elm = SugarElement.fromTag('div').dom;
 elm.innerHTML = text;
 return elm.textContent || elm.innerText || text;
 };
 // Build a two way lookup table for the entities
 const buildEntitiesLookup = (items, radix) => {
 const lookup = {};
 if (items) {
 const itemList = items.split(',');
 radix = radix || 10;
 // Build entities lookup table
 for (let i = 0; i < itemList.length; i += 2) {
 const chr = String.fromCharCode(parseInt(itemList[i], radix));
 // Only add non base entities
 if (!baseEntities[chr]) {
 const entity = '&' + itemList[i + 1] + ';';
 lookup[chr] = entity;
 lookup[entity] = chr;
 }
 }
 return lookup;
 }
 else {
 return undefined;
 }
 };
 // Unpack entities lookup where the numbers are in radix 32 to reduce the size
 const namedEntities = buildEntitiesLookup('50,nbsp,51,iexcl,52,cent,53,pound,54,curren,55,yen,56,brvbar,57,sect,58,uml,59,copy,' +
 '5a,ordf,5b,laquo,5c,not,5d,shy,5e,reg,5f,macr,5g,deg,5h,plusmn,5i,sup2,5j,sup3,5k,acute,' +
 '5l,micro,5m,para,5n,middot,5o,cedil,5p,sup1,5q,ordm,5r,raquo,5s,frac14,5t,frac12,5u,frac34,' +
 '5v,iquest,60,Agrave,61,Aacute,62,Acirc,63,Atilde,64,Auml,65,Aring,66,AElig,67,Ccedil,' +
 '68,Egrave,69,Eacute,6a,Ecirc,6b,Euml,6c,Igrave,6d,Iacute,6e,Icirc,6f,Iuml,6g,ETH,6h,Ntilde,' +
 '6i,Ograve,6j,Oacute,6k,Ocirc,6l,Otilde,6m,Ouml,6n,times,6o,Oslash,6p,Ugrave,6q,Uacute,' +
 '6r,Ucirc,6s,Uuml,6t,Yacute,6u,THORN,6v,szlig,70,agrave,71,aacute,72,acirc,73,atilde,74,auml,' +
 '75,aring,76,aelig,77,ccedil,78,egrave,79,eacute,7a,ecirc,7b,euml,7c,igrave,7d,iacute,7e,icirc,' +
 '7f,iuml,7g,eth,7h,ntilde,7i,ograve,7j,oacute,7k,ocirc,7l,otilde,7m,ouml,7n,divide,7o,oslash,' +
 '7p,ugrave,7q,uacute,7r,ucirc,7s,uuml,7t,yacute,7u,thorn,7v,yuml,ci,fnof,sh,Alpha,si,Beta,' +
 'sj,Gamma,sk,Delta,sl,Epsilon,sm,Zeta,sn,Eta,so,Theta,sp,Iota,sq,Kappa,sr,Lambda,ss,Mu,' +
 'st,Nu,su,Xi,sv,Omicron,t0,Pi,t1,Rho,t3,Sigma,t4,Tau,t5,Upsilon,t6,Phi,t7,Chi,t8,Psi,' +
 't9,Omega,th,alpha,ti,beta,tj,gamma,tk,delta,tl,epsilon,tm,zeta,tn,eta,to,theta,tp,iota,' +
 'tq,kappa,tr,lambda,ts,mu,tt,nu,tu,xi,tv,omicron,u0,pi,u1,rho,u2,sigmaf,u3,sigma,u4,tau,' +
 'u5,upsilon,u6,phi,u7,chi,u8,psi,u9,omega,uh,thetasym,ui,upsih,um,piv,812,bull,816,hellip,' +
 '81i,prime,81j,Prime,81u,oline,824,frasl,88o,weierp,88h,image,88s,real,892,trade,89l,alefsym,' +
 '8cg,larr,8ch,uarr,8ci,rarr,8cj,darr,8ck,harr,8dl,crarr,8eg,lArr,8eh,uArr,8ei,rArr,8ej,dArr,' +
 '8ek,hArr,8g0,forall,8g2,part,8g3,exist,8g5,empty,8g7,nabla,8g8,isin,8g9,notin,8gb,ni,8gf,prod,' +
 '8gh,sum,8gi,minus,8gn,lowast,8gq,radic,8gt,prop,8gu,infin,8h0,ang,8h7,and,8h8,or,8h9,cap,8ha,cup,' +
 '8hb,int,8hk,there4,8hs,sim,8i5,cong,8i8,asymp,8j0,ne,8j1,equiv,8j4,le,8j5,ge,8k2,sub,8k3,sup,8k4,' +
 'nsub,8k6,sube,8k7,supe,8kl,oplus,8kn,otimes,8l5,perp,8m5,sdot,8o8,lceil,8o9,rceil,8oa,lfloor,8ob,' +
 'rfloor,8p9,lang,8pa,rang,9ea,loz,9j0,spades,9j3,clubs,9j5,hearts,9j6,diams,ai,OElig,aj,oelig,b0,' +
 'Scaron,b1,scaron,bo,Yuml,m6,circ,ms,tilde,802,ensp,803,emsp,809,thinsp,80c,zwnj,80d,zwj,80e,lrm,' +
 '80f,rlm,80j,ndash,80k,mdash,80o,lsquo,80p,rsquo,80q,sbquo,80s,ldquo,80t,rdquo,80u,bdquo,810,dagger,' +
 '811,Dagger,81g,permil,81p,lsaquo,81q,rsaquo,85c,euro', 32);
 /**
 * Encodes the specified string using raw entities. This means only the required XML base entities will be encoded.
 *
 * @method encodeRaw
 * @param {String} text Text to encode.
 * @param {Boolean} attr Optional flag to specify if the text is attribute contents.
 * @return {String} Entity encoded text.
 */
 const encodeRaw = (text, attr) => text.replace(attr ? attrsCharsRegExp : textCharsRegExp, (chr) => {
 return baseEntities[chr] || chr;
 });
 /**
 * Encoded the specified text with both the attributes and text entities. This function will produce larger text contents
 * since it doesn't know if the context is within an attribute or text node. This was added for compatibility
 * and is exposed as the `DOMUtils.encode` function.
 *
 * @method encodeAllRaw
 * @param {String} text Text to encode.
 * @return {String} Entity encoded text.
 */
 const encodeAllRaw = (text) => ('' + text).replace(rawCharsRegExp, (chr) => {
 return baseEntities[chr] || chr;
 });
 /**
 * Encodes the specified string using numeric entities. The core entities will be
 * encoded as named ones but all non lower ascii characters will be encoded into numeric entities.
 *
 * @method encodeNumeric
 * @param {String} text Text to encode.
 * @param {Boolean} attr Optional flag to specify if the text is attribute contents.
 * @return {String} Entity encoded text.
 */
 const encodeNumeric = (text, attr) => text.replace(attr ? attrsCharsRegExp : textCharsRegExp, (chr) => {
 // Multi byte sequence convert it to a single entity
 if (chr.length > 1) {
 return '&#' + (((chr.charCodeAt(0) - 0xD800) * 0x400) + (chr.charCodeAt(1) - 0xDC00) + 0x10000) + ';';
 }
 return baseEntities[chr] || '&#' + chr.charCodeAt(0) + ';';
 });
 /**
 * Encodes the specified string using named entities. The core entities will be encoded
 * as named ones but all non lower ascii characters will be encoded into named entities.
 *
 * @method encodeNamed
 * @param {String} text Text to encode.
 * @param {Boolean} attr Optional flag to specify if the text is attribute contents.
 * @param {Object} entities Optional parameter with entities to use.
 * @return {String} Entity encoded text.
 */
 const encodeNamed = (text, attr, entities) => {
 const resolveEntities = entities || namedEntities;
 return text.replace(attr ? attrsCharsRegExp : textCharsRegExp, (chr) => {
 return baseEntities[chr] || resolveEntities[chr] || chr;
 });
 };
 /**
 * Returns an encode function based on the name(s) and it's optional entities.
 *
 * @method getEncodeFunc
 * @param {String} name Comma separated list of encoders for example named,numeric.
 * @param {String} entities Optional parameter with entities to use instead of the built in set.
 * @return {Function} Encode function to be used.
 */
 const getEncodeFunc = (name, entities) => {
 const entitiesMap = buildEntitiesLookup(entities) || namedEntities;
 const encodeNamedAndNumeric = (text, attr) => text.replace(attr ? attrsCharsRegExp : textCharsRegExp, (chr) => {
 if (baseEntities[chr] !== undefined) {
 return baseEntities[chr];
 }
 if (entitiesMap[chr] !== undefined) {
 return entitiesMap[chr];
 }
 // Convert multi-byte sequences to a single entity.
 if (chr.length > 1) {
 return '&#' + (((chr.charCodeAt(0) - 0xD800) * 0x400) + (chr.charCodeAt(1) - 0xDC00) + 0x10000) + ';';
 }
 return '&#' + chr.charCodeAt(0) + ';';
 });
 const encodeCustomNamed = (text, attr) => {
 return encodeNamed(text, attr, entitiesMap);
 };
 // Replace + with , to be compatible with previous TinyMCE versions
 const nameMap = makeMap$3(name.replace(/\+/g, ','));
 // Named and numeric encoder
 if (nameMap.named && nameMap.numeric) {
 return encodeNamedAndNumeric;
 }
 // Named encoder
 if (nameMap.named) {
 // Custom names
 if (entities) {
 return encodeCustomNamed;
 }
 return encodeNamed;
 }
 // Numeric
 if (nameMap.numeric) {
 return encodeNumeric;
 }
 // Raw encoder
 return encodeRaw;
 };
 /**
 * Decodes the specified string, this will replace entities with raw UTF characters.
 *
 * @method decode
 * @param {String} text Text to entity decode.
 * @return {String} Entity decoded string.
 */
 const decode = (text) => text.replace(entityRegExp, (all, numeric) => {
 if (numeric) {
 if (numeric.charAt(0).toLowerCase() === 'x') {
 numeric = parseInt(numeric.substr(1), 16);
 }
 else {
 numeric = parseInt(numeric, 10);
 }
 // Support upper UTF
 if (numeric > 0xFFFF) {
 numeric -= 0x10000;
 // eslint-disable-next-line no-bitwise
 return String.fromCharCode(0xD800 + (numeric >> 10), 0xDC00 + (numeric & 0x3FF));
 }
 return asciiMap[numeric] || String.fromCharCode(numeric);
 }
 return reverseEntities[all] || namedEntities[all] || nativeDecode(all);
 });
 const Entities = {
 encodeRaw,
 encodeAllRaw,
 encodeNumeric,
 encodeNamed,
 getEncodeFunc,
 decode
 };

const getGlobalAttributeSet = (type) => {
        return Object.freeze([
            // Present on all schema types
            'id',
            'accesskey',
            'class',
            'dir',
            'lang',
            'style',
            'tabindex',
            'title',
            'role',
            // html5 and html5-strict extra attributes
            ...(type !== 'html4' ? ['contenteditable', 'contextmenu', 'draggable', 'dropzone', 'hidden', 'spellcheck', 'translate', 'itemprop', 'itemscope', 'itemtype'] : []),
            // html4 and html5 extra attributes
            ...(type !== 'html5-strict' ? ['xml:lang'] : [])
        ]);
    };

// Missing elements in `phrasing` compared to HTML5 spec at 2024-01-30 (timestamped since spec is constantly evolving)
    //  area - required to be inside a map element so we should not add it to all elements.
    //  link - required to be in the body so we should not add it to all elements.
    //  math - currently not supported.
    //  meta - Only allowed if the `itemprop` attribute is set so very special.
    //  slot - We only want these to be accepted in registered custom components.
    // Extra element in `phrasing`: command keygen
    //
    // Missing elements in `flow` compared to HTML5 spec at 2034-01-30 (timestamped since the spec is constantly evolving)
    //  search - Can be both in a block and inline position but is not a transparent element. So not supported at this time.
    const getElementSetsAsStrings = (type) => {
        let blockContent;
        let phrasingContent;
        // Block content elements
        blockContent =
            'address blockquote div dl fieldset form h1 h2 h3 h4 h5 h6 hr menu ol p pre table ul';
        // Phrasing content elements from the HTML5 spec (inline)
        phrasingContent =
            'a abbr b bdo br button cite code del dfn em embed i iframe img input ins kbd ' +
                'label map noscript object q s samp script select small span strong sub sup ' +
                'textarea u var #text #comment';
        // Add HTML5 items to globalAttributes, blockContent, phrasingContent
        if (type !== 'html4') {
            const transparentContent = 'a ins del canvas map';
            blockContent += ' article aside details dialog figure main header footer hgroup section nav ' + transparentContent;
            phrasingContent += ' audio canvas command data datalist mark meter output picture ' +
                'progress template time wbr video ruby bdi keygen svg';
        }
        // Add HTML4 elements unless it's html5-strict
        if (type !== 'html5-strict') {
            const html4PhrasingContent = 'acronym applet basefont big font strike tt';
            phrasingContent = [phrasingContent, html4PhrasingContent].join(' ');
            const html4BlockContent = 'center dir isindex noframes';
            blockContent = [blockContent, html4BlockContent].join(' ');
        }
        // Flow content elements from the HTML5 spec (block+inline)
        const flowContent = [blockContent, phrasingContent].join(' ');
        return { blockContent, phrasingContent, flowContent };
    };
    const getElementSets = (type) => {
        const { blockContent, phrasingContent, flowContent } = getElementSetsAsStrings(type);
        const toArr = (value) => {
            return Object.freeze(value.split(' '));
        };
        return Object.freeze({
            blockContent: toArr(blockContent),
            phrasingContent: toArr(phrasingContent),
            flowContent: toArr(flowContent)
        });
    };

/**
 * Schema validator class.
 *
 * @class tinymce.html.Schema
 * @version 3.4
 * @example
 * if (tinymce.activeEditor.schema.isValidChild('p', 'span')) {
 * alert('span is valid child of p.');
 * }
 *
 * if (tinymce.activeEditor.schema.getElementRule('p')) {
 * alert('P is a valid element.');
 * }
 */
 const mapCache = {};
 const makeMap$2 = Tools.makeMap, each$b = Tools.each, extend$2 = Tools.extend, explode$2 = Tools.explode;
 const createMap = (defaultValue, extendWith = {}) => {
 const value = makeMap$2(defaultValue, ' ', makeMap$2(defaultValue.toUpperCase(), ' '));
 return extend$2(value, extendWith);
 };
 // A curated list using the textBlockElements map and parts of the blockElements map from the schema
 // TODO: TINY-8728 Investigate if the extras can be added directly to the default text block elements
 const getTextRootBlockElements = (schema) => createMap('td th li dt dd figcaption caption details summary', schema.getTextBlockElements());
 const compileElementMap = (value, mode) => {
 if (value) {
 const styles = {};
 if (isString(value)) {
 value = {
 '*': value
 };
 }
 // Convert styles into a rule list
 each$b(value, (value, key) => {
 styles[key] = styles[key.toUpperCase()] = mode === 'map' ? makeMap$2(value, /[, ]/) : explode$2(value, /[, ]/);
 });
 return styles;
 }
 else {
 return undefined;
 }
 };
 const Schema = (settings = {}) => {
 const elements = {};
 const children = {};
 let patternElements = [];
 const customElementsMap = {};
 const specialElements = {};
 const componentUrls = {};
 // Creates an lookup table map object for the specified option or the default value
 const createLookupTable = (option, defaultValue, extendWith) => {
 const value = settings[option];
 if (!value) {
 // Get cached default map or make it if needed
 let newValue = mapCache[option];
 if (!newValue) {
 newValue = createMap(defaultValue, extendWith);
 mapCache[option] = newValue;
 }
 return newValue;
 }
 else {
 // Create custom map
 return makeMap$2(value, /[, ]/, makeMap$2(value.toUpperCase(), /[, ]/));
 }
 };
 const schemaType = settings.schema ?? 'html5';
 const schemaItems = makeSchema(schemaType);
 // Allow all elements and attributes if verify_html is set to false
 if (settings.verify_html === false) {
 settings.valid_elements = '*[*]';
 }
 const validStyles = compileElementMap(settings.valid_styles);
 const invalidStyles = compileElementMap(settings.invalid_styles, 'map');
 const validClasses = compileElementMap(settings.valid_classes, 'map');
 // Setup map objects
 const whitespaceElementsMap = createLookupTable('whitespace_elements', 'pre script noscript style textarea video audio iframe object code');
 const selfClosingElementsMap = createLookupTable('self_closing_elements', 'colgroup dd dt li option p td tfoot th thead tr');
 const voidElementsMap = createLookupTable('void_elements', 'area base basefont br col frame hr img input isindex link ' +
 'meta param embed source wbr track');
 const boolAttrMap = createLookupTable('boolean_attributes', 'checked compact declare defer disabled ismap multiple nohref noresize ' +
 'noshade nowrap readonly selected autoplay loop controls allowfullscreen');
 const nonEmptyOrMoveCaretBeforeOnEnter = 'td th iframe video audio object script code';
 const nonEmptyElementsMap = createLookupTable('non_empty_elements', nonEmptyOrMoveCaretBeforeOnEnter + ' pre svg textarea summary', voidElementsMap);
 const moveCaretBeforeOnEnterElementsMap = createLookupTable('move_caret_before_on_enter_elements', nonEmptyOrMoveCaretBeforeOnEnter + ' table', voidElementsMap);
 const headings = 'h1 h2 h3 h4 h5 h6';
 const textBlockElementsMap = createLookupTable('text_block_elements', headings + ' p div address pre form ' +
 'blockquote center dir fieldset header footer article section hgroup aside main nav figure');
 const blockElementsMap = createLookupTable('block_elements', 'hr table tbody thead tfoot ' +
 'th tr td li ol ul caption dl dt dd noscript menu isindex option ' +
 'datalist select optgroup figcaption details summary html body multicol listing colgroup col', textBlockElementsMap);
 const textInlineElementsMap = createLookupTable('text_inline_elements', 'span strong b em i font s strike u var cite ' +
 'dfn code mark q sup sub samp');
 const transparentElementsMap = createLookupTable('transparent_elements', 'a ins del canvas map');
 const wrapBlockElementsMap = createLookupTable('wrap_block_elements', 'pre ' + headings);
 // See https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
 each$b(('script noscript iframe noframes noembed title style textarea xmp plaintext').split(' '), (name) => {
 specialElements[name] = new RegExp('<\/' + name + '[^>]*>', 'gi');
 });
 // Parses the specified valid_elements string and adds to the current rules
 const addValidElements = (validElements) => {
 const globalElement = Optional.from(elements['@']);
 const hasPatternsRegExp = /[*?+]/;
 each$e(parseValidElementsRules(globalElement, validElements ?? ''), ({ name, element, aliasName }) => {
 if (aliasName) {
 elements[aliasName] = element;
 }
 // Add pattern or exact element
 if (hasPatternsRegExp.test(name)) {
 const patternElement = element;
 patternElement.pattern = patternToRegExp(name);
 patternElements.push(patternElement);
 }
 else {
 elements[name] = element;
 }
 });
 };
 const setValidElements = (validElements) => {
 // Clear any existing rules. Note that since `elements` is exposed we can't
 // overwrite it, so instead we delete all the properties
 patternElements = [];
 each$e(keys(elements), (name) => {
 delete elements[name];
 });
 addValidElements(validElements);
 };
 const addCustomElement = (name, spec) => {
 // Flush cached items since we are altering the default maps
 delete mapCache.text_block_elements;
 delete mapCache.block_elements;
 const inline = spec.extends ? !isBlock(spec.extends) : false;
 const cloneName = spec.extends;
 children[name] = cloneName ? children[cloneName] : {};
 customElementsMap[name] = cloneName ?? name;
 // Treat all custom elements as being non-empty by default
 nonEmptyElementsMap[name.toUpperCase()] = {};
 nonEmptyElementsMap[name] = {};
 // If it's not marked as inline then add it to valid block elements
 if (!inline) {
 blockElementsMap[name.toUpperCase()] = {};
 blockElementsMap[name] = {};
 }
 // Add elements clone if needed
 if (cloneName && !elements[name] && elements[cloneName]) {
 const customRule = deepCloneElementRule(elements[cloneName]);
 delete customRule.removeEmptyAttrs;
 delete customRule.removeEmpty;
 elements[name] = customRule;
 }
 else {
 elements[name] = { attributesOrder: [], attributes: {} };
 }
 // Add custom attributes
 if (isArray$1(spec.attributes)) {
 const processAttrName = (name) => {
 customRule.attributesOrder.push(name);
 customRule.attributes[name] = {};
 };
 const customRule = elements[name] ?? {};
 delete customRule.attributesDefault;
 delete customRule.attributesForced;
 delete customRule.attributePatterns;
 delete customRule.attributesRequired;
 customRule.attributesOrder = [];
 customRule.attributes = {};
 each$e(spec.attributes, (attrName) => {
 const globalAttrs = getGlobalAttributeSet(schemaType);
 parseValidChild(attrName).each(({ preset, name }) => {
 if (preset) {
 if (name === 'global') {
 each$e(globalAttrs, processAttrName);
 }
 }
 else {
 processAttrName(name);
 }
 });
 });
 elements[name] = customRule;
 }
 // Add custom pad empty rule
 if (isBoolean(spec.padEmpty)) {
 const customRule = elements[name] ?? {};
 customRule.paddEmpty = spec.padEmpty;
 elements[name] = customRule;
 }
 // Add custom children
 if (isArray$1(spec.children)) {
 const customElementChildren = {};
 const processNodeName = (name) => {
 customElementChildren[name] = {};
 };
 const processPreset = (name) => {
 getElementsPreset(schemaType, name).each((names) => {
 each$e(names, processNodeName);
 });
 };
 each$e(spec.children, (child) => {
 parseValidChild(child).each(({ preset, name }) => {
 if (preset) {
 processPreset(name);
 }
 else {
 processNodeName(name);
 }
 });
 });
 children[name] = customElementChildren;
 }
 // Add custom elements at extends positions
 if (cloneName) {
 each$d(children, (element, elmName) => {
 if (element[cloneName]) {
 children[elmName] = element = extend$2({}, children[elmName]);
 element[name] = element[cloneName];
 }
 });
 }
 };
 const addCustomElementsFromString = (customElements) => {
 each$e(parseCustomElementsRules(customElements ?? ''), ({ name, cloneName }) => {
 addCustomElement(name, { extends: cloneName });
 });
 };
 const addComponentUrl = (elementName, componentUrl) => {
 componentUrls[elementName] = componentUrl;
 };
 const addCustomElements = (customElements) => {
 if (isObject(customElements)) {
 each$d(customElements, (spec, name) => {
 const componentUrl = spec.componentUrl;
 if (isString(componentUrl)) {
 addComponentUrl(name, componentUrl);
 }
 addCustomElement(name, spec);
 });
 }
 else if (isString(customElements)) {
 addCustomElementsFromString(customElements);
 }
 };
 // Adds valid children to the schema object
 const addValidChildren = (validChildren) => {
 each$e(parseValidChildrenRules(validChildren ?? ''), ({ operation, name, validChildren }) => {
 const parent = operation === 'replace' ? { '#comment': {} } : children[name];
 const processNodeName = (name) => {
 if (operation === 'remove') {
 delete parent[name];
 }
 else {
 parent[name] = {};
 }
 };
 const processPreset = (name) => {
 getElementsPreset(schemaType, name).each((names) => {
 each$e(names, processNodeName);
 });
 };
 each$e(validChildren, ({ preset, name }) => {
 if (preset) {
 processPreset(name);
 }
 else {
 processNodeName(name);
 }
 });
 children[name] = parent;
 });
 };
 const getElementRule = (name) => {
 const element = elements[name];
 // Exact match found
 if (element) {
 return element;
 }
 // No exact match then try the patterns
 let i = patternElements.length;
 while (i--) {
 const patternElement = patternElements[i];
 if (patternElement.pattern.test(name)) {
 return patternElement;
 }
 }
 return undefined;
 };
 const setup = () => {
 if (!settings.valid_elements) {
 // No valid elements defined then clone the elements from the schema spec
 each$b(schemaItems, (element, name) => {
 elements[name] = {
 attributes: element.attributes,
 attributesOrder: element.attributesOrder
 };
 children[name] = element.children;
 });
 // Prefer strong/em over b/i
 each$b(split$1('strong/b em/i'), (item) => {
 const items = split$1(item, '/');
 elements[items[1]].outputName = items[0];
 });
 // Add default alt attribute for images, removed since alt="" is treated as presentational.
 // elements.img.attributesDefault = [{name: 'alt', value: ''}];
 // By default,
 // - padd the text inline element if it is empty and also a child of an empty root block
 // - in all other cases, remove the text inline element if it is empty
 each$b(textInlineElementsMap, (_val, name) => {
 if (elements[name]) {
 if (settings.padd_empty_block_inline_children) {
 elements[name].paddInEmptyBlock = true;
 }
 elements[name].removeEmpty = true;
 }
 });
 // Remove these if they are empty by default
 each$b(split$1('ol ul blockquote a table tbody'), (name) => {
 if (elements[name]) {
 elements[name].removeEmpty = true;
 }
 });
 // Padd these by default
 each$b(split$1('p h1 h2 h3 h4 h5 h6 th td pre div address caption li summary'), (name) => {
 if (elements[name]) {
 elements[name].paddEmpty = true;
 }
 });
 // Remove these if they have no attributes
 each$b(split$1('span'), (name) => {
 elements[name].removeEmptyAttrs = true;
 });
 // Remove these by default
 // TODO: Reenable in 4.1
 /* each(split('script style'), function(name) {
 delete elements[name];
 });*/
 }
 else {
 setValidElements(settings.valid_elements);
 each$b(schemaItems, (element, name) => {
 children[name] = element.children;
 });
 }
 // Opt in is done with options like `extended_valid_elements`
 delete elements.svg;
 addCustomElements(settings.custom_elements);
 addValidChildren(settings.valid_children);
 addValidElements(settings.extended_valid_elements);
 // Todo: Remove this when we fix list handling to be valid
 addValidChildren('+ol[ul|ol],+ul[ul|ol]');
 // Some elements are not valid by themselves - require parents
 each$b({
 dd: 'dl',
 dt: 'dl',
 li: 'ul ol',
 td: 'tr',
 th: 'tr',
 tr: 'tbody thead tfoot',
 tbody: 'table',
 thead: 'table',
 tfoot: 'table',
 legend: 'fieldset',
 area: 'map',
 param: 'video audio object'
 }, (parents, item) => {
 if (elements[item]) {
 elements[item].parentsRequired = split$1(parents);
 }
 });
 // Delete invalid elements
 if (settings.invalid_elements) {
 each$b(explode$2(settings.invalid_elements), (item) => {
 if (elements[item]) {
 delete elements[item];
 }
 });
 }
 // If the user didn't allow span only allow internal spans
 if (!getElementRule('span')) {
 addValidElements('span[!data-mce-type|*]');
 }
 };
 /**
 * Name/value map object with valid parents and children to those parents.
 *
 * @field children
 * @type Object
 * @example
 * children = {
 * div: { p:{}, h1:{} }
 * };
 */
 /**
 * Name/value map object with valid styles for each element.
 *
 * @method getValidStyles
 * @type Object
 */
 const getValidStyles = constant(validStyles);
 /**
 * Name/value map object with valid styles for each element.
 *
 * @method getInvalidStyles
 * @type Object
 */
 const getInvalidStyles = constant(invalidStyles);
 /**
 * Name/value map object with valid classes for each element.
 *
 * @method getValidClasses
 * @type Object
 */
 const getValidClasses = constant(validClasses);
 /**
 * Returns a map with boolean attributes.
 *
 * @method getBoolAttrs
 * @return {Object} Name/value lookup map for boolean attributes.
 */
 const getBoolAttrs = constant(boolAttrMap);
 /**
 * Returns a map with block elements.
 *
 * @method getBlockElements
 * @return {Object} Name/value lookup map for block elements.
 */
 const getBlockElements = constant(blockElementsMap);
 /**
 * Returns a map with text block elements. For example: <code>&#60;p&#62;</code>, <code>&#60;h1&#62;</code> to <code>&#60;h6&#62;</code>, <code>&#60;div&#62;</code> or <code>&#60;address&#62;</code>.
 *
 * @method getTextBlockElements
 * @return {Object} Name/value lookup map for block elements.
 */
 const getTextBlockElements = constant(textBlockElementsMap);
 /**
 * Returns a map of inline text format nodes. For example: <code>&#60;strong&#62;</code>, <code>&#60;span&#62;</code> or <code>&#60;ins&#62;</code>.
 *
 * @method getTextInlineElements
 * @return {Object} Name/value lookup map for text format elements.
 */
 const getTextInlineElements = constant(textInlineElementsMap);
 /**
 * Returns a map with void elements. For example: <code>&#60;br&#62;</code> or <code>&#60;img&#62;</code>.
 *
 * @method getVoidElements
 * @return {Object} Name/value lookup map for void elements.
 */
 const getVoidElements = constant(Object.seal(voidElementsMap));
 /**
 * Returns a map with self closing tags. For example: <code>&#60;li&#62;</code>.
 *
 * @method getSelfClosingElements
 * @return {Object} Name/value lookup map for self closing tags elements.
 */
 const getSelfClosingElements = constant(selfClosingElementsMap);
 /**
 * Returns a map with elements that should be treated as contents regardless if it has text
 * content in them or not. For example: <code>&#60;td&#62;</code>, <code>&#60;video&#62;</code> or <code>&#60;img&#62;</code>.
 *
 * @method getNonEmptyElements
 * @return {Object} Name/value lookup map for non empty elements.
 */
 const getNonEmptyElements = constant(nonEmptyElementsMap);
 /**
 * Returns a map with elements that the caret should be moved in front of after enter is
 * pressed.
 *
 * @method getMoveCaretBeforeOnEnterElements
 * @return {Object} Name/value lookup map for elements to place the caret in front of.
 */
 const getMoveCaretBeforeOnEnterElements = constant(moveCaretBeforeOnEnterElementsMap);
 /**
 * Returns a map with elements where white space is to be preserved. For example: <code>&#60;pre&#62;</code> or <code>&#60;script&#62;</code>.
 *
 * @method getWhitespaceElements
 * @return {Object} Name/value lookup map for white space elements.
 */
 const getWhitespaceElements = constant(whitespaceElementsMap);
 /**
 * Returns a map with elements that should be treated as transparent.
 *
 * @method getTransparentElements
 * @return {Object} Name/value lookup map for special elements.
 */
 const getTransparentElements = constant(transparentElementsMap);
 const getWrapBlockElements = constant(wrapBlockElementsMap);
 /**
 * Returns a map with special elements. These are elements that needs to be parsed
 * in a special way such as script, style, textarea etc. The map object values
 * are regexps used to find the end of the element.
 *
 * @method getSpecialElements
 * @return {Object} Name/value lookup map for special elements.
 */
 const getSpecialElements = constant(Object.seal(specialElements));
 /**
 * Returns true/false if the specified element and it's child is valid or not
 * according to the schema.
 *
 * @method isValidChild
 * @param {String} name Element name to check for.
 * @param {String} child Element child to verify.
 * @return {Boolean} True/false if the element is a valid child of the specified parent.
 */
 const isValidChild = (name, child) => {
 const parent = children[name.toLowerCase()];
 return !!(parent && parent[child.toLowerCase()]);
 };
 /**
 * Returns true/false if the specified element name and optional attribute is
 * valid according to the schema.
 *
 * @method isValid
 * @param {String} name Name of element to check.
 * @param {String} attr Optional attribute name to check for.
 * @return {Boolean} True/false if the element and attribute is valid.
 */
 const isValid = (name, attr) => {
 const rule = getElementRule(name);
 // Check if it's a valid element
 if (rule) {
 if (attr) {
 // Check if attribute name exists
 if (rule.attributes[attr]) {
 return true;
 }
 // Check if attribute matches a regexp pattern
 const attrPatterns = rule.attributePatterns;
 if (attrPatterns) {
 let i = attrPatterns.length;
 while (i--) {
 if (attrPatterns[i].pattern.test(attr)) {
 return true;
 }
 }
 }
 }
 else {
 return true;
 }
 }
 // No match
 return false;
 };
 const isBlock = (name) => has$2(getBlockElements(), name);
 // Check if name starts with # to detect non-element node names like #text and #comment
 const isInline = (name) => !startsWith(name, '#') && isValid(name) && !isBlock(name);
 const isWrapper = (name) => has$2(getWrapBlockElements(), name) || isInline(name);
 /**
 * Returns true/false if the specified element is valid or not
 * according to the schema.
 *
 * @method getElementRule
 * @param {String} name Element name to check for.
 * @return {Object} Element object or undefined if the element isn't valid.
 */
 /**
 * Returns an map object of all custom elements.
 *
 * @method getCustomElements
 * @return {Object} Name/value map object of all custom elements.
 */
 const getCustomElements = constant(customElementsMap);
 /**
 * Parses a valid elements string and adds it to the schema. The valid elements
 * format is for example <code>element[attr=default|otherattr]</code>.
 * Existing rules will be replaced with the ones specified, so this extends the schema.
 *
 * @method addValidElements
 * @param {String} valid_elements String in the valid elements format to be parsed.
 */
 /**
 * Parses a valid elements string and sets it to the schema. The valid elements
 * format is for example <code>element[attr=default|otherattr]</code>.
 * Existing rules will be replaced with the ones specified, so this extends the schema.
 *
 * @method setValidElements
 * @param {String} valid_elements String in the valid elements format to be parsed.
 */
 /**
 * Adds custom non-HTML elements to the schema. For more information about adding custom elements see:
 * <a href="https://www.tiny.cloud/docs/tinymce/latest/content-filtering/#custom_elements">custom_elements</a>
 *
 * @method addCustomElements
 * @param {String/Object} custom_elements Comma separated list or record of custom elements to add.
 */
 /**
 * Parses a valid children string and adds them to the schema structure. The valid children
 * format is for example <code>element[child1|child2]</code>.
 *
 * @method addValidChildren
 * @param {String} valid_children Valid children elements string to parse
 */
 /**
 * Returns an object of all custom elements that have component URLs.
 *
 * @method getComponentUrls
 * @return {Object} Object with where key is the component and the value is the url for that component.
 */
 const getComponentUrls = constant(componentUrls);
 setup();
 return {
 type: schemaType,
 children,
 elements,
 getValidStyles,
 getValidClasses,
 getBlockElements,
 getInvalidStyles,
 getVoidElements,
 getTextBlockElements,
 getTextInlineElements,
 getBoolAttrs,
 getElementRule,
 getSelfClosingElements,
 getNonEmptyElements,
 getMoveCaretBeforeOnEnterElements,
 getWhitespaceElements,
 getTransparentElements,
 getSpecialElements,
 getComponentUrls,
 isValidChild,
 isValid,
 isBlock,
 isInline,
 isWrapper,
 getCustomElements,
 addValidElements,
 setValidElements,
 addCustomElements,
 addValidChildren,
 };
 };

const rgbaToHexString = (color) => fromString(color)
        .map(fromRgba)
        .map((h) => '#' + h.value)
        .getOr(color);

/**
 * This class is used to parse CSS styles. It also compresses styles to reduce the output size.
 *
 * @class tinymce.html.Styles
 * @version 3.4
 * @example
 * const Styles = tinymce.html.Styles({
 * url_converter: (url) => {
 * return url;
 * }
 * });
 *
 * styles = Styles.parse('border: 1px solid red');
 * styles.color = 'red';
 *
 * console.log(tinymce.html.Styles().serialize(styles));
 */
 const Styles = (settings = {}, schema) => {
 /* jshint maxlen:255 */
 /* eslint max-len:0 */
 const urlOrStrRegExp = /(?:url(?:(?:$\s*\"([^\"]+)\"\s*$)|(?:$\s*\'([^\']+)\'\s*$)|(?:$\s*([^)\s]+)\s*$)))|(?:\'([^\']+)\')|(?:\"([^\"]+)\")/gi;
 const styleRegExp = /\s*([^:]+):\s*([^;]+);?/g;
 const trimRightRegExp = /\s+$/;
 const encodingLookup = {};
 let validStyles;
 let invalidStyles;
 const invisibleChar = zeroWidth;
 if (schema) {
 validStyles = schema.getValidStyles();
 invalidStyles = schema.getInvalidStyles();
 }
 const encodingItems = (`\\" \\' \\; \\: ; : ` + invisibleChar).split(' ');
 for (let i = 0; i < encodingItems.length; i++) {
 encodingLookup[encodingItems[i]] = invisibleChar + i;
 encodingLookup[invisibleChar + i] = encodingItems[i];
 }
 // eslint-disable-next-line consistent-this
 const self = {
 /**
 * Parses the specified style value into an object collection. This parser will also
 * merge and remove any redundant items that browsers might have added. URLs inside
 * the styles will also be converted to absolute/relative based on the settings.
 *
 * @method parse
 * @param {String} css Style value to parse. For example: `border:1px solid red;`
 * @return {Object} Object representation of that style. For example: `{ border: '1px solid red' }`
 */
 parse: (css) => {
 const styles = {};
 let isEncoded = false;
 const urlConverter = settings.url_converter;
 const urlConverterScope = settings.url_converter_scope || self;
 const compress = (prefix, suffix, noJoin) => {
 const top = styles[prefix + '-top' + suffix];
 if (!top) {
 return;
 }
 const right = styles[prefix + '-right' + suffix];
 if (!right) {
 return;
 }
 const bottom = styles[prefix + '-bottom' + suffix];
 if (!bottom) {
 return;
 }
 const left = styles[prefix + '-left' + suffix];
 if (!left) {
 return;
 }
 const box = [top, right, bottom, left];
 let i = box.length - 1;
 while (i--) {
 if (box[i] !== box[i + 1]) {
 break;
 }
 }
 if (i > -1 && noJoin) {
 return;
 }
 styles[prefix + suffix] = i === -1 ? box[0] : box.join(' ');
 delete styles[prefix + '-top' + suffix];
 delete styles[prefix + '-right' + suffix];
 delete styles[prefix + '-bottom' + suffix];
 delete styles[prefix + '-left' + suffix];
 };
 /**
 * Checks if the specific style can be compressed in other words if all border-width are equal.
 */
 const canCompress = (key) => {
 const value = styles[key];
 if (!value) {
 return;
 }
 // Make sure not to split values like 'rgb(100, 50, 100);
 const values = value.indexOf(',') > -1 ? [value] : value.split(' ');
 let i = values.length;
 while (i--) {
 if (values[i] !== values[0]) {
 return false;
 }
 }
 styles[key] = values[0];
 return true;
 };
 /**
 * Compresses multiple styles into one style.
 */
 const compress2 = (target, a, b, c) => {
 if (!canCompress(a)) {
 return;
 }
 if (!canCompress(b)) {
 return;
 }
 if (!canCompress(c)) {
 return;
 }
 // Compress
 styles[target] = styles[a] + ' ' + styles[b] + ' ' + styles[c];
 delete styles[a];
 delete styles[b];
 delete styles[c];
 };
 // Encodes the specified string by replacing all \" \' ; : with _<num>
 const encode = (str) => {
 isEncoded = true;
 return encodingLookup[str];
 };
 // Decodes the specified string by replacing all _<num> with it's original value \" \' etc
 // It will also decode the \" \' if keepSlashes is set to false or omitted
 const decode = (str, keepSlashes) => {
 if (isEncoded) {
 str = str.replace(/\uFEFF[0-9]/g, (str) => {
 return encodingLookup[str];
 });
 }
 if (!keepSlashes) {
 str = str.replace(/\\([\'\";:])/g, '$1');
 }
 return str;
 };
 const decodeSingleHexSequence = (escSeq) => {
 return String.fromCharCode(parseInt(escSeq.slice(1), 16));
 };
 const decodeHexSequences = (value) => {
 return value.replace(/\\[0-9a-f]+/gi, decodeSingleHexSequence);
 };
 const processUrl = (match, url, url2, url3, str, str2) => {
 str = str || str2;
 if (str) {
 str = decode(str);
 // Force strings into single quote format
 return `'` + str.replace(/\'/g, `\\'`) + `'`;
 }
 url = decode(url || url2 || url3 || '');
 if (!settings.allow_script_urls) {
 const scriptUrl = url.replace(/[\s\r\n]+/g, '');
 if (/(java|vb)script:/i.test(scriptUrl)) {
 return '';
 }
 if (!settings.allow_svg_data_urls && /^data:image\/svg/i.test(scriptUrl)) {
 return '';
 }
 }
 // Convert the URL to relative/absolute depending on config
 if (urlConverter) {
 url = urlConverter.call(urlConverterScope, url, 'style');
 }
 // Output new URL format
 return `url('` + url.replace(/\'/g, `\\'`) + `')`;
 };
 if (css) {
 css = css.replace(/[\u0000-\u001F]/g, '');
 // Encode \" \' % and ; and : inside strings so they don't interfere with the style parsing
 css = css.replace(/\\[\"\';:\uFEFF]/g, encode).replace(/\"[^\"]+\"|\'[^\']+\'/g, (str) => {
 return str.replace(/[;:]/g, encode);
 });
 // Parse styles
 let matches;
 while ((matches = styleRegExp.exec(css))) {
 styleRegExp.lastIndex = matches.index + matches[0].length;
 let name = matches[1].replace(trimRightRegExp, '').toLowerCase();
 let value = matches[2].replace(trimRightRegExp, '');
 if (name && value) {
 // Decode escaped sequences like \65 -> e
 name = decodeHexSequences(name);
 value = decodeHexSequences(value);
 // Skip properties with double quotes and sequences like \" \' in their names
 // See 'mXSS Attacks: Attacking well-secured Web-Applications by using innerHTML Mutations'
 // https://cure53.de/fp170.pdf
 if (name.indexOf(invisibleChar) !== -1 || name.indexOf('"') !== -1) {
 continue;
 }
 // Don't allow behavior name or expression/comments within the values
 if (!settings.allow_script_urls && (name === 'behavior' || /expression\s*\(|\/\*|\*\//.test(value))) {
 continue;
 }
 // Opera will produce 700 instead of bold in their style values
 if (name === 'font-weight' && value === '700') {
 value = 'bold';
 }
 else if (name === 'color' || name === 'background-color') { // Lowercase colors like RED
 value = value.toLowerCase();
 }
 // Convert RGB colors to HEX
 if (getColorFormat(value) === 'rgb') {
 fromString(value).each((rgba) => {
 value = rgbaToHexString(toString(rgba)).toLowerCase();
 });
 }
 // Convert URLs and force them into url('value') format
 value = value.replace(urlOrStrRegExp, processUrl);
 styles[name] = isEncoded ? decode(value, true) : value;
 }
 }
 // Compress the styles to reduce it's size for example IE will expand styles
 compress('border', '', true);
 compress('border', '-width');
 compress('border', '-color');
 compress('border', '-style');
 compress('padding', '');
 compress('margin', '');
 compress2('border', 'border-width', 'border-style', 'border-color');
 // Remove pointless border, IE produces these
 if (styles.border === 'medium none') {
 delete styles.border;
 }
 // IE 11 will produce a border-image: none when getting the style attribute from 
 // So let us assume it shouldn't be there
 if (styles['border-image'] === 'none') {
 delete styles['border-image'];
 }
 }
 return styles;
 },
 /**
 * Serializes the specified style object into a string.
 *
 * @method serialize
 * @param {Object} styles Object to serialize as string. For example: `{ border: '1px solid red' }`
 * @param {String} elementName Optional element name, if specified only the styles that matches the schema will be serialized.
 * @return {String} String representation of the style object. For example: `border: 1px solid red`
 */
 serialize: (styles, elementName) => {
 let css = '';
 const serializeStyles = (elemName, validStyleList) => {
 const styleList = validStyleList[elemName];
 if (styleList) {
 for (let i = 0, l = styleList.length; i < l; i++) {
 const name = styleList[i];
 const value = styles[name];
 if (value) {
 css += (css.length > 0 ? ' ' : '') + name + ': ' + value + ';';
 }
 }
 }
 };
 const isValid = (name, elemName) => {
 if (!invalidStyles || !elemName) {
 return true;
 }
 let styleMap = invalidStyles['*'];
 if (styleMap && styleMap[name]) {
 return false;
 }
 styleMap = invalidStyles[elemName];
 return !(styleMap && styleMap[name]);
 };
 // Serialize styles according to schema
 if (elementName && validStyles) {
 // Serialize global styles and element specific styles
 serializeStyles('*', validStyles);
 serializeStyles(elementName, validStyles);
 }
 else {
 // Output the styles in the order they are inside the object
 each$d(styles, (value, name) => {
 if (value && isValid(name, elementName)) {
 css += (css.length > 0 ? ' ' : '') + name + ': ' + value + ';';
 }
 });
 }
 return css;
 }
 };
 return self;
 };

// Note: The values here aren't used. This is just used as a hash map to see if the key exists
    const deprecated = {
        keyLocation: true,
        layerX: true,
        layerY: true,
        returnValue: true,
        webkitMovementX: true,
        webkitMovementY: true,
        keyIdentifier: true,
        mozPressure: true
    };
    // Note: We can't rely on `instanceof` here as it won't work if the event was fired from another window.
    // Additionally, the constructor name might be `MouseEvent` or similar so we can't rely on the constructor name.
    const isNativeEvent = (event) => event instanceof Event || isFunction(event.initEvent);
    // Checks if it is our own isDefaultPrevented function
    const hasIsDefaultPrevented = (event) => event.isDefaultPrevented === always || event.isDefaultPrevented === never;
    // An event needs normalizing if it doesn't have the prevent default function or if it's a native event
    const needsNormalizing = (event) => isNullable(event.preventDefault) || isNativeEvent(event);
    const clone$2 = (originalEvent, data) => {
        const event = data ?? {};
        // Copy all properties from the original event
        for (const name in originalEvent) {
            // Some properties are deprecated and produces a warning so don't include them
            if (!has$2(deprecated, name)) {
                event[name] = originalEvent[name];
            }
        }
        // The composed path can't be cloned, so delegate instead
        if (isNonNullable(originalEvent.composedPath)) {
            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
            event.composedPath = () => originalEvent.composedPath();
        }
        // The getModifierState won't work when cloned, so delegate instead
        if (isNonNullable(originalEvent.getModifierState)) {
            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
            event.getModifierState = (keyArg) => originalEvent.getModifierState(keyArg);
        }
        // The getTargetRanges won't work when cloned, so delegate instead
        if (isNonNullable(originalEvent.getTargetRanges)) {
            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
            event.getTargetRanges = () => originalEvent.getTargetRanges();
        }
        return event;
    };
    const normalize$3 = (type, originalEvent, fallbackTarget, data) => {
        const event = clone$2(originalEvent, data);
        event.type = type;
        // Normalize target IE uses srcElement
        if (isNullable(event.target)) {
            event.target = event.srcElement ?? fallbackTarget;
        }
        if (needsNormalizing(originalEvent)) {
            // Add preventDefault method
            event.preventDefault = () => {
                event.defaultPrevented = true;
                event.isDefaultPrevented = always;
                // Execute preventDefault on the original event object
                if (isFunction(originalEvent.preventDefault)) {
                    originalEvent.preventDefault();
                }
            };
            // Add stopPropagation
            event.stopPropagation = () => {
                event.cancelBubble = true;
                event.isPropagationStopped = always;
                // Execute stopPropagation on the original event object
                if (isFunction(originalEvent.stopPropagation)) {
                    originalEvent.stopPropagation();
                }
            };
            // Add stopImmediatePropagation
            event.stopImmediatePropagation = () => {
                event.isImmediatePropagationStopped = always;
                event.stopPropagation();
            };
            // Add event delegation states
            if (!hasIsDefaultPrevented(event)) {
                event.isDefaultPrevented = event.defaultPrevented === true ? always : never;
                event.isPropagationStopped = event.cancelBubble === true ? always : never;
                event.isImmediatePropagationStopped = never;
            }
        }
        return event;
    };

/**
 * This class wraps the browsers native event logic with more convenient methods.
 *
 * @class tinymce.dom.EventUtils
 */
 const eventExpandoPrefix = 'mce-data-';
 const mouseEventRe = /^(?:mouse|contextmenu)|click/;
 /**
 * Binds a native event to a callback on the speified target.
 */
 const addEvent = (target, name, callback, capture) => {
 target.addEventListener(name, callback, capture || false);
 };
 /**
 * Unbinds a native event callback on the specified target.
 */
 const removeEvent = (target, name, callback, capture) => {
 target.removeEventListener(name, callback, capture || false);
 };
 const isMouseEvent = (event) => isNonNullable(event) && mouseEventRe.test(event.type);
 /**
 * Normalizes a native event object or just adds the event specific methods on a custom event.
 */
 const fix = (originalEvent, data) => {
 const event = normalize$3(originalEvent.type, originalEvent, document, data);
 // Calculate pageX/Y if missing and clientX/Y available
 if (isMouseEvent(originalEvent) && isUndefined(originalEvent.pageX) && !isUndefined(originalEvent.clientX)) {
 const eventDoc = event.target.ownerDocument || document;
 const doc = eventDoc.documentElement;
 const body = eventDoc.body;
 const mouseEvent = event;
 mouseEvent.pageX = originalEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) -
 (doc && doc.clientLeft || body && body.clientLeft || 0);
 mouseEvent.pageY = originalEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) -
 (doc && doc.clientTop || body && body.clientTop || 0);
 }
 return event;
 };
 /**
 * Bind a DOMContentLoaded event across browsers and executes the callback once the page DOM is initialized.
 * It will also set/check the domLoaded state of the event_utils instance so ready isn't called multiple times.
 */
 const bindOnReady = (win, callback, eventUtils) => {
 const doc = win.document, event = { type: 'ready' };
 if (eventUtils.domLoaded) {
 callback(event);
 return;
 }
 const isDocReady = () => {
 // Check complete or interactive state if there is a body
 // element on some iframes IE 8 will produce a null body
 return doc.readyState === 'complete' || (doc.readyState === 'interactive' && doc.body);
 };
 // Gets called when the DOM is ready
 const readyHandler = () => {
 removeEvent(win, 'DOMContentLoaded', readyHandler);
 removeEvent(win, 'load', readyHandler);
 if (!eventUtils.domLoaded) {
 eventUtils.domLoaded = true;
 callback(event);
 }
 // Clean memory for IE
 win = null;
 };
 if (isDocReady()) {
 readyHandler();
 }
 else {
 addEvent(win, 'DOMContentLoaded', readyHandler);
 }
 // Fallback if any of the above methods should fail for some odd reason
 if (!eventUtils.domLoaded) {
 addEvent(win, 'load', readyHandler);
 }
 };
 /**
 * This class enables you to bind/unbind native events to elements and normalize it's behavior across browsers.
 */
 class EventUtils {
 static Event = new EventUtils();
 // State if the DOMContentLoaded was executed or not
 domLoaded = false;
 events = {};
 expando;
 hasFocusIn;
 count = 1;
 constructor() {
 this.expando = eventExpandoPrefix + (+new Date()).toString(32);
 this.hasFocusIn = 'onfocusin' in document.documentElement;
 this.count = 1;
 }
 bind(target, names, callback, scope) {
 const self = this;
 let callbackList;
 const win = window;
 // Native event handler function patches the event and executes the callbacks for the expando
 const defaultNativeHandler = (evt) => {
 self.executeHandlers(fix(evt || win.event), id);
 };
 // Don't bind to text nodes or comments
 if (!target || isText$b(target) || isComment(target)) {
 return callback;
 }
 // Create or get events id for the target
 let id;
 if (!target[self.expando]) {
 id = self.count++;
 target[self.expando] = id;
 self.events[id] = {};
 }
 else {
 id = target[self.expando];
 }
 // Setup the specified scope or use the target as a default
 scope = scope || target;
 // Split names and bind each event, enables you to bind multiple events with one call
 const namesList = names.split(' ');
 let i = namesList.length;
 while (i--) {
 let name = namesList[i];
 let nativeHandler = defaultNativeHandler;
 let capture = false;
 let fakeName = false;
 // Use ready instead of DOMContentLoaded
 if (name === 'DOMContentLoaded') {
 name = 'ready';
 }
 // DOM is already ready
 if (self.domLoaded && name === 'ready' && target.readyState === 'complete') {
 callback.call(scope, fix({ type: name }));
 continue;
 }
 // Fake bubbling of focusin/focusout
 if (!self.hasFocusIn && (name === 'focusin' || name === 'focusout')) {
 capture = true;
 fakeName = name === 'focusin' ? 'focus' : 'blur';
 nativeHandler = (evt) => {
 const event = fix(evt || win.event);
 event.type = event.type === 'focus' ? 'focusin' : 'focusout';
 self.executeHandlers(event, id);
 };
 }
 // Setup callback list and bind native event
 callbackList = self.events[id][name];
 if (!callbackList) {
 self.events[id][name] = callbackList = [{ func: callback, scope }];
 callbackList.fakeName = fakeName;
 callbackList.capture = capture;
 // callbackList.callback = callback;
 // Add the nativeHandler to the callback list so that we can later unbind it
 callbackList.nativeHandler = nativeHandler;
 // Check if the target has native events support
 if (name === 'ready') {
 bindOnReady(target, nativeHandler, self);
 }
 else {
 addEvent(target, fakeName || name, nativeHandler, capture);
 }
 }
 else {
 if (name === 'ready' && self.domLoaded) {
 callback(fix({ type: name }));
 }
 else {
 // If it already has an native handler then just push the callback
 callbackList.push({ func: callback, scope });
 }
 }
 }
 target = callbackList = null; // Clean memory for IE
 return callback;
 }
 unbind(target, names, callback) {
 // Don't bind to text nodes or comments
 if (!target || isText$b(target) || isComment(target)) {
 return this;
 }
 // Unbind event or events if the target has the expando
 const id = target[this.expando];
 if (id) {
 let eventMap = this.events[id];
 // Specific callback
 if (names) {
 const namesList = names.split(' ');
 let i = namesList.length;
 while (i--) {
 const name = namesList[i];
 const callbackList = eventMap[name];
 // Unbind the event if it exists in the map
 if (callbackList) {
 // Remove specified callback
 if (callback) {
 let ci = callbackList.length;
 while (ci--) {
 if (callbackList[ci].func === callback) {
 const nativeHandler = callbackList.nativeHandler;
 const fakeName = callbackList.fakeName, capture = callbackList.capture;
 // Clone callbackList since unbind inside a callback would otherwise break the handlers loop
 const newCallbackList = callbackList.slice(0, ci).concat(callbackList.slice(ci + 1));
 newCallbackList.nativeHandler = nativeHandler;
 newCallbackList.fakeName = fakeName;
 newCallbackList.capture = capture;
 eventMap[name] = newCallbackList;
 }
 }
 }
 // Remove all callbacks if there isn't a specified callback or there is no callbacks left
 if (!callback || callbackList.length === 0) {
 delete eventMap[name];
 removeEvent(target, callbackList.fakeName || name, callbackList.nativeHandler, callbackList.capture);
 }
 }
 }
 }
 else {
 // All events for a specific element
 each$d(eventMap, (callbackList, name) => {
 removeEvent(target, callbackList.fakeName || name, callbackList.nativeHandler, callbackList.capture);
 });
 eventMap = {};
 }
 // Check if object is empty, if it isn't then we won't remove the expando map
 for (const name in eventMap) {
 if (has$2(eventMap, name)) {
 return this;
 }
 }
 // Delete event object
 delete this.events[id];
 // Remove expando from target
 try {
 // IE will fail here since it can't delete properties from window
 delete target[this.expando];
 }
 catch {
 // IE will set it to null
 target[this.expando] = null;
 }
 }
 return this;
 }
 /**
 * Fires the specified event on the specified target.
 * 
 * Deprecated in TinyMCE 6.0 and has been marked for removal in TinyMCE 7.0. Use <code>dispatch</code> instead.
 *
 * @method fire
 * @param {Object} target Target node/window or custom object.
 * @param {String} name Event name to fire.
 * @param {Object} args Optional arguments to send to the observers.
 * @return {EventUtils} Event utils instance.
 * @deprecated Use dispatch() instead
 */
 fire(target, name, args) {
 return this.dispatch(target, name, args);
 }
 /**
 * Dispatches the specified event on the specified target.
 *
 * @method dispatch
 * @param {Node/window} target Target node/window or custom object.
 * @param {String} name Event name to dispatch.
 * @param {Object} args Optional arguments to send to the observers.
 * @return {EventUtils} Event utils instance.
 */
 dispatch(target, name, args) {
 // Don't bind to text nodes or comments
 if (!target || isText$b(target) || isComment(target)) {
 return this;
 }
 // Build event object by patching the args
 const event = fix({ type: name, target }, args);
 do {
 // Found an expando that means there is listeners to execute
 const id = target[this.expando];
 if (id) {
 this.executeHandlers(event, id);
 }
 // Walk up the DOM
 target = target.parentNode || target.ownerDocument || target.defaultView || target.parentWindow;
 } while (target && !event.isPropagationStopped());
 return this;
 }
 /**
 * Removes all bound event listeners for the specified target. This will also remove any bound
 * listeners to child nodes within that target.
 *
 * @method clean
 * @param {Object} target Target node/window object.
 * @return {EventUtils} Event utils instance.
 */
 clean(target) {
 // Don't bind to text nodes or comments
 if (!target || isText$b(target) || isComment(target)) {
 return this;
 }
 // Unbind any element on the specified target
 if (target[this.expando]) {
 this.unbind(target);
 }
 // Target doesn't have getElementsByTagName it's probably a window object then use it's document to find the children
 if (!target.getElementsByTagName) {
 target = target.document;
 }
 // Remove events from each child element
 if (target && target.getElementsByTagName) {
 this.unbind(target);
 const children = target.getElementsByTagName('*');
 let i = children.length;
 while (i--) {
 target = children[i];
 if (target[this.expando]) {
 this.unbind(target);
 }
 }
 }
 return this;
 }
 /**
 * Destroys the event object. Call this to remove memory leaks.
 */
 destroy() {
 this.events = {};
 }
 // Legacy function for canceling events
 cancel(e) {
 if (e) {
 e.preventDefault();
 e.stopImmediatePropagation();
 }
 return false;
 }
 /**
 * Executes all event handler callbacks for a specific event.
 *
 * @private
 * @param {Event} evt Event object.
 * @param {String} id Expando id value to look for.
 */
 executeHandlers(evt, id) {
 const container = this.events[id];
 const callbackList = container && container[evt.type];
 if (callbackList) {
 for (let i = 0, l = callbackList.length; i < l; i++) {
 const callback = callbackList[i];
 // Check if callback exists might be removed if a unbind is called inside the callback
 if (callback && callback.func.call(callback.scope, evt) === false) {
 evt.preventDefault();
 }
 // Should we stop propagation to immediate listeners
 if (evt.isImmediatePropagationStopped()) {
 return;
 }
 }
 }
 }
 }

/**
 * Utility class for various DOM manipulation and retrieval functions.
 *
 * @class tinymce.dom.DOMUtils
 * @example
 * // Add a class to an element by id in the page
 * tinymce.DOM.addClass('someid', 'someclass');
 *
 * // Add a class to an element by id inside the editor
 * tinymce.activeEditor.dom.addClass('someid', 'someclass');
 */
 // Shorten names
 const each$a = Tools.each;
 const grep = Tools.grep;
 const internalStyleName = 'data-mce-style';
 const numericalCssMap = Tools.makeMap('fill-opacity font-weight line-height opacity orphans widows z-index zoom', ' ');
 const legacySetAttribute = (elm, name, value) => {
 if (isNullable(value) || value === '') {
 remove$9(elm, name);
 }
 else {
 set$4(elm, name, value);
 }
 };
 // Convert camel cased names back to hyphenated names
 const camelCaseToHyphens = (name) => name.replace(/[A-Z]/g, (v) => '-' + v.toLowerCase());
 const findNodeIndex = (node, normalized) => {
 let idx = 0;
 if (node) {
 for (let lastNodeType = node.nodeType, tempNode = node.previousSibling; tempNode; tempNode = tempNode.previousSibling) {
 const nodeType = tempNode.nodeType;
 // Normalize text nodes
 if (normalized && isText$b(tempNode)) {
 if (nodeType === lastNodeType || !tempNode.data.length) {
 continue;
 }
 }
 idx++;
 lastNodeType = nodeType;
 }
 }
 return idx;
 };
 const updateInternalStyleAttr = (styles, elm) => {
 const rawValue = get$9(elm, 'style');
 const value = styles.serialize(styles.parse(rawValue), name(elm));
 legacySetAttribute(elm, internalStyleName, value);
 };
 const convertStyleToString = (cssValue, cssName) => {
 if (isNumber(cssValue)) {
 return has$2(numericalCssMap, cssName) ? cssValue + '' : cssValue + 'px';
 }
 else {
 return cssValue;
 }
 };
 const applyStyle$1 = ($elm, cssName, cssValue) => {
 const normalizedName = camelCaseToHyphens(cssName);
 if (isNullable(cssValue) || cssValue === '') {
 remove$7($elm, normalizedName);
 }
 else {
 set$2($elm, normalizedName, convertStyleToString(cssValue, normalizedName));
 }
 };
 const setupAttrHooks = (styles, settings, getContext) => {
 const keepValues = settings.keep_values;
 const keepUrlHook = {
 set: (elm, value, name) => {
 const sugarElm = SugarElement.fromDom(elm);
 if (isFunction(settings.url_converter) && isNonNullable(value)) {
 value = settings.url_converter.call(settings.url_converter_scope || getContext(), String(value), name, elm);
 }
 const internalName = 'data-mce-' + name;
 legacySetAttribute(sugarElm, internalName, value);
 legacySetAttribute(sugarElm, name, value);
 },
 get: (elm, name) => {
 const sugarElm = SugarElement.fromDom(elm);
 return get$9(sugarElm, 'data-mce-' + name) || get$9(sugarElm, name);
 }
 };
 const attrHooks = {
 style: {
 set: (elm, value) => {
 const sugarElm = SugarElement.fromDom(elm);
 if (keepValues) {
 legacySetAttribute(sugarElm, internalStyleName, value);
 }
 remove$9(sugarElm, 'style');
 // If setting a style then delegate to the css api, otherwise
 // this will cause issues when using a content security policy
 if (isString(value)) {
 setAll(sugarElm, styles.parse(value));
 }
 },
 get: (elm) => {
 const sugarElm = SugarElement.fromDom(elm);
 const value = get$9(sugarElm, internalStyleName) || get$9(sugarElm, 'style');
 return styles.serialize(styles.parse(value), name(sugarElm));
 }
 }
 };
 if (keepValues) {
 attrHooks.href = attrHooks.src = keepUrlHook;
 }
 return attrHooks;
 };
 /**
 * Constructs a new DOMUtils instance. Consult the TinyMCE Documentation for more details on settings etc for this class.
 *
 * @private
 * @constructor
 * @method DOMUtils
 * @param {Document} doc Document reference to bind the utility class to.
 * @param {settings} settings Optional settings collection.
 */
 const DOMUtils = (doc, settings = {}) => {
 const addedStyles = {};
 const win = window;
 const files = {};
 let counter = 0;
 const stdMode = true;
 const boxModel = true;
 const styleSheetLoader = instance.forElement(SugarElement.fromDom(doc), {
 contentCssCors: settings.contentCssCors,
 referrerPolicy: settings.referrerPolicy,
 crossOrigin: (url) => {
 const crossOrigin = settings.crossOrigin;
 if (isFunction(crossOrigin)) {
 return crossOrigin(url, 'stylesheet');
 }
 else {
 return undefined;
 }
 }
 });
 const boundEvents = [];
 const schema = settings.schema ? settings.schema : Schema({});
 const styles = Styles({
 url_converter: settings.url_converter,
 url_converter_scope: settings.url_converter_scope,
 }, settings.schema);
 const events = settings.ownEvents ? new EventUtils() : EventUtils.Event;
 const blockElementsMap = schema.getBlockElements();
 /**
 * Returns true/false if the specified element is a block element or not.
 *
 * @method isBlock
 * @param {Node/String} node Element/Node to check.
 * @return {Boolean} True/False state if the node is a block element or not.
 */
 const isBlock = (node) => {
 if (isString(node)) {
 return has$2(blockElementsMap, node);
 }
 else {
 return isElement$7(node) && (has$2(blockElementsMap, node.nodeName) || isTransparentBlock(schema, node));
 }
 };
 const get = (elm) => elm && doc && isString(elm)
 ? doc.getElementById(elm)
 : elm;
 const _get = (elm) => {
 const value = get(elm);
 return isNonNullable(value) ? SugarElement.fromDom(value) : null;
 };
 const getAttrib = (elm, name, defaultVal = '') => {
 let value;
 const $elm = _get(elm);
 if (isNonNullable($elm) && isElement$8($elm)) {
 const hook = attrHooks[name];
 if (hook && hook.get) {
 value = hook.get($elm.dom, name);
 }
 else {
 value = get$9($elm, name);
 }
 }
 return isNonNullable(value) ? value : defaultVal;
 };
 const getAttribs = (elm) => {
 const node = get(elm);
 return isNullable(node) ? [] : node.attributes;
 };
 const setAttrib = (elm, name, value) => {
 run(elm, (e) => {
 if (isElement$7(e)) {
 const $elm = SugarElement.fromDom(e);
 const val = value === '' ? null : value;
 const originalValue = get$9($elm, name);
 const hook = attrHooks[name];
 if (hook && hook.set) {
 hook.set($elm.dom, val, name);
 }
 else {
 legacySetAttribute($elm, name, val);
 }
 if (originalValue !== val && settings.onSetAttrib) {
 settings.onSetAttrib({
 attrElm: $elm.dom, // We lie here to not break backwards compatibility
 attrName: name,
 attrValue: val
 });
 }
 }
 });
 };
 const clone = (node, deep) => {
 return node.cloneNode(deep);
 };
 const getRoot = () => settings.root_element || doc.body;
 const getViewPort = (argWin) => {
 const vp = getBounds(argWin);
 // Returns viewport size excluding scrollbars
 return {
 x: vp.x,
 y: vp.y,
 w: vp.width,
 h: vp.height
 };
 };
 const getPos$1 = (elm, rootElm) => getPos(doc.body, get(elm), rootElm);
 const setStyle = (elm, name, value) => {
 run(elm, (e) => {
 const $elm = SugarElement.fromDom(e);
 applyStyle$1($elm, name, value);
 if (settings.update_styles) {
 updateInternalStyleAttr(styles, $elm);
 }
 });
 };
 const setStyles = (elm, stylesArg) => {
 run(elm, (e) => {
 const $elm = SugarElement.fromDom(e);
 each$d(stylesArg, (v, n) => {
 applyStyle$1($elm, n, v);
 });
 if (settings.update_styles) {
 updateInternalStyleAttr(styles, $elm);
 }
 });
 };
 const getStyle = (elm, name, computed) => {
 const $elm = get(elm);
 if (isNullable($elm) || (!isHTMLElement($elm) && !isSVGElement($elm))) {
 return undefined;
 }
 if (computed) {
 return get$7(SugarElement.fromDom($elm), camelCaseToHyphens(name));
 }
 else {
 // Camelcase it, if needed
 name = name.replace(/-(\D)/g, (a, b) => b.toUpperCase());
 if (name === 'float') {
 name = 'cssFloat';
 }
 return $elm.style ? $elm.style[name] : undefined;
 }
 };
 const getSize = (elm) => {
 const $elm = get(elm);
 if (!$elm) {
 return { w: 0, h: 0 };
 }
 let w = getStyle($elm, 'width');
 let h = getStyle($elm, 'height');
 // Non pixel value, then force offset/clientWidth
 if (!w || w.indexOf('px') === -1) {
 w = '0';
 }
 // Non pixel value, then force offset/clientWidth
 if (!h || h.indexOf('px') === -1) {
 h = '0';
 }
 return {
 w: parseInt(w, 10) || $elm.offsetWidth || $elm.clientWidth,
 h: parseInt(h, 10) || $elm.offsetHeight || $elm.clientHeight
 };
 };
 const getRect = (elm) => {
 const $elm = get(elm);
 const pos = getPos$1($elm);
 const size = getSize($elm);
 return {
 x: pos.x, y: pos.y,
 w: size.w, h: size.h
 };
 };
 const is = (elm, selector) => {
 if (!elm) {
 return false;
 }
 const elms = isArray$1(elm) ? elm : [elm];
 return exists(elms, (e) => {
 return is$2(SugarElement.fromDom(e), selector);
 });
 };
 const getParents = (elm, selector, root, collect) => {
 const result = [];
 let node = get(elm);
 collect = collect === undefined;
 // Default root on inline mode
 const resolvedRoot = root || (getRoot().nodeName !== 'BODY' ? getRoot().parentNode : null);
 // Wrap node name as func
 if (isString(selector)) {
 if (selector === '*') {
 selector = isElement$7;
 }
 else {
 const selectorVal = selector;
 selector = (node) => is(node, selectorVal);
 }
 }
 while (node) {
 // TODO: Remove nullable check once TINY-6599 is complete
 if (node === resolvedRoot || isNullable(node.nodeType) || isDocument$1(node) || isDocumentFragment(node)) {
 break;
 }
 if (!selector || selector(node)) {
 if (collect) {
 result.push(node);
 }
 else {
 return [node];
 }
 }
 node = node.parentNode;
 }
 return collect ? result : null;
 };
 const getParent = (node, selector, root) => {
 const parents = getParents(node, selector, root, false);
 return parents && parents.length > 0 ? parents[0] : null;
 };
 const _findSib = (node, selector, name) => {
 let func = selector;
 if (node) {
 // If expression make a function of it using is
 if (isString(selector)) {
 func = (node) => {
 return is(node, selector);
 };
 }
 // Loop all siblings
 for (let tempNode = node[name]; tempNode; tempNode = tempNode[name]) {
 if (isFunction(func) && func(tempNode)) {
 return tempNode;
 }
 }
 }
 return null;
 };
 const getNext = (node, selector) => _findSib(node, selector, 'nextSibling');
 const getPrev = (node, selector) => _findSib(node, selector, 'previousSibling');
 const isParentNode = (node) => isFunction(node.querySelectorAll);
 const select = (selector, scope) => {
 const elm = get(scope) ?? settings.root_element ?? doc;
 return isParentNode(elm) ? from(elm.querySelectorAll(selector)) : [];
 };
 const run = function (elm, func, scope) {
 const context = scope ?? this;
 if (isArray$1(elm)) {
 const result = [];
 each$a(elm, (e, i) => {
 const node = get(e);
 if (node) {
 result.push(func.call(context, node, i));
 }
 });
 return result;
 }
 else {
 const node = get(elm);
 return !node ? false : func.call(context, node);
 }
 };
 const setAttribs = (elm, attrs) => {
 run(elm, ($elm) => {
 each$d(attrs, (value, name) => {
 setAttrib($elm, name, value);
 });
 });
 };
 const setHTML = (elm, html) => {
 run(elm, (e) => {
 const $elm = SugarElement.fromDom(e);
 set$3($elm, html);
 });
 };
 const add = (parentElm, name, attrs, html, create) => run(parentElm, (parentElm) => {
 const newElm = isString(name) ? doc.createElement(name) : name;
 if (isNonNullable(attrs)) {
 setAttribs(newElm, attrs);
 }
 if (html) {
 if (!isString(html) && html.nodeType) {
 newElm.appendChild(html);
 }
 else if (isString(html)) {
 setHTML(newElm, html);
 }
 }
 return !create ? parentElm.appendChild(newElm) : newElm;
 });
 const create = (name, attrs, html) => add(doc.createElement(name), name, attrs, html, true);
 const decode = Entities.decode;
 const encode = Entities.encodeAllRaw;
 const createHTML = (name, attrs, html = '') => {
 let outHtml = '<' + name;
 for (const key in attrs) {
 if (hasNonNullableKey(attrs, key)) {
 outHtml += ' ' + key + '="' + encode(attrs[key]) + '"';
 }
 }
 if (isEmpty$5(html) && has$2(schema.getVoidElements(), name)) {
 return outHtml + ' />';
 }
 else {
 return outHtml + '>' + html + '</' + name + '>';
 }
 };
 const createFragment = (html) => {
 const container = doc.createElement('div');
 const frag = doc.createDocumentFragment();
 // Append the container to the fragment so as to remove it from
 // the current document context
 frag.appendChild(container);
 if (html) {
 container.innerHTML = html;
 }
 let node;
 while ((node = container.firstChild)) {
 frag.appendChild(node);
 }
 // Remove the container now that all the children have been transferred
 frag.removeChild(container);
 return frag;
 };
 const remove = (node, keepChildren) => {
 return run(node, (n) => {
 const $node = SugarElement.fromDom(n);
 if (keepChildren) {
 // Unwrap but don't keep any empty text nodes
 each$e(children$1($node), (child) => {
 if (isText$c(child) && child.dom.length === 0) {
 remove$8(child);
 }
 else {
 before$4($node, child);
 }
 });
 }
 remove$8($node);
 return $node.dom;
 });
 };
 const removeAllAttribs = (e) => run(e, (e) => {
 const attrs = e.attributes;
 for (let i = attrs.length - 1; i >= 0; i--) {
 e.removeAttributeNode(attrs.item(i));
 }
 });
 const parseStyle = (cssText) => styles.parse(cssText);
 const serializeStyle = (stylesArg, name) => styles.serialize(stylesArg, name);
 const addStyle = (cssText) => {
 // Prevent inline from loading the same styles twice
 if (self !== DOMUtils.DOM && doc === document) {
 if (addedStyles[cssText]) {
 return;
 }
 addedStyles[cssText] = true;
 }
 // Create style element if needed
 let styleElm = doc.getElementById('mceDefaultStyles');
 if (!styleElm) {
 styleElm = doc.createElement('style');
 styleElm.id = 'mceDefaultStyles';
 styleElm.type = 'text/css';
 const head = doc.head;
 if (head.firstChild) {
 head.insertBefore(styleElm, head.firstChild);
 }
 else {
 head.appendChild(styleElm);
 }
 }
 // Append style data to old or new style element
 if (styleElm.styleSheet) {
 styleElm.styleSheet.cssText += cssText;
 }
 else {
 styleElm.appendChild(doc.createTextNode(cssText));
 }
 };
 const loadCSS = (urls) => {
 if (!urls) {
 urls = '';
 }
 each$e(urls.split(','), (url) => {
 files[url] = true;
 styleSheetLoader.load(url).catch(noop);
 });
 };
 const toggleClass = (elm, cls, state) => {
 run(elm, (e) => {
 if (isElement$7(e)) {
 const $elm = SugarElement.fromDom(e);
 // TINY-4520: DomQuery used to handle specifying multiple classes and the
 // formatter relies on it due to the changes made for TINY-7227
 const classes = cls.split(' ');
 each$e(classes, (c) => {
 if (isNonNullable(state)) {
 const fn = state ? add$2 : remove$4;
 fn($elm, c);
 }
 else {
 toggle$1($elm, c);
 }
 });
 }
 });
 };
 const addClass = (elm, cls) => {
 toggleClass(elm, cls, true);
 };
 const removeClass = (elm, cls) => {
 toggleClass(elm, cls, false);
 };
 const hasClass = (elm, cls) => {
 const $elm = _get(elm);
 // TINY-4520: DomQuery used to handle specifying multiple classes and the
 // formatter relies on it due to the changes made for TINY-7227
 const classes = cls.split(' ');
 return isNonNullable($elm) && forall(classes, (c) => has($elm, c));
 };
 const show = (elm) => {
 run(elm, (e) => remove$7(SugarElement.fromDom(e), 'display'));
 };
 const hide = (elm) => {
 run(elm, (e) => set$2(SugarElement.fromDom(e), 'display', 'none'));
 };
 const isHidden = (elm) => {
 const $elm = _get(elm);
 return isNonNullable($elm) && is$4(getRaw$1($elm, 'display'), 'none');
 };
 const uniqueId = (prefix) => (!prefix ? 'mce_' : prefix) + (counter++);
 const getOuterHTML = (elm) => {
 const $elm = _get(elm);
 if (isNonNullable($elm)) {
 return isElement$7($elm.dom) ? $elm.dom.outerHTML : getOuter($elm);
 }
 else {
 return '';
 }
 };
 const setOuterHTML = (elm, html) => {
 run(elm, ($elm) => {
 if (isElement$7($elm)) {
 $elm.outerHTML = html;
 }
 });
 };
 const insertAfter = (node, reference) => {
 const referenceNode = get(reference);
 return run(node, (node) => {
 const parent = referenceNode?.parentNode;
 const nextSibling = referenceNode?.nextSibling;
 if (parent) {
 if (nextSibling) {
 parent.insertBefore(node, nextSibling);
 }
 else {
 parent.appendChild(node);
 }
 }
 return node;
 });
 };
 const replace = (newElm, oldElm, keepChildren) => run(oldElm, (elm) => {
 const replacee = isArray$1(oldElm) ? newElm.cloneNode(true) : newElm;
 if (keepChildren) {
 each$a(grep(elm.childNodes), (node) => {
 replacee.appendChild(node);
 });
 }
 elm.parentNode?.replaceChild(replacee, elm);
 return elm;
 });
 const rename = (elm, name) => {
 if (elm.nodeName !== name.toUpperCase()) {
 // Rename block element
 const newElm = create(name);
 // Copy attribs to new block
 each$a(getAttribs(elm), (attrNode) => {
 setAttrib(newElm, attrNode.nodeName, getAttrib(elm, attrNode.nodeName));
 });
 // Replace block
 replace(newElm, elm, true);
 return newElm;
 }
 else {
 return elm;
 }
 };
 const findCommonAncestor = (a, b) => {
 let ps = a;
 while (ps) {
 let pe = b;
 while (pe && ps !== pe) {
 pe = pe.parentNode;
 }
 if (ps === pe) {
 break;
 }
 ps = ps.parentNode;
 }
 if (!ps && a.ownerDocument) {
 return a.ownerDocument.documentElement;
 }
 else {
 return ps;
 }
 };
 const isEmpty = (node, elements, options) => {
 if (isPlainObject(elements)) {
 const isContent = (node) => {
 const name = node.nodeName.toLowerCase();
 return Boolean(elements[name]);
 };
 return isEmptyNode(schema, node, { ...options, isContent });
 }
 else {
 return isEmptyNode(schema, node, options);
 }
 };
 const createRng = () => doc.createRange();
 const split = (parentElm, splitElm, replacementElm) => {
 let range = createRng();
 let beforeFragment;
 let afterFragment;
 if (parentElm && splitElm && parentElm.parentNode && splitElm.parentNode) {
 const parentNode = parentElm.parentNode;
 // Get before chunk
 range.setStart(parentNode, findNodeIndex(parentElm));
 range.setEnd(splitElm.parentNode, findNodeIndex(splitElm));
 beforeFragment = range.extractContents();
 // Get after chunk
 range = createRng();
 range.setStart(splitElm.parentNode, findNodeIndex(splitElm) + 1);
 range.setEnd(parentNode, findNodeIndex(parentElm) + 1);
 afterFragment = range.extractContents();
 // Insert before chunk
 parentNode.insertBefore(trimNode(self, beforeFragment, schema), parentElm);
 // Insert middle chunk
 if (replacementElm) {
 parentNode.insertBefore(replacementElm, parentElm);
 // pa.replaceChild(replacementElm, splitElm);
 }
 else {
 parentNode.insertBefore(splitElm, parentElm);
 }
 // Insert after chunk
 parentNode.insertBefore(trimNode(self, afterFragment, schema), parentElm);
 remove(parentElm);
 return replacementElm || splitElm;
 }
 else {
 return undefined;
 }
 };
 const bind = (target, name, func, scope) => {
 if (isArray$1(target)) {
 let i = target.length;
 const rv = [];
 while (i--) {
 rv[i] = bind(target[i], name, func, scope);
 }
 return rv;
 }
 else {
 // Collect all window/document events bound by editor instance
 if (settings.collect && (target === doc || target === win)) {
 boundEvents.push([target, name, func, scope]);
 }
 return events.bind(target, name, func, scope || self);
 }
 };
 const unbind = (target, name, func) => {
 if (isArray$1(target)) {
 let i = target.length;
 const rv = [];
 while (i--) {
 rv[i] = unbind(target[i], name, func);
 }
 return rv;
 }
 else {
 // Remove any bound events matching the input
 if (boundEvents.length > 0 && (target === doc || target === win)) {
 let i = boundEvents.length;
 while (i--) {
 const [boundTarget, boundName, boundFunc] = boundEvents[i];
 if (target === boundTarget && (!name || name === boundName) && (!func || func === boundFunc)) {
 events.unbind(boundTarget, boundName, boundFunc);
 }
 }
 }
 return events.unbind(target, name, func);
 }
 };
 const dispatch = (target, name, evt) => events.dispatch(target, name, evt);
 const fire = (target, name, evt) => events.dispatch(target, name, evt);
 const getContentEditable = (node) => {
 if (node && isHTMLElement(node)) {
 // Check for fake content editable
 const contentEditable = node.getAttribute('data-mce-contenteditable');
 if (contentEditable && contentEditable !== 'inherit') {
 return contentEditable;
 }
 // Check for real content editable
 return node.contentEditable !== 'inherit' ? node.contentEditable : null;
 }
 else {
 return null;
 }
 };
 const getContentEditableParent = (node) => {
 const root = getRoot();
 let state = null;
 for (let tempNode = node; tempNode && tempNode !== root; tempNode = tempNode.parentNode) {
 state = getContentEditable(tempNode);
 if (state !== null) {
 break;
 }
 }
 return state;
 };
 const isEditable = (node) => {
 if (isNonNullable(node)) {
 const scope = isElement$7(node) ? node : node.parentElement;
 return isNonNullable(scope) && isHTMLElement(scope) && isEditable$2(SugarElement.fromDom(scope));
 }
 else {
 return false;
 }
 };
 const destroy = () => {
 // Unbind all events bound to window/document by editor instance
 if (boundEvents.length > 0) {
 let i = boundEvents.length;
 while (i--) {
 const [boundTarget, boundName, boundFunc] = boundEvents[i];
 events.unbind(boundTarget, boundName, boundFunc);
 }
 }
 // Remove CSS files added to the dom
 each$d(files, (_, url) => {
 styleSheetLoader.unload(url);
 delete files[url];
 });
 };
 const isChildOf = (node, parent) => {
 return node === parent || parent.contains(node);
 };
 const dumpRng = (r) => ('startContainer: ' + r.startContainer.nodeName +
 ', startOffset: ' + r.startOffset +
 ', endContainer: ' + r.endContainer.nodeName +
 ', endOffset: ' + r.endOffset);
 // eslint-disable-next-line consistent-this
 const self = {
 doc,
 settings,
 win,
 files,
 stdMode,
 boxModel,
 styleSheetLoader,
 boundEvents,
 styles,
 schema,
 events,
 isBlock: isBlock,
 root: null,
 clone,
 /**
 * Returns the root node of the document. This is normally the body but might be a DIV. Parents like getParent will not
 * go above the point of this root node.
 *
 * @method getRoot
 * @return {Element} Root element for the utility class.
 */
 getRoot,
 /**
 * Returns the viewport of the window.
 *
 * @method getViewPort
 * @param {Window} win Optional window to get viewport of.
 * @return {Object} Viewport object with fields x, y, w and h.
 */
 getViewPort,
 /**
 * Returns the rectangle for a specific element.
 *
 * @method getRect
 * @param {Element/String} elm Element object or element ID to get rectangle from.
 * @return {Object} Rectangle for specified element object with x, y, w, h fields.
 */
 getRect,
 /**
 * Returns the size dimensions of the specified element.
 *
 * @method getSize
 * @param {Element/String} elm Element object or element ID to get rectangle from.
 * @return {Object} Rectangle for specified element object with w, h fields.
 */
 getSize,
 /**
 * Returns a node by the specified selector function. This function will
 * loop through all parent nodes and call the specified function for each node.
 * If the function then returns true indicating that it has found what it was looking for, the loop execution will then end
 * and the node it found will be returned.
 *
 * @method getParent
 * @param {Node/String} node DOM node to search parents on or ID string.
 * @param {Function} selector Selection function or CSS selector to execute on each node.
 * @param {Node} root Optional root element, never go beyond this point.
 * @return {Node} DOM Node or null if it wasn't found.
 */
 getParent,
 /**
 * Returns a node list of all parents matching the specified selector function or pattern.
 * If the function then returns true indicating that it has found what it was looking for and that node will be collected.
 *
 * @method getParents
 * @param {Node/String} node DOM node to search parents on or ID string.
 * @param {Function} selector Selection function to execute on each node or CSS pattern.
 * @param {Node} root Optional root element, never go beyond this point.
 * @return {Array} Array of nodes or null if it wasn't found.
 */
 getParents: getParents,
 /**
 * Returns the specified element by ID or the input element if it isn't a string.
 *
 * @method get
 * @param {String/Element} n Element id to look for or element to just pass though.
 * @return {Element} Element matching the specified id or null if it wasn't found.
 */
 get,
 /**
 * Returns the next node that matches selector or function
 *
 * @method getNext
 * @param {Node} node Node to find siblings from.
 * @param {String/function} selector Selector CSS expression or function.
 * @return {Node} Next node item matching the selector or null if it wasn't found.
 */
 getNext,
 /**
 * Returns the previous node that matches selector or function
 *
 * @method getPrev
 * @param {Node} node Node to find siblings from.
 * @param {String/function} selector Selector CSS expression or function.
 * @return {Node} Previous node item matching the selector or null if it wasn't found.
 */
 getPrev,
 // #ifndef jquery
 /**
 * Returns a list of the elements specified by the given CSS selector. For example: `div#a1 p.test`
 *
 * @method select
 * @param {String} selector Target CSS selector.
 * @param {Object} scope Optional root element/scope element to search in.
 * @return {Array} Array with all matched elements.
 * @example
 * // Adds a class to all paragraphs in the currently active editor
 * tinymce.activeEditor.dom.addClass(tinymce.activeEditor.dom.select('p'), 'someclass');
 *
 * // Adds a class to all spans that have the test class in the currently active editor
 * tinymce.activeEditor.dom.addClass(tinymce.activeEditor.dom.select('span.test'), 'someclass')
 */
 select,
 /**
 * Returns true/false if the specified element matches the specified css pattern.
 *
 * @method is
 * @param {Node/NodeList} elm DOM node to match or an array of nodes to match.
 * @param {String} selector CSS pattern to match the element against.
 */
 is,
 // #endif
 /**
 * Adds the specified element to another element or elements.
 *
 * @method add
 * @param {String/Element/Array} parentElm Element id string, DOM node element or array of ids or elements to add to.
 * @param {String/Element} name Name of new element to add or existing element to add.
 * @param {Object} attrs Optional object collection with arguments to add to the new element(s).
 * @param {String} html Optional inner HTML contents to add for each element.
 * @param {Boolean} create Optional flag if the element should be created or added.
 * @return {Element/Array} Element that got created, or an array of created elements if multiple input elements
 * were passed in.
 * @example
 * // Adds a new paragraph to the end of the active editor
 * tinymce.activeEditor.dom.add(tinymce.activeEditor.getBody(), 'p', { title: 'my title' }, 'Some content');
 */
 add,
 /**
 * Creates a new element.
 *
 * @method create
 * @param {String} name Name of new element.
 * @param {Object} attrs Optional object name/value collection with element attributes.
 * @param {String} html Optional HTML string to set as inner HTML of the element.
 * @return {Element} HTML DOM node element that got created.
 * @example
 * // Adds an element where the caret/selection is in the active editor
 * var el = tinymce.activeEditor.dom.create('div', { id: 'test', 'class': 'myclass' }, 'some content');
 * tinymce.activeEditor.selection.setNode(el);
 */
 create,
 /**
 * Creates HTML string for element. The element will be closed unless an empty inner HTML string is passed in.
 *
 * @method createHTML
 * @param {String} name Name of new element.
 * @param {Object} attrs Optional object name/value collection with element attributes.
 * @param {String} html Optional HTML string to set as inner HTML of the element.
 * @return {String} String with new HTML element, for example: <a href="#">test</a>.
 * @example
 * // Creates a html chunk and inserts it at the current selection/caret location
 * tinymce.activeEditor.insertContent(tinymce.activeEditor.dom.createHTML('a', { href: 'test.html' }, 'some line'));
 */
 createHTML,
 /**
 * Creates a document fragment out of the specified HTML string.
 *
 * @method createFragment
 * @param {String} html Html string to create fragment from.
 * @return {DocumentFragment} Document fragment node.
 */
 createFragment,
 /**
 * Removes/deletes the specified element(s) from the DOM.
 *
 * @method remove
 * @param {String/Element/Array} node ID of element or DOM element object or array containing multiple elements/ids.
 * @param {Boolean} keepChildren Optional state to keep children or not. If set to true all children will be
 * placed at the location of the removed element.
 * @return {Element/Array} HTML DOM element that got removed, or an array of removed elements if multiple input elements
 * were passed in.
 * @example
 * // Removes all paragraphs in the active editor
 * tinymce.activeEditor.dom.remove(tinymce.activeEditor.dom.select('p'));
 *
 * // Removes an element by id in the document
 * tinymce.DOM.remove('mydiv');
 */
 remove,
 /**
 * Sets the CSS style value on a HTML element. The name can be a camelcase string
 * or the CSS style name like background-color.
 *
 * @method setStyle
 * @param {String/Element/Array} elm HTML element/Array of elements to set CSS style value on.
 * @param {String} name Name of the style value to set.
 * @param {String} value Value to set on the style.
 * @example
 * // Sets a style value on all paragraphs in the currently active editor
 * tinymce.activeEditor.dom.setStyle(tinymce.activeEditor.dom.select('p'), 'background-color', 'red');
 *
 * // Sets a style value to an element by id in the current document
 * tinymce.DOM.setStyle('mydiv', 'background-color', 'red');
 */
 setStyle,
 /**
 * Returns the current style or runtime/computed value of an element.
 *
 * @method getStyle
 * @param {String/Element} elm HTML element or element id string to get style from.
 * @param {String} name Style name to return.
 * @param {Boolean} computed Computed style.
 * @return {String} Current style or computed style value of an element.
 */
 getStyle: getStyle,
 /**
 * Sets multiple styles on the specified element(s).
 *
 * @method setStyles
 * @param {Element/String/Array} elm DOM element, element id string or array of elements/ids to set styles on.
 * @param {Object} styles Name/Value collection of style items to add to the element(s).
 * @example
 * // Sets styles on all paragraphs in the currently active editor
 * tinymce.activeEditor.dom.setStyles(tinymce.activeEditor.dom.select('p'), { 'background-color': 'red', 'color': 'green' });
 *
 * // Sets styles to an element by id in the current document
 * tinymce.DOM.setStyles('mydiv', { 'background-color': 'red', 'color': 'green' });
 */
 setStyles,
 /**
 * Removes all attributes from an element or elements.
 *
 * @method removeAllAttribs
 * @param {Element/String/Array} e DOM element, element id string or array of elements/ids to remove attributes from.
 */
 removeAllAttribs,
 /**
 * Sets the specified attribute of an element or elements.
 *
 * @method setAttrib
 * @param {Element/String/Array} elm DOM element, element id string or array of elements/ids to set attribute on.
 * @param {String} name Name of attribute to set.
 * @param {String} value Value to set on the attribute - if this value is falsy like null, 0 or '' it will remove
 * the attribute instead.
 * @example
 * // Sets class attribute on all paragraphs in the active editor
 * tinymce.activeEditor.dom.setAttrib(tinymce.activeEditor.dom.select('p'), 'class', 'myclass');
 *
 * // Sets class attribute on a specific element in the current page
 * tinymce.dom.setAttrib('mydiv', 'class', 'myclass');
 */
 setAttrib,
 /**
 * Sets two or more specified attributes of an element or elements.
 *
 * @method setAttribs
 * @param {Element/String/Array} elm DOM element, element id string or array of elements/ids to set attributes on.
 * @param {Object} attrs Name/Value collection of attribute items to add to the element(s).
 * @example
 * // Sets class and title attributes on all paragraphs in the active editor
 * tinymce.activeEditor.dom.setAttribs(tinymce.activeEditor.dom.select('p'), { 'class': 'myclass', title: 'some title' });
 *
 * // Sets class and title attributes on a specific element in the current page
 * tinymce.DOM.setAttribs('mydiv', { 'class': 'myclass', title: 'some title' });
 */
 setAttribs,
 /**
 * Returns the specified attribute by name.
 *
 * @method getAttrib
 * @param {String/Element} elm Element string id or DOM element to get attribute from.
 * @param {String} name Name of attribute to get.
 * @param {String} defaultVal Optional default value to return if the attribute didn't exist.
 * @return {String} Attribute value string, default value or null if the attribute wasn't found.
 */
 getAttrib,
 /**
 * Returns the absolute x, y position of a node. The position will be returned in an object with x, y fields.
 *
 * @method getPos
 * @param {Element/String} elm HTML element or element id to get x, y position from.
 * @param {Element} rootElm Optional root element to stop calculations at.
 * @return {Object} Absolute position of the specified element object with x, y fields.
 */
 getPos: getPos$1,
 /**
 * Parses the specified style value into an object collection. This parser will also
 * merge and remove any redundant items that browsers might have added. It will also convert non-hex
 * colors to hex values. Urls inside the styles will also be converted to absolute/relative based on settings.
 *
 * @method parseStyle
 * @param {String} cssText Style value to parse, for example: border:1px solid red;.
 * @return {Object} Object representation of that style, for example: {border: '1px solid red'}
 */
 parseStyle,
 /**
 * Serializes the specified style object into a string.
 *
 * @method serializeStyle
 * @param {Object} styles Object to serialize as string, for example: {border: '1px solid red'}
 * @param {String} name Optional element name.
 * @return {String} String representation of the style object, for example: border: 1px solid red.
 */
 serializeStyle,
 /**
 * Adds a style element at the top of the document with the specified cssText content.
 *
 * @method addStyle
 * @param {String} cssText CSS Text style to add to top of head of document.
 */
 addStyle,
 /**
 * Imports/loads the specified CSS file into the document bound to the class.
 *
 * @method loadCSS
 * @param {String} url URL to CSS file to load.
 * @example
 * // Loads a CSS file dynamically into the current document
 * tinymce.DOM.loadCSS('somepath/some.css');
 *
 * // Loads a CSS file into the currently active editor instance
 * tinymce.activeEditor.dom.loadCSS('somepath/some.css');
 *
 * // Loads a CSS file into an editor instance by id
 * tinymce.get('someid').dom.loadCSS('somepath/some.css');
 *
 * // Loads multiple CSS files into the current document
 * tinymce.DOM.loadCSS('somepath/some.css,somepath/someother.css');
 */
 loadCSS,
 /**
 * Adds a class to the specified element or elements.
 *
 * @method addClass
 * @param {String/Element/Array} elm Element ID string or DOM element or array with elements or IDs.
 * @param {String} cls Class name to add to each element.
 * @return {String/Array} String with new class value or array with new class values for all elements.
 * @example
 * // Adds a class to all paragraphs in the active editor
 * tinymce.activeEditor.dom.addClass(tinymce.activeEditor.dom.select('p'), 'myclass');
 *
 * // Adds a class to a specific element in the current page
 * tinymce.DOM.addClass('mydiv', 'myclass');
 */
 addClass,
 /**
 * Removes a class from the specified element or elements.
 *
 * @method removeClass
 * @param {String/Element/Array} elm Element ID string or DOM element or array with elements or IDs.
 * @param {String} cls Class name to remove from each element.
 * @return {String/Array} String of remaining class name(s), or an array of strings if multiple input elements
 * were passed in.
 * @example
 * // Removes a class from all paragraphs in the active editor
 * tinymce.activeEditor.dom.removeClass(tinymce.activeEditor.dom.select('p'), 'myclass');
 *
 * // Removes a class from a specific element in the current page
 * tinymce.DOM.removeClass('mydiv', 'myclass');
 */
 removeClass,
 /**
 * Returns true if the specified element has the specified class.
 *
 * @method hasClass
 * @param {String/Element} elm HTML element or element id string to check CSS class on.
 * @param {String} cls CSS class to check for.
 * @return {Boolean} true/false if the specified element has the specified class.
 */
 hasClass,
 /**
 * Toggles the specified class on/off.
 *
 * @method toggleClass
 * @param {Element} elm Element to toggle class on.
 * @param {String} cls Class to toggle on/off.
 * @param {Boolean} state Optional state to set.
 */
 toggleClass,
 /**
 * Shows the specified element(s) by ID by setting the "display" style.
 *
 * @method show
 * @param {String/Element/Array} elm ID of DOM element or DOM element or array with elements or IDs to show.
 */
 show,
 /**
 * Hides the specified element(s) by ID by setting the "display" style.
 *
 * @method hide
 * @param {String/Element/Array} elm ID of DOM element or DOM element or array with elements or IDs to hide.
 * @example
 * // Hides an element by id in the document
 * tinymce.DOM.hide('myid');
 */
 hide,
 /**
 * Returns true/false if the element is hidden or not by checking the "display" style.
 *
 * @method isHidden
 * @param {String/Element} elm Id or element to check display state on.
 * @return {Boolean} true/false if the element is hidden or not.
 */
 isHidden,
 /**
 * Returns a unique id. This can be useful when generating elements on the fly.
 * This method will not check if the element already exists.
 *
 * @method uniqueId
 * @param {String} prefix Optional prefix to add in front of all ids - defaults to "mce_".
 * @return {String} Unique id.
 */
 uniqueId,
 /**
 * Sets the specified HTML content inside the element or elements. The HTML will first be processed. This means
 * URLs will get converted, hex color values fixed etc. Check processHTML for details.
 *
 * @method setHTML
 * @param {Element/String/Array} elm DOM element, element id string or array of elements/ids to set HTML inside of.
 * @param {String} html HTML content to set as inner HTML of the element.
 * @example
 * // Sets the inner HTML of all paragraphs in the active editor
 * tinymce.activeEditor.dom.setHTML(tinymce.activeEditor.dom.select('p'), 'some inner html');
 *
 * // Sets the inner HTML of an element by id in the document
 * tinymce.DOM.setHTML('mydiv', 'some inner html');
 */
 setHTML,
 /**
 * Returns the outer HTML of an element.
 *
 * @method getOuterHTML
 * @param {String/Element} elm Element ID or element object to get outer HTML from.
 * @return {String} Outer HTML string.
 * @example
 * tinymce.DOM.getOuterHTML(editorElement);
 * tinymce.activeEditor.getOuterHTML(tinymce.activeEditor.getBody());
 */
 getOuterHTML,
 /**
 * Sets the specified outer HTML on an element or elements.
 *
 * @method setOuterHTML
 * @param {Element/String/Array} elm DOM element, element id string or array of elements/ids to set outer HTML on.
 * @param {Object} html HTML code to set as outer value for the element.
 * @example
 * // Sets the outer HTML of all paragraphs in the active editor
 * tinymce.activeEditor.dom.setOuterHTML(tinymce.activeEditor.dom.select('p'), '<div>some html</div>');
 *
 * // Sets the outer HTML of an element by id in the document
 * tinymce.DOM.setOuterHTML('mydiv', '<div>some html</div>');
 */
 setOuterHTML,
 /**
 * Entity decodes a string. This method decodes any HTML entities, such as `&amp;aring;`.
 *
 * @method decode
 * @param {String} s String to decode entities on.
 * @return {String} Entity decoded string.
 */
 decode,
 /**
 * Entity encodes a string. This method encodes the most common entities, such as `<`, `>`, `"` and `&`.
 *
 * @method encode
 * @param {String} text String to encode with entities.
 * @return {String} Entity encoded string.
 */
 encode,
 /**
 * Inserts an element after the reference element.
 *
 * @method insertAfter
 * @param {Element} node Element to insert after the reference.
 * @param {Element/String/Array} referenceNode Reference element, element id or array of elements to insert after.
 * @return {Element/Array} Element that got added or an array with elements.
 */
 insertAfter,
 /**
 * Replaces the specified element or elements with the new element specified. The new element will
 * be cloned if multiple input elements are passed in.
 *
 * @method replace
 * @param {Element} newElm New element to replace old ones with.
 * @param {Element/String/Array} oldElm Element DOM node, element id or array of elements or ids to replace.
 * @param {Boolean} keepChildren Optional keep children state, if set to true child nodes from the old object will be added
 * to new ones.
 */
 replace,
 /**
 * Renames the specified element and keeps its attributes and children.
 *
 * @method rename
 * @param {Element} elm Element to rename.
 * @param {String} name Name of the new element.
 * @return {Element} New element or the old element if it needed renaming.
 */
 rename,
 /**
 * Find the common ancestor of two elements. This is a shorter method than using the DOM Range logic.
 *
 * @method findCommonAncestor
 * @param {Element} a Element to find common ancestor of.
 * @param {Element} b Element to find common ancestor of.
 * @return {Element} Common ancestor element of the two input elements.
 */
 findCommonAncestor,
 /**
 * Executes the specified function on the element by id or dom element node or array of elements/id.
 *
 * @method run
 * @param {String/Element/Array} elm ID or DOM element object or array with ids or elements.
 * @param {Function} func Function to execute for each item.
 * @param {Object} scope Optional scope to execute the function in.
 * @return {Object/Array} Single object, or an array of objects if multiple input elements were passed in.
 */
 run,
 /**
 * Returns a NodeList with attributes for the element.
 *
 * @method getAttribs
 * @param {HTMLElement/string} elm Element node or string id to get attributes from.
 * @return {NodeList} NodeList with attributes.
 */
 getAttribs,
 /**
 * Returns true/false if the specified node is to be considered empty or not.
 *
 * @method isEmpty
 * @param {Node} node The target node to check if it's empty.
 * @param {Object} elements Optional name/value object with elements that are automatically treated as non-empty elements.
 * @return {Boolean} true/false if the node is empty or not.
 * @example
 * tinymce.DOM.isEmpty(node, { img: true });
 */
 isEmpty,
 /**
 * Creates a new DOM Range object. This will use the native DOM Range API if it's
 * available. If it's not, it will fall back to the custom TinyMCE implementation.
 *
 * @method createRng
 * @return {DOMRange} DOM Range object.
 * @example
 * const rng = tinymce.DOM.createRng();
 * alert(rng.startContainer + "," + rng.startOffset);
 */
 createRng,
 /**
 * Returns the index of the specified node within its parent.
 *
 * @method nodeIndex
 * @param {Node} node Node to look for.
 * @param {Boolean} normalized Optional true/false state if the index is what it would be after a normalization.
 * @return {Number} Index of the specified node.
 */
 nodeIndex: findNodeIndex,
 /**
 * Splits an element into two new elements and places the specified split
 * element or elements between the new ones. For example splitting the paragraph at the bold element in
 * this example `abcabc123` would produce `abcabc123`.
 *
 * @method split
 * @param {Element} parentElm Parent element to split.
 * @param {Element} splitElm Element to split at.
 * @param {Element} replacementElm Optional replacement element to replace the split element with.
 * @return {Element} Returns the split element or the replacement element if that is specified.
 */
 split,
 /**
 * Adds an event handler to the specified object.
 *
 * @method bind
 * @param {Element/Document/Window/Array} target Target element to bind events to.
 * handler to or an array of elements/ids/documents.
 * @param {String} name Name of event handler to add, for example: click.
 * @param {Function} func Function to execute when the event occurs.
 * @param {Object} scope Optional scope to execute the function in.
 * @return {Function} Function callback handler the same as the one passed in.
 */
 bind: bind,
 /**
 * Removes the specified event handler by name and function from an element or collection of elements.
 *
 * @method unbind
 * @param {Element/Document/Window/Array} target Target element to unbind events on.
 * @param {String} name Event handler name, for example: "click"
 * @param {Function} func Function to remove.
 * @return {Boolean/Array} Bool state of true if the handler was removed, or an array of states if multiple input elements
 * were passed in.
 */
 unbind: unbind,
 /**
 * Fires the specified event name and optional object on the specified target.
 * 
 * Deprecated in TinyMCE 6.0 and has been marked for removal in TinyMCE 7.0. Use <code>dispatch</code> instead.
 *
 * @method fire
 * @param {Node/Document/Window} target Target element or object to fire event on.
 * @param {String} name Event name to fire.
 * @param {Object} evt Event object to send.
 * @return {Event} Event object.
 * @deprecated Use dispatch() instead
 */
 fire,
 /**
 * Dispatches the specified event name and optional object on the specified target.
 *
 * @method dispatch
 * @param {Node/Document/Window} target Target element or object to dispatch event on.
 * @param {String} name Name of the event to fire.
 * @param {Object} evt Event object to send.
 * @return {Event} Event object.
 */
 dispatch,
 // Returns the content editable state of a node
 getContentEditable,
 getContentEditableParent,
 /**
 * Checks if the specified node is editable within the given context of its parents.
 *
 * @method isEditable
 * @param {Node} node Node to check if it's editable.
 * @return {Boolean} Will be true if the node is editable and false if it's not editable.
 */
 isEditable,
 /**
 * Destroys all internal references to the DOM to solve memory leak issues.
 *
 * @method destroy
 */
 destroy,
 isChildOf,
 dumpRng
 };
 const attrHooks = setupAttrHooks(styles, settings, constant(self));
 return self;
 };
 /**
 * Instance of DOMUtils for the current document.
 *
 * @static
 * @property DOM
 * @type tinymce.dom.DOMUtils
 * @example
 * // Example of how to add a class to some element by id
 * tinymce.DOM.addClass('someid', 'someclass');
 */
 DOMUtils.DOM = DOMUtils(document);
 DOMUtils.nodeIndex = findNodeIndex;

/**
     * This class handles asynchronous/synchronous loading of JavaScript files it will execute callbacks
     * when various items gets loaded. This class is useful to load external JavaScript files.
     *
     * @class tinymce.dom.ScriptLoader
     * @example
     * // Load a script from a specific URL using the global script loader
     * tinymce.ScriptLoader.load('somescript.js');
     *
     * // Load a script using a unique instance of the script loader
     * const scriptLoader = new tinymce.dom.ScriptLoader();
     *
     * scriptLoader.load('somescript.js');
     *
     * // Load multiple scripts
     * scriptLoader.add('somescript1.js');
     * scriptLoader.add('somescript2.js');
     * scriptLoader.add('somescript3.js');
     *
     * scriptLoader.loadQueue().then(() => {
     *   alert('All scripts are now loaded.');
     * });
     */
    const DOM$e = DOMUtils.DOM;
    const QUEUED = 0;
    const LOADING = 1;
    const LOADED = 2;
    const FAILED = 3;
    class ScriptLoader {
        static ScriptLoader = new ScriptLoader();
        settings;
        states = {};
        queue = [];
        scriptLoadedCallbacks = {};
        queueLoadedCallbacks = [];
        loading = false;
        constructor(settings = {}) {
            this.settings = settings;
        }
        _setReferrerPolicy(referrerPolicy) {
            this.settings.referrerPolicy = referrerPolicy;
        }
        _setCrossOrigin(crossOrigin) {
            this.settings.crossOrigin = crossOrigin;
        }
        /**
         * Loads a specific script directly without adding it to the load queue.
         *
         * @method loadScript
         * @param {String} url Absolute URL to script to add.
         * @return {Promise} A promise that will resolve when the script loaded successfully or reject if it failed to load.
         */
        loadScript(url) {
            return new Promise((resolve, reject) => {
                const dom = DOM$e;
                const doc = document;
                let elm;
                const cleanup = () => {
                    dom.remove(id);
                    if (elm) {
                        elm.onerror = elm.onload = elm = null;
                    }
                };
                // Execute callback when script is loaded
                const done = () => {
                    cleanup();
                    resolve();
                };
                const error = () => {
                    // We can't mark it as done if there is a load error since
                    // A) We don't want to produce 404 errors on the server and
                    // B) the onerror event won't fire on all browsers.
                    cleanup();
                    reject('Failed to load script: ' + url);
                };
                const id = dom.uniqueId();
                // Create new script element
                elm = doc.createElement('script');
                elm.id = id;
                elm.type = 'text/javascript';
                elm.src = Tools._addCacheSuffix(url);
                if (this.settings.referrerPolicy) {
                    // Note: Don't use elm.referrerPolicy = ... here as it doesn't work on Safari
                    dom.setAttrib(elm, 'referrerpolicy', this.settings.referrerPolicy);
                }
                const crossOrigin = this.settings.crossOrigin;
                if (isFunction(crossOrigin)) {
                    const resultCrossOrigin = crossOrigin(url);
                    if (resultCrossOrigin !== undefined) {
                        dom.setAttrib(elm, 'crossorigin', resultCrossOrigin);
                    }
                }
                elm.onload = done;
                // Add onerror event will get fired on some browsers but not all of them
                elm.onerror = error;
                // Add script to document
                (doc.head || doc.body).appendChild(elm);
            });
        }
        /**
         * Returns true/false if a script has been loaded or not.
         *
         * @method isDone
         * @param {String} url URL to check for.
         * @return {Boolean} true/false if the URL is loaded.
         */
        isDone(url) {
            return this.states[url] === LOADED;
        }
        /**
         * Marks a specific script to be loaded. This can be useful if a script got loaded outside
         * the script loader or to skip it from loading some script.
         *
         * @method markDone
         * @param {String} url Absolute URL to the script to mark as loaded.
         */
        markDone(url) {
            this.states[url] = LOADED;
        }
        /**
         * Adds a specific script to the load queue of the script loader.
         *
         * @method add
         * @param {String} url Absolute URL to script to add.
         * @return {Promise} A promise that will resolve when the script loaded successfully or reject if it failed to load.
         */
        add(url) {
            const self = this;
            self.queue.push(url);
            // Add url to load queue
            const state = self.states[url];
            if (state === undefined) {
                self.states[url] = QUEUED;
            }
            return new Promise((resolve, reject) => {
                // Store away callback for later execution
                if (!self.scriptLoadedCallbacks[url]) {
                    self.scriptLoadedCallbacks[url] = [];
                }
                self.scriptLoadedCallbacks[url].push({
                    resolve,
                    reject
                });
            });
        }
        load(url) {
            return this.add(url);
        }
        remove(url) {
            delete this.states[url];
            delete this.scriptLoadedCallbacks[url];
        }
        /**
         * Starts the loading of the queue.
         *
         * @method loadQueue
         * @return {Promise} A promise that is resolved when all queued items are loaded or rejected with the script urls that failed to load.
         */
        loadQueue() {
            const queue = this.queue;
            this.queue = [];
            return this.loadScripts(queue);
        }
        /**
         * Loads the specified queue of files and executes the callback ones they are loaded.
         * This method is generally not used outside this class but it might be useful in some scenarios.
         *
         * @method loadScripts
         * @param {Array} scripts Array of queue items to load.
         * @return {Promise} A promise that is resolved when all scripts are loaded or rejected with the script urls that failed to load.
         */
        loadScripts(scripts) {
            const self = this;
            const execCallbacks = (name, url) => {
                // Execute URL callback functions
                get$a(self.scriptLoadedCallbacks, url).each((callbacks) => {
                    each$e(callbacks, (callback) => callback[name](url));
                });
                delete self.scriptLoadedCallbacks[url];
            };
            const processResults = (results) => {
                const failures = filter$5(results, (result) => result.status === 'rejected');
                if (failures.length > 0) {
                    return Promise.reject(bind$3(failures, ({ reason }) => isArray$1(reason) ? reason : [reason]));
                }
                else {
                    return Promise.resolve();
                }
            };
            const load = (urls) => Promise.allSettled(map$3(urls, (url) => {
                // Script is already loaded then execute script callbacks directly
                if (self.states[url] === LOADED) {
                    execCallbacks('resolve', url);
                    return Promise.resolve();
                }
                else if (self.states[url] === FAILED) {
                    execCallbacks('reject', url);
                    return Promise.reject(url);
                }
                else {
                    // Script is not already loaded, so load it
                    self.states[url] = LOADING;
                    return self.loadScript(url).then(() => {
                        self.states[url] = LOADED;
                        execCallbacks('resolve', url);
                        // Immediately load additional scripts if any were added to the queue while loading this script
                        const queue = self.queue;
                        if (queue.length > 0) {
                            self.queue = [];
                            return load(queue).then(processResults);
                        }
                        else {
                            return Promise.resolve();
                        }
                    }, () => {
                        self.states[url] = FAILED;
                        execCallbacks('reject', url);
                        return Promise.reject(url);
                    });
                }
            }));
            const processQueue = (urls) => {
                self.loading = true;
                return load(urls).then((results) => {
                    self.loading = false;
                    // Start loading the next queued item
                    const nextQueuedItem = self.queueLoadedCallbacks.shift();
                    Optional.from(nextQueuedItem).each(call);
                    return processResults(results);
                });
            };
            // Wait for any other scripts to finish loading first, otherwise load immediately
            const uniqueScripts = stringArray(scripts);
            if (self.loading) {
                return new Promise((resolve, reject) => {
                    self.queueLoadedCallbacks.push(() => {
                        processQueue(uniqueScripts).then(resolve, reject);
                    });
                });
            }
            else {
                return processQueue(uniqueScripts);
            }
        }
        /**
         * Returns the attributes that should be added to a script tag when loading the specified URL.
         *
         * @method getScriptAttributes
         * @param {String} url Url to get attributes for.
         * @return {Object} Object with attributes to add to the script tag.
         */
        getScriptAttributes(url) {
            const attrs = {};
            if (this.settings.referrerPolicy) {
                attrs.referrerpolicy = this.settings.referrerPolicy;
            }
            const crossOrigin = this.settings.crossOrigin;
            if (isFunction(crossOrigin)) {
                const resultCrossOrigin = crossOrigin(url);
                if (isString(resultCrossOrigin)) {
                    attrs.crossorigin = resultCrossOrigin;
                }
            }
            return attrs;
        }
    }

const annotation = constant('mce-annotation');
    const dataAnnotation = constant('data-mce-annotation');
    const dataAnnotationId = constant('data-mce-annotation-uid');
    const dataAnnotationActive = constant('data-mce-annotation-active');
    const dataAnnotationClasses = constant('data-mce-annotation-classes');
    const dataAnnotationAttributes = constant('data-mce-annotation-attrs');

/**
 * The TextSeeker class enables you to seek for a specific point in text across the DOM.
 *
 * @class tinymce.dom.TextSeeker
 * @example
 * const seeker = tinymce.dom.TextSeeker(editor.dom);
 * const startOfWord = seeker.backwards(startNode, startOffset, (textNode, offset, text) => {
 * const lastSpaceCharIndex = text.lastIndexOf(' ');
 * if (lastSpaceCharIndex !== -1) {
 * return lastSpaceCharIndex + 1;
 * } else {
 * // No space found so continue searching
 * return -1;
 * }
 * });
 */
 /**
 * Constructs a new TextSeeker instance.
 *
 * @constructor
 * @param {tinymce.dom.DOMUtils} dom DOMUtils object reference.
 * @param {Function} isBoundary Optional function to determine if the seeker should continue to walk past the node provided. The default is to search until a block or <code>br</code> element is found.
 */
 const TextSeeker = (dom, isBoundary) => {
 const isBlockBoundary = isBoundary ? isBoundary : (node) => dom.isBlock(node) || isBr$7(node) || isContentEditableFalse$a(node);
 const walk = (node, offset, walker, process) => {
 if (isText$b(node)) {
 const newOffset = process(node, offset, node.data);
 if (newOffset !== -1) {
 return Optional.some({ container: node, offset: newOffset });
 }
 }
 return walker().bind((next) => walk(next.container, next.offset, walker, process));
 };
 /**
 * Search backwards through text nodes until a match, boundary, or root node has been found.
 *
 * @method backwards
 * @param {Node} node The node to start searching from.
 * @param {Number} offset The offset of the node to start searching from.
 * @param {Function} process A function that's passed the current text node, the current offset and the text content of the node. It should return the offset of the match or -1 to continue searching.
 * @param {Node} root An optional root node to constrain the search to.
 * @return {Object} An object containing the matched text node and offset. If no match is found, null will be returned.
 */
 const backwards = (node, offset, process, root) => {
 const walker = TextWalker(node, root ?? dom.getRoot(), isBlockBoundary);
 return walk(node, offset, () => walker.prev().map((prev) => ({ container: prev, offset: prev.length })), process).getOrNull();
 };
 /**
 * Search forwards through text nodes until a match, boundary, or root node has been found.
 *
 * @method forwards
 * @param {Node} node The node to start searching from.
 * @param {Number} offset The offset of the node to start searching from.
 * @param {Function} process A function that's passed the current text node, the current offset and the text content of the node. It should return the offset of the match or -1 to continue searching.
 * @param {Node} root An optional root node to constrain the search to.
 * @return {Object} An object containing the matched text node and offset. If no match is found, null will be returned.
 */
 const forwards = (node, offset, process, root) => {
 const walker = TextWalker(node, root ?? dom.getRoot(), isBlockBoundary);
 return walk(node, offset, () => walker.next().map((next) => ({ container: next, offset: 0 })), process).getOrNull();
 };
 return {
 backwards,
 forwards
 };
 };

const tableCells = ['td', 'th'];
    const tableSections = ['thead', 'tbody', 'tfoot'];
    const textBlocks = [
        'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'div', 'address', 'pre', 'form',
        'blockquote', 'center', 'dir', 'fieldset', 'header', 'footer', 'article',
        'section', 'hgroup', 'aside', 'nav', 'figure'
    ];
    const listItems$1 = ['li', 'dd', 'dt'];
    const lists = ['ul', 'ol', 'dl'];
    const wsElements = ['pre', 'script', 'textarea', 'style'];
    const lazyLookup = (items) => {
        let lookup;
        return (node) => {
            lookup = lookup ? lookup : mapToObject(items, always);
            return has$2(lookup, name(node));
        };
    };
    // WARNING: don't add anything to this file, the intention is to move these checks into the Schema
    const isTable$1 = (node) => name(node) === 'table';
    const isBr$6 = (node) => isElement$8(node) && name(node) === 'br';
    const isTextBlock$3 = lazyLookup(textBlocks);
    const isList$1 = lazyLookup(lists);
    const isListItem$2 = lazyLookup(listItems$1);
    const isTableSection = lazyLookup(tableSections);
    const isTableCell$2 = lazyLookup(tableCells);
    const isWsPreserveElement = lazyLookup(wsElements);

/**
     * Utility functions for working with zero width space
     * characters used as character containers etc.
     *
     * @private
     * @class tinymce.text.Zwsp
     * @example
     * const isZwsp = Zwsp.isZwsp('\uFEFF');
     * const abc = Zwsp.trim('a\uFEFFc');
     */
    // This is technically not a ZWSP but a ZWNBSP or a BYTE ORDER MARK it used to be a ZWSP
    const ZWSP$1 = zeroWidth;
    const isZwsp = isZwsp$2;
    const trim$2 = removeZwsp;
    const insert$5 = (editor) => editor.insertContent(ZWSP$1, { preserve_zwsp: true });

/**
     * This module handles caret containers. A caret container is a node that
     * holds the caret for positional purposes.
     *
     * @private
     * @class tinymce.caret.CaretContainer
     */
    const isElement$6 = isElement$7;
    const isText$9 = isText$b;
    const isCaretContainerBlock$1 = (node) => {
        if (isText$9(node)) {
            node = node.parentNode;
        }
        return isElement$6(node) && node.hasAttribute('data-mce-caret');
    };
    const isCaretContainerInline = (node) => isText$9(node) && isZwsp(node.data);
    const isCaretContainer$2 = (node) => isCaretContainerBlock$1(node) || isCaretContainerInline(node);
    const hasContent = (node) => node.firstChild !== node.lastChild || !isBr$7(node.firstChild);
    const insertInline$1 = (node, before) => {
        const doc = node.ownerDocument ?? document;
        const textNode = doc.createTextNode(ZWSP$1);
        const parentNode = node.parentNode;
        if (!before) {
            const sibling = node.nextSibling;
            if (isText$9(sibling)) {
                if (isCaretContainer$2(sibling)) {
                    return sibling;
                }
                if (startsWithCaretContainer$1(sibling)) {
                    sibling.splitText(1);
                    return sibling;
                }
            }
            if (node.nextSibling) {
                parentNode?.insertBefore(textNode, node.nextSibling);
            }
            else {
                parentNode?.appendChild(textNode);
            }
        }
        else {
            const sibling = node.previousSibling;
            if (isText$9(sibling)) {
                if (isCaretContainer$2(sibling)) {
                    return sibling;
                }
                if (endsWithCaretContainer$1(sibling)) {
                    return sibling.splitText(sibling.data.length - 1);
                }
            }
            parentNode?.insertBefore(textNode, node);
        }
        return textNode;
    };
    const isBeforeInline = (pos) => {
        const container = pos.container();
        if (!isText$b(container)) {
            return false;
        }
        // The text nodes may not be normalized, so check the current node and the previous one
        return container.data.charAt(pos.offset()) === ZWSP$1 || pos.isAtStart() && isCaretContainerInline(container.previousSibling);
    };
    const isAfterInline = (pos) => {
        const container = pos.container();
        if (!isText$b(container)) {
            return false;
        }
        // The text nodes may not be normalized, so check the current node and the next one
        return container.data.charAt(pos.offset() - 1) === ZWSP$1 || pos.isAtEnd() && isCaretContainerInline(container.nextSibling);
    };
    const insertBlock = (blockName, node, before) => {
        const doc = node.ownerDocument ?? document;
        const blockNode = doc.createElement(blockName);
        blockNode.setAttribute('data-mce-caret', before ? 'before' : 'after');
        blockNode.setAttribute('data-mce-bogus', 'all');
        blockNode.appendChild(createPaddingBr().dom);
        const parentNode = node.parentNode;
        if (!before) {
            if (node.nextSibling) {
                parentNode?.insertBefore(blockNode, node.nextSibling);
            }
            else {
                parentNode?.appendChild(blockNode);
            }
        }
        else {
            parentNode?.insertBefore(blockNode, node);
        }
        return blockNode;
    };
    const startsWithCaretContainer$1 = (node) => isText$9(node) && node.data[0] === ZWSP$1;
    const endsWithCaretContainer$1 = (node) => isText$9(node) && node.data[node.data.length - 1] === ZWSP$1;
    const trimBogusBr = (elm) => {
        const brs = elm.getElementsByTagName('br');
        const lastBr = brs[brs.length - 1];
        if (isBogus$1(lastBr)) {
            lastBr.parentNode?.removeChild(lastBr);
        }
    };
    const showCaretContainerBlock = (caretContainer) => {
        if (caretContainer && caretContainer.hasAttribute('data-mce-caret')) {
            trimBogusBr(caretContainer);
            caretContainer.removeAttribute('data-mce-caret');
            caretContainer.removeAttribute('data-mce-bogus');
            caretContainer.removeAttribute('style');
            caretContainer.removeAttribute('data-mce-style');
            caretContainer.removeAttribute('_moz_abspos');
            return caretContainer;
        }
        return null;
    };
    const isRangeInCaretContainerBlock = (range) => isCaretContainerBlock$1(range.startContainer);

/**
     * This class contains logic for detecting extending characters.
     *
     * @private
     * @class tinymce.text.ExtendingChar
     * @example
     * const isExtending = ExtendingChar.isExtendingChar('a');
     */
    // Generated from: http://www.unicode.org/Public/UNIDATA/DerivedCoreProperties.txt
    // Only includes the characters in that fit into UCS-2 16 bit
    const extendingChars = new RegExp('[\u0300-\u036F\u0483-\u0487\u0488-\u0489\u0591-\u05BD\u05BF\u05C1-\u05C2\u05C4-\u05C5\u05C7\u0610-\u061A' +
        '\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7-\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0' +
        '\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E3-\u0902\u093A\u093C' +
        '\u0941-\u0948\u094D\u0951-\u0957\u0962-\u0963\u0981\u09BC\u09BE\u09C1-\u09C4\u09CD\u09D7\u09E2-\u09E3' +
        '\u0A01-\u0A02\u0A3C\u0A41-\u0A42\u0A47-\u0A48\u0A4B-\u0A4D\u0A51\u0A70-\u0A71\u0A75\u0A81-\u0A82\u0ABC' +
        '\u0AC1-\u0AC5\u0AC7-\u0AC8\u0ACD\u0AE2-\u0AE3\u0B01\u0B3C\u0B3E\u0B3F\u0B41-\u0B44\u0B4D\u0B56\u0B57' +
        '\u0B62-\u0B63\u0B82\u0BBE\u0BC0\u0BCD\u0BD7\u0C00\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55-\u0C56' +
        '\u0C62-\u0C63\u0C81\u0CBC\u0CBF\u0CC2\u0CC6\u0CCC-\u0CCD\u0CD5-\u0CD6\u0CE2-\u0CE3\u0D01\u0D3E\u0D41-\u0D44' +
        '\u0D4D\u0D57\u0D62-\u0D63\u0DCA\u0DCF\u0DD2-\u0DD4\u0DD6\u0DDF\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9' +
        '\u0EBB-\u0EBC\u0EC8-\u0ECD\u0F18-\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86-\u0F87\u0F8D-\u0F97' +
        '\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039-\u103A\u103D-\u103E\u1058-\u1059\u105E-\u1060\u1071-\u1074' +
        '\u1082\u1085-\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17B4-\u17B5' +
        '\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193B\u1A17-\u1A18' +
        '\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ABD\u1ABE\u1B00-\u1B03\u1B34' +
        '\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80-\u1B81\u1BA2-\u1BA5\u1BA8-\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8-\u1BE9' +
        '\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8-\u1CF9' +
        '\u1DC0-\u1DF5\u1DFC-\u1DFF\u200C-\u200D\u20D0-\u20DC\u20DD-\u20E0\u20E1\u20E2-\u20E4\u20E5-\u20F0\u2CEF-\u2CF1' +
        '\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u302E-\u302F\u3099-\u309A\uA66F\uA670-\uA672\uA674-\uA67D\uA69E-\uA69F\uA6F0-\uA6F1' +
        '\uA802\uA806\uA80B\uA825-\uA826\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC' +
        '\uA9E5\uAA29-\uAA2E\uAA31-\uAA32\uAA35-\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7-\uAAB8\uAABE-\uAABF\uAAC1' +
        '\uAAEC-\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFF9E-\uFF9F]');
    const isExtendingChar = (ch) => isString(ch) && ch.charCodeAt(0) >= 768 && extendingChars.test(ch);

/**
     * This module contains logic for handling caret candidates. A caret candidate is
     * for example text nodes, images, input elements, cE=false elements etc.
     *
     * @private
     * @class tinymce.caret.CaretCandidate
     */
    const isContentEditableTrue$2 = isContentEditableTrue$3;
    const isContentEditableFalse$9 = isContentEditableFalse$a;
    const isBr$5 = isBr$7;
    const isText$8 = isText$b;
    const isInvalidTextElement = matchNodeNames$1(['script', 'style', 'textarea']);
    const isAtomicInline = matchNodeNames$1(['img', 'input', 'textarea', 'hr', 'iframe', 'video', 'audio', 'object', 'embed']);
    const isTable = matchNodeNames$1(['table']);
    const isCaretContainer$1 = isCaretContainer$2;
    const isCaretCandidate$3 = (node) => {
        if (isCaretContainer$1(node)) {
            return false;
        }
        if (isText$8(node)) {
            return !isInvalidTextElement(node.parentNode);
        }
        return isAtomicInline(node) || isBr$5(node) || isTable(node) || isNonUiContentEditableFalse(node);
    };
    // UI components on IE is marked with contenteditable=false and unselectable=true so lets not handle those as real content editables
    const isUnselectable = (node) => isElement$7(node) && node.getAttribute('unselectable') === 'true';
    const isNonUiContentEditableFalse = (node) => !isUnselectable(node) && isContentEditableFalse$9(node);
    const isInEditable = (node, root) => {
        for (let tempNode = node.parentNode; tempNode && tempNode !== root; tempNode = tempNode.parentNode) {
            if (isNonUiContentEditableFalse(tempNode)) {
                return false;
            }
            if (isContentEditableTrue$2(tempNode)) {
                return true;
            }
        }
        return true;
    };
    const isAtomicContentEditableFalse = (node) => {
        if (!isNonUiContentEditableFalse(node)) {
            return false;
        }
        return !foldl(from(node.getElementsByTagName('*')), (result, elm) => {
            return result || isContentEditableTrue$2(elm);
        }, false);
    };
    const isAtomic$1 = (node) => isAtomicInline(node) || isAtomicContentEditableFalse(node);
    const isEditableCaretCandidate$1 = (node, root) => isCaretCandidate$3(node) && isInEditable(node, root);

/**
 * This module contains logic for creating caret positions within a document a caretposition
 * is similar to a DOMRange object but it doesn't have two endpoints and is also more lightweight
 * since it's now updated live when the DOM changes.
 *
 * @private
 * @class tinymce.caret.CaretPosition
 * @example
 * const caretPos1 = CaretPosition(container, offset);
 * const caretPos2 = CaretPosition.fromRangeStart(someRange);
 */
 const isElement$5 = isElement$7;
 const isCaretCandidate$2 = isCaretCandidate$3;
 const isBlock$3 = matchStyleValues('display', 'block table');
 const isFloated = matchStyleValues('float', 'left right');
 const isValidElementCaretCandidate = and(isElement$5, isCaretCandidate$2, not(isFloated));
 const isNotPre = not(matchStyleValues('white-space', 'pre pre-line pre-wrap'));
 const isText$7 = isText$b;
 const isBr$4 = isBr$7;
 const nodeIndex$1 = DOMUtils.nodeIndex;
 const resolveIndex$1 = getNodeUnsafe;
 const createRange$1 = (doc) => doc ? doc.createRange() : DOMUtils.DOM.createRng();
 const isWhiteSpace$1 = (chr) => isString(chr) && /[\r\n\t ]/.test(chr);
 const isRange = (rng) => !!rng.setStart && !!rng.setEnd;
 const isHiddenWhiteSpaceRange = (range) => {
 const container = range.startContainer;
 const offset = range.startOffset;
 if (isWhiteSpace$1(range.toString()) && isNotPre(container.parentNode) && isText$b(container)) {
 const text = container.data;
 if (isWhiteSpace$1(text[offset - 1]) || isWhiteSpace$1(text[offset + 1])) {
 return true;
 }
 }
 return false;
 };
 // Hack for older WebKit versions that doesn't
 // support getBoundingClientRect on BR elements
 const getBrClientRect = (brNode) => {
 const doc = brNode.ownerDocument;
 const rng = createRange$1(doc);
 const nbsp$1 = doc.createTextNode(nbsp);
 const parentNode = brNode.parentNode;
 parentNode.insertBefore(nbsp$1, brNode);
 rng.setStart(nbsp$1, 0);
 rng.setEnd(nbsp$1, 1);
 const clientRect = clone$1(rng.getBoundingClientRect());
 parentNode.removeChild(nbsp$1);
 return clientRect;
 };
 // Safari will not return a rect for a |b for some odd reason
 const getBoundingClientRectWebKitText = (rng) => {
 const sc = rng.startContainer;
 const ec = rng.endContainer;
 const so = rng.startOffset;
 const eo = rng.endOffset;
 if (sc === ec && isText$b(ec) && so === 0 && eo === 1) {
 const newRng = rng.cloneRange();
 newRng.setEndAfter(ec);
 return getBoundingClientRect$1(newRng);
 }
 else {
 return null;
 }
 };
 const isZeroRect = (r) => r.left === 0 && r.right === 0 && r.top === 0 && r.bottom === 0;
 const getBoundingClientRect$1 = (item) => {
 let clientRect;
 const clientRects = item.getClientRects();
 if (clientRects.length > 0) {
 clientRect = clone$1(clientRects[0]);
 }
 else {
 clientRect = clone$1(item.getBoundingClientRect());
 }
 if (!isRange(item) && isBr$4(item) && isZeroRect(clientRect)) {
 return getBrClientRect(item);
 }
 if (isZeroRect(clientRect) && isRange(item)) {
 return getBoundingClientRectWebKitText(item) ?? clientRect;
 }
 return clientRect;
 };
 const collapseAndInflateWidth = (clientRect, toStart) => {
 const newClientRect = collapse(clientRect, toStart);
 newClientRect.width = 1;
 newClientRect.right = newClientRect.left + 1;
 return newClientRect;
 };
 const getCaretPositionClientRects = (caretPosition) => {
 const clientRects = [];
 const addUniqueAndValidRect = (clientRect) => {
 if (clientRect.height === 0) {
 return;
 }
 if (clientRects.length > 0) {
 if (isEqual(clientRect, clientRects[clientRects.length - 1])) {
 return;
 }
 }
 clientRects.push(clientRect);
 };
 const addCharacterOffset = (container, offset) => {
 const range = createRange$1(container.ownerDocument);
 if (offset < container.data.length) {
 if (isExtendingChar(container.data[offset])) {
 return;
 }
 // WebKit returns two client rects for a position after an extending
 // character a\uxxx|b so expand on "b" and collapse to start of "b" box
 if (isExtendingChar(container.data[offset - 1])) {
 range.setStart(container, offset);
 range.setEnd(container, offset + 1);
 if (!isHiddenWhiteSpaceRange(range)) {
 addUniqueAndValidRect(collapseAndInflateWidth(getBoundingClientRect$1(range), false));
 return;
 }
 }
 }
 if (offset > 0) {
 range.setStart(container, offset - 1);
 range.setEnd(container, offset);
 if (!isHiddenWhiteSpaceRange(range)) {
 addUniqueAndValidRect(collapseAndInflateWidth(getBoundingClientRect$1(range), false));
 }
 }
 if (offset < container.data.length) {
 range.setStart(container, offset);
 range.setEnd(container, offset + 1);
 if (!isHiddenWhiteSpaceRange(range)) {
 addUniqueAndValidRect(collapseAndInflateWidth(getBoundingClientRect$1(range), true));
 }
 }
 };
 const container = caretPosition.container();
 const offset = caretPosition.offset();
 if (isText$7(container)) {
 addCharacterOffset(container, offset);
 return clientRects;
 }
 if (isElement$5(container)) {
 if (caretPosition.isAtEnd()) {
 const node = resolveIndex$1(container, offset);
 if (isText$7(node)) {
 addCharacterOffset(node, node.data.length);
 }
 if (isValidElementCaretCandidate(node) && !isBr$4(node)) {
 addUniqueAndValidRect(collapseAndInflateWidth(getBoundingClientRect$1(node), false));
 }
 }
 else {
 const node = resolveIndex$1(container, offset);
 if (isText$7(node)) {
 addCharacterOffset(node, 0);
 }
 if (isValidElementCaretCandidate(node) && caretPosition.isAtEnd()) {
 addUniqueAndValidRect(collapseAndInflateWidth(getBoundingClientRect$1(node), false));
 return clientRects;
 }
 const beforeNode = resolveIndex$1(caretPosition.container(), caretPosition.offset() - 1);
 if (isValidElementCaretCandidate(beforeNode) && !isBr$4(beforeNode)) {
 if (isBlock$3(beforeNode) || isBlock$3(node) || !isValidElementCaretCandidate(node)) {
 addUniqueAndValidRect(collapseAndInflateWidth(getBoundingClientRect$1(beforeNode), false));
 }
 }
 if (isValidElementCaretCandidate(node)) {
 addUniqueAndValidRect(collapseAndInflateWidth(getBoundingClientRect$1(node), true));
 }
 }
 }
 return clientRects;
 };
 /**
 * Represents a location within the document by a container and an offset.
 *
 * @constructor
 * @param {Node} container Container node.
 * @param {Number} offset Offset within that container node.
 * @param {Array} clientRects Optional client rects array for the position.
 */
 const CaretPosition = (container, offset, clientRects) => {
 const isAtStart = () => {
 if (isText$7(container)) {
 return offset === 0;
 }
 return offset === 0;
 };
 const isAtEnd = () => {
 if (isText$7(container)) {
 return offset >= container.data.length;
 }
 return offset >= container.childNodes.length;
 };
 const toRange = () => {
 const range = createRange$1(container.ownerDocument);
 range.setStart(container, offset);
 range.setEnd(container, offset);
 return range;
 };
 const getClientRects = () => {
 if (!clientRects) {
 clientRects = getCaretPositionClientRects(CaretPosition(container, offset));
 }
 return clientRects;
 };
 const isVisible = () => getClientRects().length > 0;
 const isEqual = (caretPosition) => caretPosition && container === caretPosition.container() && offset === caretPosition.offset();
 const getNode = (before) => resolveIndex$1(container, before ? offset - 1 : offset);
 return {
 /**
 * Returns the container node.
 *
 * @method container
 * @return {Node} Container node.
 */
 container: constant(container),
 /**
 * Returns the offset within the container node.
 *
 * @method offset
 * @return {Number} Offset within the container node.
 */
 offset: constant(offset),
 /**
 * Returns a range out of a the caret position.
 *
 * @method toRange
 * @return {DOMRange} range for the caret position.
 */
 toRange,
 /**
 * Returns the client rects for the caret position. Might be multiple rects between
 * block elements.
 *
 * @method getClientRects
 * @return {Array} Array of client rects.
 */
 getClientRects,
 /**
 * Returns true if the caret location is visible/displayed on screen.
 *
 * @method isVisible
 * @return {Boolean} true/false if the position is visible or not.
 */
 isVisible,
 /**
 * Returns true if the caret location is at the beginning of text node or container.
 *
 * @method isVisible
 * @return {Boolean} true/false if the position is at the beginning.
 */
 isAtStart,
 /**
 * Returns true if the caret location is at the end of text node or container.
 *
 * @method isVisible
 * @return {Boolean} true/false if the position is at the end.
 */
 isAtEnd,
 /**
 * Compares the caret position to another caret position. This will only compare the
 * container and offset not it's visual position.
 *
 * @method isEqual
 * @param {tinymce.caret.CaretPosition} caretPosition Caret position to compare with.
 * @return {Boolean} true if the caret positions are equal.
 */
 isEqual,
 /**
 * Returns the closest resolved node from a node index. That means if you have an offset after the
 * last node in a container it will return that last node.
 *
 * @method getNode
 * @return {Node} Node that is closest to the index.
 */
 getNode
 };
 };
 /**
 * Creates a caret position from the start of a range.
 *
 * @method fromRangeStart
 * @param {DOMRange} range DOM Range to create caret position from.
 * @return {tinymce.caret.CaretPosition} Caret position from the start of DOM range.
 */
 CaretPosition.fromRangeStart = (range) => CaretPosition(range.startContainer, range.startOffset);
 /**
 * Creates a caret position from the end of a range.
 *
 * @method fromRangeEnd
 * @param {DOMRange} range DOM Range to create caret position from.
 * @return {tinymce.caret.CaretPosition} Caret position from the end of DOM range.
 */
 CaretPosition.fromRangeEnd = (range) => CaretPosition(range.endContainer, range.endOffset);
 /**
 * Creates a caret position from a node and places the offset after it.
 *
 * @method after
 * @param {Node} node Node to get caret position from.
 * @return {tinymce.caret.CaretPosition} Caret position from the node.
 */
 // TODO: TINY-8865 - This may not be safe to cast as Node and alternative solutions need to be looked into
 CaretPosition.after = (node) => CaretPosition(node.parentNode, nodeIndex$1(node) + 1);
 /**
 * Creates a caret position from a node and places the offset before it.
 *
 * @method before
 * @param {Node} node Node to get caret position from.
 * @return {tinymce.caret.CaretPosition} Caret position from the node.
 */
 // TODO: TINY-8865 - This may not be safe to cast as Node and alternative solutions need to be looked into
 CaretPosition.before = (node) => CaretPosition(node.parentNode, nodeIndex$1(node));
 CaretPosition.isAbove = (pos1, pos2) => lift2(head(pos2.getClientRects()), last$2(pos1.getClientRects()), isAbove$1).getOr(false);
 CaretPosition.isBelow = (pos1, pos2) => lift2(last$2(pos2.getClientRects()), head(pos1.getClientRects()), isBelow$1).getOr(false);
 CaretPosition.isAtStart = (pos) => pos ? pos.isAtStart() : false;
 CaretPosition.isAtEnd = (pos) => pos ? pos.isAtEnd() : false;
 CaretPosition.isTextPosition = (pos) => pos ? isText$b(pos.container()) : false;
 CaretPosition.isElementPosition = (pos) => !CaretPosition.isTextPosition(pos);

/**
 * This module creates or resolves xpath like string representation of a CaretPositions.
 *
 * The format is a / separated list of chunks with:
 * <element|text()>[index|after|before]
 *
 * For example:
 * p[0]/b[0]/text()[0],1 = a|c
 * p[0]/img[0],before = |<img>
 * p[0]/img[0],after = <img>|
 *
 * @private
 * @static
 * @class tinymce.caret.CaretBookmark
 * @example
 * const bookmark = CaretBookmark.create(rootElm, CaretPosition.before(rootElm.firstChild));
 * const caretPosition = CaretBookmark.resolve(bookmark);
 */
 const isText$6 = isText$b;
 const isBogus = isBogus$1;
 const nodeIndex = DOMUtils.nodeIndex;
 const normalizedParent = (node) => {
 const parentNode = node.parentNode;
 if (isBogus(parentNode)) {
 return normalizedParent(parentNode);
 }
 return parentNode;
 };
 const getChildNodes = (node) => {
 if (!node) {
 return [];
 }
 return reduce(node.childNodes, (result, node) => {
 if (isBogus(node) && node.nodeName !== 'BR') {
 result = result.concat(getChildNodes(node));
 }
 else {
 result.push(node);
 }
 return result;
 }, []);
 };
 const normalizedTextOffset = (node, offset) => {
 let tempNode = node;
 while ((tempNode = tempNode.previousSibling)) {
 if (!isText$6(tempNode)) {
 break;
 }
 offset += tempNode.data.length;
 }
 return offset;
 };
 const equal = (a) => (b) => a === b;
 const normalizedNodeIndex = (node) => {
 let nodes, index;
 nodes = getChildNodes(normalizedParent(node));
 index = findIndex$1(nodes, equal(node), node);
 nodes = nodes.slice(0, index + 1);
 const numTextFragments = reduce(nodes, (result, node, i) => {
 if (isText$6(node) && isText$6(nodes[i - 1])) {
 result++;
 }
 return result;
 }, 0);
 nodes = filter$3(nodes, matchNodeNames$1([node.nodeName]));
 index = findIndex$1(nodes, equal(node), node);
 return index - numTextFragments;
 };
 const createPathItem = (node) => {
 const name = isText$6(node) ? 'text()' : node.nodeName.toLowerCase();
 return name + '[' + normalizedNodeIndex(node) + ']';
 };
 const parentsUntil$1 = (root, node, predicate) => {
 const parents = [];
 for (let tempNode = node.parentNode; tempNode && tempNode !== root; tempNode = tempNode.parentNode) {
 if (predicate && predicate(tempNode)) {
 break;
 }
 parents.push(tempNode);
 }
 return parents;
 };
 const create$9 = (root, caretPosition) => {
 let path = [];
 let container = caretPosition.container();
 let offset = caretPosition.offset();
 let outputOffset;
 if (isText$6(container)) {
 outputOffset = normalizedTextOffset(container, offset);
 }
 else {
 const childNodes = container.childNodes;
 if (offset >= childNodes.length) {
 outputOffset = 'after';
 offset = childNodes.length - 1;
 }
 else {
 outputOffset = 'before';
 }
 container = childNodes[offset];
 }
 path.push(createPathItem(container));
 let parents = parentsUntil$1(root, container);
 parents = filter$3(parents, not(isBogus$1));
 path = path.concat(map$1(parents, (node) => {
 return createPathItem(node);
 }));
 return path.reverse().join('/') + ',' + outputOffset;
 };
 const resolvePathItem = (node, name, index) => {
 let nodes = getChildNodes(node);
 nodes = filter$3(nodes, (node, index) => {
 return !isText$6(node) || !isText$6(nodes[index - 1]);
 });
 nodes = filter$3(nodes, matchNodeNames$1([name]));
 return nodes[index];
 };
 const findTextPosition = (container, offset) => {
 let node = container;
 let targetOffset = 0;
 while (isText$6(node)) {
 const dataLen = node.data.length;
 if (offset >= targetOffset && offset <= targetOffset + dataLen) {
 container = node;
 offset = offset - targetOffset;
 break;
 }
 if (!isText$6(node.nextSibling)) {
 container = node;
 offset = dataLen;
 break;
 }
 targetOffset += dataLen;
 node = node.nextSibling;
 }
 if (isText$6(container) && offset > container.data.length) {
 offset = container.data.length;
 }
 return CaretPosition(container, offset);
 };
 const resolve$1 = (root, path) => {
 if (!path) {
 return null;
 }
 const parts = path.split(',');
 const paths = parts[0].split('/');
 const offset = parts.length > 1 ? parts[1] : 'before';
 const container = reduce(paths, (result, value) => {
 const match = /([\w\-]+)\[([0-9]+)\]/.exec(value);
 if (!match) {
 return null;
 }
 if (match[1] === 'text()') {
 match[1] = '#text';
 }
 return resolvePathItem(result, match[1], parseInt(match[2], 10));
 }, root);
 if (!container) {
 return null;
 }
 if (!isText$6(container) && container.parentNode) {
 let nodeOffset;
 if (offset === 'after') {
 nodeOffset = nodeIndex(container) + 1;
 }
 else {
 nodeOffset = nodeIndex(container);
 }
 return CaretPosition(container.parentNode, nodeOffset);
 }
 return findTextPosition(container, parseInt(offset, 10));
 };

/**
     * Checks if the direction is forwards.
     */
    const isForwards = (direction) => direction === 1 /* HDirection.Forwards */;
    /**
     * Checks if the direction is backwards.
     */
    const isBackwards = (direction) => direction === -1 /* HDirection.Backwards */;

var SimpleResultType;
    (function (SimpleResultType) {
        SimpleResultType[SimpleResultType["Error"] = 0] = "Error";
        SimpleResultType[SimpleResultType["Value"] = 1] = "Value";
    })(SimpleResultType || (SimpleResultType = {}));
    const fold$1 = (res, onError, onValue) => res.stype === SimpleResultType.Error ? onError(res.serror) : onValue(res.svalue);
    const partition = (results) => {
        const values = [];
        const errors = [];
        each$e(results, (obj) => {
            fold$1(obj, (err) => errors.push(err), (val) => values.push(val));
        });
        return { values, errors };
    };
    const mapError = (res, f) => {
        if (res.stype === SimpleResultType.Error) {
            return { stype: SimpleResultType.Error, serror: f(res.serror) };
        }
        else {
            return res;
        }
    };
    const map = (res, f) => {
        if (res.stype === SimpleResultType.Value) {
            return { stype: SimpleResultType.Value, svalue: f(res.svalue) };
        }
        else {
            return res;
        }
    };
    const bind = (res, f) => {
        if (res.stype === SimpleResultType.Value) {
            return f(res.svalue);
        }
        else {
            return res;
        }
    };
    const bindError = (res, f) => {
        if (res.stype === SimpleResultType.Error) {
            return f(res.serror);
        }
        else {
            return res;
        }
    };
    const svalue = (v) => ({ stype: SimpleResultType.Value, svalue: v });
    const serror = (e) => ({ stype: SimpleResultType.Error, serror: e });
    const toResult = (res) => fold$1(res, Result.error, Result.value);
    const fromResult = (res) => res.fold(serror, svalue);
    const SimpleResult = {
        fromResult,
        toResult,
        svalue,
        partition,
        serror,
        bind,
        bindError,
        map,
        mapError,
        fold: fold$1
    };

const nu = (path, getErrorInfo) => {
        return SimpleResult.serror([{
                path,
                // This is lazy so that it isn't calculated unnecessarily
                getErrorInfo
            }]);
    };
    const missingRequired = (path, key, obj) => nu(path, () => 'Could not find valid *required* value for "' + key + '" in ' + formatObj(obj));
    const custom = (path, err) => nu(path, constant(err));

const field = field$1;
    const required = (key) => field(key, key, required$1(), anyValue());
    const requiredOf = (key, schema) => field(key, key, required$1(), schema);
    const requiredString = (key) => requiredOf(key, string);
    const requiredFunction = (key) => requiredOf(key, functionProcessor);
    const requiredArrayOf = (key, schema) => field(key, key, required$1(), arrOf(schema));
    const option$1 = (key) => field(key, key, asOption(), anyValue());
    const optionOf = (key, schema) => field(key, key, asOption(), schema);
    const optionString = (key) => optionOf(key, string);
    const optionFunction = (key) => optionOf(key, functionProcessor);
    const defaulted = (key, fallback) => field(key, key, defaulted$1(fallback), anyValue());
    const defaultedOf = (key, fallback, schema) => field(key, key, defaulted$1(fallback), schema);
    const defaultedNumber = (key, fallback) => defaultedOf(key, fallback, number);
    const defaultedArrayOf = (key, fallback, schema) => defaultedOf(key, fallback, arrOf(schema));

/**
 * This module contains logic for moving around a virtual caret in logical order within a DOM element.
 *
 * It ignores the most obvious invalid caret locations such as within a script element or within a
 * contentEditable=false element but it will return locations that isn't possible to render visually.
 *
 * @private
 * @class tinymce.caret.CaretWalker
 * @example
 * const caretWalker = CaretWalker(rootElm);
 *
 * const prevLogicalCaretPosition = caretWalker.prev(CaretPosition.fromRangeStart(range));
 * const nextLogicalCaretPosition = caretWalker.next(CaretPosition.fromRangeEnd(range));
 */
 const isContentEditableFalse$5 = isContentEditableFalse$a;
 const isText$3 = isText$b;
 const isElement$2 = isElement$7;
 const isBr$3 = isBr$7;
 const isCaretCandidate = isCaretCandidate$3;
 const isAtomic = isAtomic$1;
 const isEditableCaretCandidate = isEditableCaretCandidate$1;
 const getParents$3 = (node, root) => {
 const parents = [];
 let tempNode = node;
 while (tempNode && tempNode !== root) {
 parents.push(tempNode);
 tempNode = tempNode.parentNode;
 }
 return parents;
 };
 const nodeAtIndex = (container, offset) => {
 if (container.hasChildNodes() && offset < container.childNodes.length) {
 return container.childNodes[offset];
 }
 return null;
 };
 const getCaretCandidatePosition = (direction, node) => {
 if (isForwards(direction)) {
 if (isCaretCandidate(node.previousSibling) && !isText$3(node.previousSibling)) {
 return CaretPosition.before(node);
 }
 if (isText$3(node)) {
 return CaretPosition(node, 0);
 }
 }
 if (isBackwards(direction)) {
 if (isCaretCandidate(node.nextSibling) && !isText$3(node.nextSibling)) {
 return CaretPosition.after(node);
 }
 if (isText$3(node)) {
 return CaretPosition(node, node.data.length);
 }
 }
 if (isBackwards(direction)) {
 if (isBr$3(node)) {
 return CaretPosition.before(node);
 }
 return CaretPosition.after(node);
 }
 return CaretPosition.before(node);
 };
 const moveForwardFromBr = (root, nextNode) => {
 const nextSibling = nextNode.nextSibling;
 if (nextSibling && isCaretCandidate(nextSibling)) {
 if (isText$3(nextSibling)) {
 return CaretPosition(nextSibling, 0);
 }
 else {
 return CaretPosition.before(nextSibling);
 }
 }
 else {
 return findCaretPosition$1(1 /* HDirection.Forwards */, CaretPosition.after(nextNode), root);
 }
 };
 const findCaretPosition$1 = (direction, startPos, root) => {
 let node;
 let nextNode;
 let innerNode;
 let caretPosition;
 if (!isElement$2(root) || !startPos) {
 return null;
 }
 if (startPos.isEqual(CaretPosition.after(root)) && root.lastChild) {
 caretPosition = CaretPosition.after(root.lastChild);
 if (isBackwards(direction) && isCaretCandidate(root.lastChild) && isElement$2(root.lastChild)) {
 return isBr$3(root.lastChild) ? CaretPosition.before(root.lastChild) : caretPosition;
 }
 }
 else {
 caretPosition = startPos;
 }
 const container = caretPosition.container();
 let offset = caretPosition.offset();
 if (isText$3(container)) {
 if (isBackwards(direction) && offset > 0) {
 return CaretPosition(container, --offset);
 }
 if (isForwards(direction) && offset < container.length) {
 return CaretPosition(container, ++offset);
 }
 node = container;
 }
 else {
 if (isBackwards(direction) && offset > 0) {
 nextNode = nodeAtIndex(container, offset - 1);
 if (isCaretCandidate(nextNode)) {
 if (!isAtomic(nextNode)) {
 innerNode = findNode(nextNode, direction, isEditableCaretCandidate, nextNode);
 if (innerNode) {
 if (isText$3(innerNode)) {
 return CaretPosition(innerNode, innerNode.data.length);
 }
 return CaretPosition.after(innerNode);
 }
 }
 if (isText$3(nextNode)) {
 return CaretPosition(nextNode, nextNode.data.length);
 }
 return CaretPosition.before(nextNode);
 }
 }
 if (isForwards(direction) && offset < container.childNodes.length) {
 nextNode = nodeAtIndex(container, offset);
 if (isCaretCandidate(nextNode)) {
 if (isBr$3(nextNode)) {
 return moveForwardFromBr(root, nextNode);
 }
 if (!isAtomic(nextNode)) {
 innerNode = findNode(nextNode, direction, isEditableCaretCandidate, nextNode);
 if (innerNode) {
 if (isText$3(innerNode)) {
 return CaretPosition(innerNode, 0);
 }
 return CaretPosition.before(innerNode);
 }
 }
 if (isText$3(nextNode)) {
 return CaretPosition(nextNode, 0);
 }
 return CaretPosition.after(nextNode);
 }
 }
 node = nextNode ? nextNode : caretPosition.getNode();
 }
 if (node && ((isForwards(direction) && caretPosition.isAtEnd()) || (isBackwards(direction) && caretPosition.isAtStart()))) {
 node = findNode(node, direction, always, root, true);
 if (isEditableCaretCandidate(node, root)) {
 return getCaretCandidatePosition(direction, node);
 }
 }
 nextNode = node ? findNode(node, direction, isEditableCaretCandidate, root) : node;
 const rootContentEditableFalseElm = last(filter$5(getParents$3(container, root), isContentEditableFalse$5));
 if (rootContentEditableFalseElm && (!nextNode || !rootContentEditableFalseElm.contains(nextNode))) {
 if (isForwards(direction)) {
 caretPosition = CaretPosition.after(rootContentEditableFalseElm);
 }
 else {
 caretPosition = CaretPosition.before(rootContentEditableFalseElm);
 }
 return caretPosition;
 }
 if (nextNode) {
 return getCaretCandidatePosition(direction, nextNode);
 }
 return null;
 };
 const CaretWalker = (root) => ({
 /**
 * Returns the next logical caret position from the specified input
 * caretPosition or null if there isn't any more positions left for example
 * at the end specified root element.
 *
 * @method next
 * @param {tinymce.caret.CaretPosition} caretPosition Caret position to start from.
 * @return {tinymce.caret.CaretPosition} CaretPosition or null if no position was found.
 */
 next: (caretPosition) => {
 return findCaretPosition$1(1 /* HDirection.Forwards */, caretPosition, root);
 },
 /**
 * Returns the previous logical caret position from the specified input
 * caretPosition or null if there isn't any more positions left for example
 * at the end specified root element.
 *
 * @method prev
 * @param {tinymce.caret.CaretPosition} caretPosition Caret position to start from.
 * @return {tinymce.caret.CaretPosition} CaretPosition or null if no position was found.
 */
 prev: (caretPosition) => {
 return findCaretPosition$1(-1 /* HDirection.Backwards */, caretPosition, root);
 }
 });

const isStringPathBookmark = (bookmark) => isString(bookmark.start);
    const isRangeBookmark = (bookmark) => has$2(bookmark, 'rng');
    const isIdBookmark = (bookmark) => has$2(bookmark, 'id');
    const isIndexBookmark = (bookmark) => has$2(bookmark, 'name');
    const isPathBookmark = (bookmark) => Tools.isArray(bookmark.start);

const is = (expected) => (actual) => expected === actual;
    const isNbsp = is(nbsp);
    const isWhiteSpace = (chr) => chr !== '' && ' \f\n\r\t\v'.indexOf(chr) !== -1;
    const isContent = (chr) => !isWhiteSpace(chr) && !isNbsp(chr) && !isZwsp$2(chr);

const getCellsFromRanges = (ranges) => filter$5(getSelectedNodes(ranges), isTableCell$2);
    const getCellsFromElement = (elm) => descendants(elm, 'td[data-mce-selected],th[data-mce-selected]');
    const getCellsFromElementOrRanges = (ranges, element) => {
        const selectedCells = getCellsFromElement(element);
        return selectedCells.length > 0 ? selectedCells : getCellsFromRanges(ranges);
    };
    const getCellsFromEditor = (editor) => getCellsFromElementOrRanges(getRanges(editor.selection.getSel()), SugarElement.fromDom(editor.getBody()));
    const getClosestTable = (cell, isRoot) => ancestor$4(cell, 'table', isRoot);

/**
     * Constructs a new BookmarkManager instance for a specific selection instance.
     *
     * @constructor
     * @method BookmarkManager
     * @param {tinymce.dom.Selection} selection Selection instance to handle bookmarks for.
     */
    const BookmarkManager = (selection) => {
        return {
            /**
             * Returns a bookmark location for the current selection. This bookmark object
             * can then be used to restore the selection after some content modification to the document.
             *
             * @method getBookmark
             * @param {Number} type Optional state if the bookmark should be simple or not. Default is complex.
             * @param {Boolean} normalized Optional state that enables you to get a position that it would be after normalization.
             * @return {Object} Bookmark object, use moveToBookmark with this object to restore the selection.
             * @example
             * // Stores a bookmark of the current selection
             * const bm = tinymce.activeEditor.selection.getBookmark();
             *
             * tinymce.activeEditor.setContent(tinymce.activeEditor.getContent() + 'Some new content');
             *
             * // Restore the selection bookmark
             * tinymce.activeEditor.selection.moveToBookmark(bm);
             */
            getBookmark: curry(getBookmark$1, selection),
            /**
             * Restores the selection to the specified bookmark.
             *
             * @method moveToBookmark
             * @param {Object} bookmark Bookmark to restore selection from.
             * @example
             * // Stores a bookmark of the current selection
             * const bm = tinymce.activeEditor.selection.getBookmark();
             *
             * tinymce.activeEditor.setContent(tinymce.activeEditor.getContent() + 'Some new content');
             *
             * // Restore the selection bookmark
             * tinymce.activeEditor.selection.moveToBookmark(bm);
             */
            moveToBookmark: curry(moveToBookmark, selection)
        };
    };
    /**
     * Returns true/false if the specified node is a bookmark node or not.
     *
     * @static
     * @method isBookmarkNode
     * @param {DOMNode} node DOM Node to check if it's a bookmark node or not.
     * @return {Boolean} true/false if the node is a bookmark node or not.
     */
    BookmarkManager.isBookmarkNode = isBookmarkNode$1;

/**
     * This class manages the focus/blur state of the editor. This class is needed since some
     * browsers fire false focus/blur states when the selection is moved to a UI dialog or similar.
     *
     * This class will fire two events focus and blur on the editor instances that got affected.
     * It will also handle the restore of selection when the focus is lost and returned.
     *
     * @class tinymce.FocusManager
     * @private
     */
    /**
     * Returns true if the specified element is part of the UI for example an button or text input.
     *
     * @static
     * @method isEditorUIElement
     * @param  {Element} elm Element to check if it's part of the UI or not.
     * @return {Boolean} True/false state if the element is part of the UI or not.
     */
    const isEditorUIElement$1 = (elm) => {
        // Needs to be converted to string since svg can have focus: #6776
        const className = elm.className.toString();
        return className.indexOf('tox-') !== -1 || className.indexOf('mce-') !== -1;
    };
    const FocusManager = {
        isEditorUIElement: isEditorUIElement$1
    };

/**
 * Utility class for working with delayed actions like setTimeout.
 *
 * @class tinymce.util.Delay
 */
 const wrappedSetTimeout = (callback, time) => {
 if (!isNumber(time)) {
 time = 0;
 }
 return window.setTimeout(callback, time);
 };
 const wrappedSetInterval = (callback, time) => {
 if (!isNumber(time)) {
 time = 0;
 }
 return window.setInterval(callback, time);
 };
 const Delay = {
 /**
 * Sets a timeout that's similar to the native browser <a href="https://developer.mozilla.org/en-US/docs/Web/API/setTimeout">setTimeout</a>
 * API, except that it checks if the editor instance is still alive when the callback gets executed.
 *
 * @method setEditorTimeout
 * @param {tinymce.Editor} editor Editor instance to check the removed state on.
 * @param {Function} callback Callback to execute when timer runs out.
 * @param {Number} time Optional time to wait before the callback is executed, defaults to 0.
 * @return {Number} Timeout id number.
 */
 setEditorTimeout: (editor, callback, time) => {
 return wrappedSetTimeout(() => {
 if (!editor.removed) {
 callback();
 }
 }, time);
 },
 /**
 * Sets an interval timer that's similar to native browser <a href="https://developer.mozilla.org/en-US/docs/Web/API/setInterval">setInterval</a>
 * API, except that it checks if the editor instance is still alive when the callback gets executed.
 *
 * @method setEditorInterval
 * @param {Function} callback Callback to execute when interval time runs out.
 * @param {Number} time Optional time to wait before the callback is executed, defaults to 0.
 * @return {Number} Timeout id number.
 */
 setEditorInterval: (editor, callback, time) => {
 const timer = wrappedSetInterval(() => {
 if (!editor.removed) {
 callback();
 }
 else {
 window.clearInterval(timer);
 }
 }, time);
 return timer;
 }
 };

let documentFocusInHandler;
    const DOM$c = DOMUtils.DOM;
    const isEditorUIElement = (elm) => {
        // Since this can be overridden by third party we need to use the API reference here
        return isElement$7(elm) && FocusManager.isEditorUIElement(elm);
    };
    const isEditorContentAreaElement = (elm) => {
        const classList = elm.classList;
        if (classList !== undefined) {
            // tox-edit-area__iframe === iframe container element
            // mce-content-body === inline body element
            return classList.contains('tox-edit-area') || classList.contains('tox-edit-area__iframe') || classList.contains('mce-content-body');
        }
        else {
            return false;
        }
    };
    const isUIElement = (editor, elm) => {
        const customSelector = getCustomUiSelector(editor);
        const parent = DOM$c.getParent(elm, (elm) => {
            return (isEditorUIElement(elm) ||
                (customSelector ? editor.dom.is(elm, customSelector) : false));
        });
        return parent !== null;
    };
    const getActiveElement = (editor) => {
        try {
            const root = getRootNode(SugarElement.fromDom(editor.getElement()));
            return active(root).fold(() => document.body, (x) => x.dom);
        }
        catch {
            // IE sometimes fails to get the activeElement when resizing table
            // TODO: Investigate this
            return document.body;
        }
    };
    const registerEvents$1 = (editorManager, e) => {
        const editor = e.editor;
        register$6(editor);
        const toggleContentAreaOnFocus = (editor, fn) => {
            // Inline editors have a different approach to highlight the content area on focus
            if (shouldHighlightOnFocus(editor) && editor.inline !== true) {
                const contentArea = SugarElement.fromDom(editor.getContainer());
                fn(contentArea, 'tox-edit-focus');
            }
        };
        editor.on('focusin', () => {
            const focusedEditor = editorManager.focusedEditor;
            if (isEditorContentAreaElement(getActiveElement(editor))) {
                toggleContentAreaOnFocus(editor, add$2);
            }
            if (focusedEditor !== editor) {
                if (focusedEditor) {
                    focusedEditor.dispatch('blur', { focusedEditor: editor });
                }
                editorManager.setActive(editor);
                editorManager.focusedEditor = editor;
                editor.dispatch('focus', { blurredEditor: focusedEditor });
                editor.focus(true);
            }
        });
        editor.on('focusout', () => {
            Delay.setEditorTimeout(editor, () => {
                const focusedEditor = editorManager.focusedEditor;
                // Remove focus highlight when the content area is no longer the active editor element, or if the highlighted editor is not the current focused editor
                if (!isEditorContentAreaElement(getActiveElement(editor)) || focusedEditor !== editor) {
                    toggleContentAreaOnFocus(editor, remove$4);
                }
                // Still the same editor the blur was outside any editor UI
                if (!isUIElement(editor, getActiveElement(editor)) && focusedEditor === editor) {
                    editor.dispatch('blur', { focusedEditor: null });
                    editorManager.focusedEditor = null;
                }
            });
        });
        // Check if focus is moved to an element outside the active editor by checking if the target node
        // isn't within the body of the activeEditor nor a UI element such as a dialog child control
        if (!documentFocusInHandler) {
            documentFocusInHandler = (e) => {
                const activeEditor = editorManager.activeEditor;
                if (activeEditor) {
                    getOriginalEventTarget(e).each((target) => {
                        const elem = target;
                        if (elem.ownerDocument === document) {
                            // Fire a blur event if the element isn't a UI element
                            if (elem !== document.body && !isUIElement(activeEditor, elem) && editorManager.focusedEditor === activeEditor) {
                                activeEditor.dispatch('blur', { focusedEditor: null });
                                editorManager.focusedEditor = null;
                            }
                        }
                    });
                }
            };
            DOM$c.bind(document, 'focusin', documentFocusInHandler);
        }
    };
    const unregisterDocumentEvents = (editorManager, e) => {
        if (editorManager.focusedEditor === e.editor) {
            editorManager.focusedEditor = null;
        }
        if (!editorManager.activeEditor && documentFocusInHandler) {
            DOM$c.unbind(document, 'focusin', documentFocusInHandler);
            documentFocusInHandler = null;
        }
    };
    const setup$C = (editorManager) => {
        editorManager.on('AddEditor', curry(registerEvents$1, editorManager));
        editorManager.on('RemoveEditor', curry(unregisterDocumentEvents, editorManager));
    };

/**
     * This file exposes a set of the common KeyCodes for use. Please grow it as needed.
     */
    const VK = {
        BACKSPACE: 8,
        DELETE: 46,
        DOWN: 40,
        ENTER: 13,
        ESC: 27,
        LEFT: 37,
        RIGHT: 39,
        SPACEBAR: 32,
        TAB: 9,
        UP: 38,
        PAGE_UP: 33,
        PAGE_DOWN: 34,
        END: 35,
        HOME: 36,
        modifierPressed: (e) => {
            return e.shiftKey || e.ctrlKey || e.altKey || VK.metaKeyPressed(e);
        },
        metaKeyPressed: (e) => {
            // Check if ctrl or meta key is pressed. Edge case for AltGr on Windows where it produces ctrlKey+altKey states
            return Env.os.isMacOS() || Env.os.isiOS() ? e.metaKey : e.ctrlKey && !e.altKey;
        }
    };

const fromPoint = (clientX, clientY, doc) => {
        const win = defaultView(SugarElement.fromDom(doc));
        return getAtPoint(win.dom, clientX, clientY).map((simRange) => {
            const rng = doc.createRange();
            rng.setStart(simRange.start.dom, simRange.soffset);
            rng.setEnd(simRange.finish.dom, simRange.foffset);
            return rng;
        }).getOrUndefined();
    };

const isEq$4 = (rng1, rng2) => {
        return isNonNullable(rng1) && isNonNullable(rng2) &&
            (rng1.startContainer === rng2.startContainer && rng1.startOffset === rng2.startOffset) &&
            (rng1.endContainer === rng2.endContainer && rng1.endOffset === rng2.endOffset);
    };

/**
     * This class contains a few utility methods for ranges.
     *
     * @class tinymce.dom.RangeUtils
     */
    const RangeUtils = (dom) => {
        /**
         * Walks the specified range like object and executes the callback for each sibling collection it finds.
         *
         * @private
         * @method walk
         * @param {RangeObject} rng Range like object.
         * @param {Function} callback Callback function to execute for each sibling collection.
         */
        const walk = (rng, callback) => {
            return walk$3(dom, rng, callback);
        };
        /**
         * Splits the specified range at it's start/end points.
         *
         * @private
         * @param {RangeObject} rng Range to split.
         * @return {RangeObject} Range position object.
         */
        const split$1 = split;
        /**
         * Normalizes the specified range by finding the closest best suitable caret location.
         *
         * @private
         * @param {Range} rng Range to normalize.
         * @return {Boolean} True or false if the specified range was normalized or not.
         */
        const normalize = (rng) => {
            return normalize$2(dom, rng).fold(never, (normalizedRng) => {
                rng.setStart(normalizedRng.startContainer, normalizedRng.startOffset);
                rng.setEnd(normalizedRng.endContainer, normalizedRng.endOffset);
                return true;
            });
        };
        /**
         * Returns a range expanded around the entire word the provided selection was collapsed within.
         *
         * @method expand
         * @param {Range} rng The initial range to work from.
         * @param {Object} options Optional options provided to the expansion. Defaults to { type: 'word' }
         * @return {Range} Returns the expanded range.
         */
        const expand = (rng, options = { type: 'word' }) => {
            if (options.type === 'word') {
                const rangeLike = expandRng(dom, rng, [{ inline: 'span' }], { includeTrailingSpace: false, expandToBlock: false });
                const newRange = dom.createRng();
                newRange.setStart(rangeLike.startContainer, rangeLike.startOffset);
                newRange.setEnd(rangeLike.endContainer, rangeLike.endOffset);
                return newRange;
            }
            return rng;
        };
        return {
            walk,
            split: split$1,
            expand,
            normalize
        };
    };
    /**
     * Compares two ranges and checks if they are equal.
     *
     * @static
     * @method compareRanges
     * @param {RangeObject} rng1 First range to compare.
     * @param {RangeObject} rng2 First range to compare.
     * @return {Boolean} True or false if the ranges are equal.
     */
    RangeUtils.compareRanges = isEq$4;
    /**
     * Gets the caret range for the given x/y location.
     *
     * @static
     * @method getCaretRangeFromPoint
     * @param {Number} clientX X coordinate for range
     * @param {Number} clientY Y coordinate for range
     * @param {Document} doc Document that the x and y coordinates are relative to
     * @returns {Range} Caret range
     */
    RangeUtils.getCaretRangeFromPoint = fromPoint;
    RangeUtils.getSelectedNode = getSelectedNode;
    RangeUtils.getNode = getNode$1;

const view = (doc) => {
        // Only walk up to the document this script is defined in.
        // This prevents walking up to the parent window when the editor is in an iframe.
        const element = doc.dom === document ? Optional.none() : Optional.from(doc.dom.defaultView?.frameElement);
        return element.map(SugarElement.fromDom);
    };
    const owner = (element) => documentOrOwner(element);

var Navigation = /*#__PURE__*/Object.freeze({
        __proto__: null,
        view: view,
        owner: owner
    });

const processRanges = (editor, ranges) => map$3(ranges, (range) => {
        const evt = editor.dispatch('GetSelectionRange', { range });
        return evt.range !== range ? evt.range : range;
    });

// TINY-10305: Map over array for faster lookup.
    const unescapedTextParents = Tools.makeMap('NOSCRIPT STYLE SCRIPT XMP IFRAME NOEMBED NOFRAMES PLAINTEXT', ' ');
    const containsZwsp = (node) => isString(node.nodeValue) && node.nodeValue.includes(ZWSP$1);
    const getTemporaryNodeSelector = (tempAttrs) => `${tempAttrs.length === 0 ? '' : `${map$3(tempAttrs, (attr) => `[${attr}]`).join(',')},`}[data-mce-bogus="all"]`;
    const getTemporaryNodes = (tempAttrs, body) => body.querySelectorAll(getTemporaryNodeSelector(tempAttrs));
    const createZwspCommentWalker = (body) => document.createTreeWalker(body, NodeFilter.SHOW_COMMENT, (node) => containsZwsp(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP);
    const createUnescapedZwspTextWalker = (body) => document.createTreeWalker(body, NodeFilter.SHOW_TEXT, (node) => {
        if (containsZwsp(node)) {
            const parent = node.parentNode;
            return parent && has$2(unescapedTextParents, parent.nodeName) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
        }
        else {
            return NodeFilter.FILTER_SKIP;
        }
    });
    const hasZwspComment = (body) => createZwspCommentWalker(body).nextNode() !== null;
    const hasUnescapedZwspText = (body) => createUnescapedZwspTextWalker(body).nextNode() !== null;
    const hasTemporaryNode = (tempAttrs, body) => body.querySelector(getTemporaryNodeSelector(tempAttrs)) !== null;
    const trimTemporaryNodes = (tempAttrs, body) => {
        each$e(getTemporaryNodes(tempAttrs, body), (elm) => {
            const element = SugarElement.fromDom(elm);
            if (get$9(element, 'data-mce-bogus') === 'all') {
                remove$8(element);
            }
            else {
                each$e(tempAttrs, (attr) => {
                    if (has$1(element, attr)) {
                        remove$9(element, attr);
                    }
                });
            }
        });
    };
    const emptyAllNodeValuesInWalker = (walker) => {
        let curr = walker.nextNode();
        while (curr !== null) {
            curr.nodeValue = null;
            curr = walker.nextNode();
        }
    };
    const emptyZwspComments = compose(emptyAllNodeValuesInWalker, createZwspCommentWalker);
    const emptyUnescapedZwspTexts = compose(emptyAllNodeValuesInWalker, createUnescapedZwspTextWalker);
    const trim$1 = (body, tempAttrs) => {
        const conditionalTrims = [
            {
                condition: curry(hasTemporaryNode, tempAttrs),
                action: curry(trimTemporaryNodes, tempAttrs)
            },
            {
                condition: hasZwspComment,
                action: emptyZwspComments
            },
            {
                condition: hasUnescapedZwspText,
                action: emptyUnescapedZwspTexts
            }
        ];
        let trimmed = body;
        let cloned = false;
        each$e(conditionalTrims, ({ condition, action }) => {
            if (condition(trimmed)) {
                if (!cloned) {
                    trimmed = body.cloneNode(true);
                    cloned = true;
                }
                action(trimmed);
            }
        });
        return trimmed;
    };

/**
 * This class is used to write HTML tags out it can be used with the Serializer.
 *
 * @class tinymce.html.Writer
 * @version 3.4
 * @example
 * const writer = tinymce.html.Writer({ indent: true });
 * writer.start('node', { attr: 'value' });
 * writer.end('node');
 * console.log(writer.getContent());
 */
 const makeMap$1 = Tools.makeMap;
 const Writer = (settings) => {
 const html = [];
 settings = settings || {};
 const indent = settings.indent;
 const indentBefore = makeMap$1(settings.indent_before || '');
 const indentAfter = makeMap$1(settings.indent_after || '');
 const encode = Entities.getEncodeFunc(settings.entity_encoding || 'raw', settings.entities);
 const htmlOutput = settings.element_format !== 'xhtml';
 return {
 /**
 * Writes a start element, such as ``.
 *
 * @method start
 * @param {String} name Name of the element.
 * @param {Array} attrs Optional array of objects containing an attribute name and value, or undefined if the element has no attributes.
 * @param {Boolean} empty Optional empty state if the tag should serialize as a void element. For example: `<img />`
 */
 start: (name, attrs, empty) => {
 if (indent && indentBefore[name] && html.length > 0) {
 const value = html[html.length - 1];
 if (value.length > 0 && value !== '\n') {
 html.push('\n');
 }
 }
 html.push('<', name);
 if (attrs) {
 for (let i = 0, l = attrs.length; i < l; i++) {
 const attr = attrs[i];
 html.push(' ', attr.name, '="', encode(attr.value, true), '"');
 }
 }
 if (!empty || htmlOutput) {
 html[html.length] = '>';
 }
 else {
 html[html.length] = ' />';
 }
 if (empty && indent && indentAfter[name] && html.length > 0) {
 const value = html[html.length - 1];
 if (value.length > 0 && value !== '\n') {
 html.push('\n');
 }
 }
 },
 /**
 * Writes an end element, such as ``.
 *
 * @method end
 * @param {String} name Name of the element.
 */
 end: (name) => {
 let value;
 /* if (indent && indentBefore[name] && html.length > 0) {
 value = html[html.length - 1];
 
 if (value.length > 0 && value !== '\n')
 html.push('\n');
 }*/
 html.push('</', name, '>');
 if (indent && indentAfter[name] && html.length > 0) {
 value = html[html.length - 1];
 if (value.length > 0 && value !== '\n') {
 html.push('\n');
 }
 }
 },
 /**
 * Writes a text node.
 *
 * @method text
 * @param {String} text String to write out.
 * @param {Boolean} raw Optional raw state. If true, the contents won't get encoded.
 */
 text: (text, raw) => {
 if (text.length > 0) {
 html[html.length] = raw ? text : encode(text);
 }
 },
 /**
 * Writes a cdata node, such as `<![CDATA[data]]>`.
 *
 * @method cdata
 * @param {String} text String to write out inside the cdata.
 */
 cdata: (text) => {
 html.push('<![CDATA[', text, ']]>');
 },
 /**
 * Writes a comment node, such as ``.
 *
 * @method comment
 * @param {String} text String to write out inside the comment.
 */
 comment: (text) => {
 html.push('');
 },
 /**
 * Writes a processing instruction (PI) node, such as `<?xml attr="value" ?>`.
 *
 * @method pi
 * @param {String} name Name of the pi.
 * @param {String} text String to write out inside the pi.
 */
 pi: (name, text) => {
 if (text) {
 html.push('<?', name, ' ', encode(text), '?>');
 }
 else {
 html.push('<?', name, '?>');
 }
 if (indent) {
 html.push('\n');
 }
 },
 /**
 * Writes a doctype node, such as `<!DOCTYPE data>`.
 *
 * @method doctype
 * @param {String} text String to write out inside the doctype.
 */
 doctype: (text) => {
 html.push('<!DOCTYPE', text, '>', indent ? '\n' : '');
 },
 /**
 * Resets the internal buffer. For example, if one wants to reuse the writer.
 *
 * @method reset
 */
 reset: () => {
 html.length = 0;
 },
 /**
 * Returns the contents that was serialized.
 *
 * @method getContent
 * @return {String} HTML contents that got written down.
 */
 getContent: () => {
 return html.join('').replace(/\n$/, '');
 }
 };
 };

/**
 * This class is used to serialize down the DOM tree into a string using a Writer instance.
 *
 * @class tinymce.html.Serializer
 * @version 3.4
 * @example
 * tinymce.html.Serializer().serialize(tinymce.html.DomParser().parse('text'));
 */
 const HtmlSerializer = (settings = {}, schema = Schema()) => {
 const writer = Writer(settings);
 settings.validate = 'validate' in settings ? settings.validate : true;
 /**
 * Serializes the specified node into a string.
 *
 * @method serialize
 * @param {tinymce.html.Node} node Node instance to serialize.
 * @return {String} String with HTML based on the DOM tree.
 * @example
 * tinymce.html.Serializer().serialize(tinymce.html.DomParser().parse('text'));
 */
 const serialize = (node) => {
 const validate = settings.validate;
 const handlers = {
 // #text
 3: (node) => {
 writer.text(node.value ?? '', node.raw);
 },
 // #comment
 8: (node) => {
 writer.comment(node.value ?? '');
 },
 // Processing instruction
 7: (node) => {
 writer.pi(node.name, node.value);
 },
 // Doctype
 10: (node) => {
 writer.doctype(node.value ?? '');
 },
 // CDATA
 4: (node) => {
 writer.cdata(node.value ?? '');
 },
 // Document fragment
 11: (node) => {
 let tempNode = node;
 if ((tempNode = tempNode.firstChild)) {
 do {
 walk(tempNode);
 } while ((tempNode = tempNode.next));
 }
 }
 };
 writer.reset();
 const walk = (node) => {
 const handler = handlers[node.type];
 if (!handler) {
 const name = node.name;
 const isEmpty = name in schema.getVoidElements();
 let attrs = node.attributes;
 // Sort attributes
 if (validate && attrs && attrs.length > 1) {
 const sortedAttrs = [];
 sortedAttrs.map = {};
 const elementRule = schema.getElementRule(node.name);
 if (elementRule) {
 for (let i = 0, l = elementRule.attributesOrder.length; i < l; i++) {
 const attrName = elementRule.attributesOrder[i];
 if (attrName in attrs.map) {
 const attrValue = attrs.map[attrName];
 sortedAttrs.map[attrName] = attrValue;
 sortedAttrs.push({ name: attrName, value: attrValue });
 }
 }
 for (let i = 0, l = attrs.length; i < l; i++) {
 const attrName = attrs[i].name;
 if (!(attrName in sortedAttrs.map)) {
 const attrValue = attrs.map[attrName];
 sortedAttrs.map[attrName] = attrValue;
 sortedAttrs.push({ name: attrName, value: attrValue });
 }
 }
 attrs = sortedAttrs;
 }
 }
 writer.start(name, attrs, isEmpty);
 if (isNonHtmlElementRootName(name)) {
 if (isString(node.value)) {
 writer.text(node.value, true);
 }
 writer.end(name);
 }
 else {
 if (!isEmpty) {
 let child = node.firstChild;
 if (child) {
 // Pre and textarea elements treat the first newline character as optional and will omit it. As such, if the content starts
 // with a newline we need to add in an additional newline to prevent the current newline in the value being treated as optional
 // See https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions
 if ((name === 'pre' || name === 'textarea') && child.type === 3 && child.value?.[0] === '\n') {
 writer.text('\n', true);
 }
 do {
 walk(child);
 } while ((child = child.next));
 }
 writer.end(name);
 }
 }
 }
 else {
 handler(node);
 }
 };
 // Serialize element or text nodes and treat all other nodes as fragments
 if (node.type === 1 && !settings.inner) {
 walk(node);
 }
 else if (node.type === 3) {
 handlers[3](node);
 }
 else {
 handlers[11](node);
 }
 return writer.getContent();
 };
 return {
 serialize
 };
 };

const isChar = (forward, predicate, pos) => Optional.from(pos.container()).filter(isText$b).exists((text) => {
        const delta = forward ? 0 : -1;
        return predicate(text.data.charAt(pos.offset() + delta));
    });
    const isBeforeSpace = curry(isChar, true, isWhiteSpace);
    const isAfterSpace = curry(isChar, false, isWhiteSpace);
    const isEmptyText = (pos) => {
        const container = pos.container();
        return isText$b(container) && (container.data.length === 0 || isZwsp(container.data) && BookmarkManager.isBookmarkNode(container.parentNode));
    };
    const matchesElementPosition = (before, predicate) => (pos) => getChildNodeAtRelativeOffset(before ? 0 : -1, pos).filter(predicate).isSome();
    const isImageBlock = (node) => isImg(node) && get$7(SugarElement.fromDom(node), 'display') === 'block';
    const isCefNode = (node) => isContentEditableFalse$a(node) && !isBogusAll(node);
    const isBeforeImageBlock = matchesElementPosition(true, isImageBlock);
    const isAfterImageBlock = matchesElementPosition(false, isImageBlock);
    const isBeforeMedia = matchesElementPosition(true, isMedia$2);
    const isAfterMedia = matchesElementPosition(false, isMedia$2);
    const isBeforeTable = matchesElementPosition(true, isTable$2);
    const isAfterTable = matchesElementPosition(false, isTable$2);
    const isBeforeContentEditableFalse = matchesElementPosition(true, isCefNode);
    const isAfterContentEditableFalse = matchesElementPosition(false, isCefNode);

const navigateIgnoreEmptyTextNodes = (forward, root, from) => navigateIgnore(forward, root, from, isEmptyText);
    const isBlock$2 = (schema) => (el) => schema.isBlock(name(el));
    const getClosestBlock$1 = (root, pos, schema) => find$2(parentsAndSelf(SugarElement.fromDom(pos.container()), root), isBlock$2(schema));
    const isAtBeforeAfterBlockBoundary = (forward, root, pos, schema) => navigateIgnoreEmptyTextNodes(forward, root.dom, pos)
        .forall((newPos) => getClosestBlock$1(root, pos, schema).fold(() => !isInSameBlock(newPos, pos, root.dom), (fromBlock) => !isInSameBlock(newPos, pos, root.dom) && contains(fromBlock, SugarElement.fromDom(newPos.container()))));
    const isAtBlockBoundary = (forward, root, pos, schema) => getClosestBlock$1(root, pos, schema).fold(() => navigateIgnoreEmptyTextNodes(forward, root.dom, pos).forall((newPos) => !isInSameBlock(newPos, pos, root.dom)), (parent) => navigateIgnoreEmptyTextNodes(forward, parent.dom, pos).isNone());
    const isAtStartOfBlock = curry(isAtBlockBoundary, false);
    const isAtEndOfBlock = curry(isAtBlockBoundary, true);
    const isBeforeBlock = curry(isAtBeforeAfterBlockBoundary, false);
    const isAfterBlock = curry(isAtBeforeAfterBlockBoundary, true);

const isBr$2 = (pos) => getElementFromPosition(pos).exists(isBr$6);
    const findBr = (forward, root, pos, schema) => {
        const parentBlocks = filter$5(parentsAndSelf(SugarElement.fromDom(pos.container()), root), (el) => schema.isBlock(name(el)));
        const scope = head(parentBlocks).getOr(root);
        return fromPosition(forward, scope.dom, pos).filter(isBr$2);
    };
    const isBeforeBr$1 = (root, pos, schema) => getElementFromPosition(pos).exists(isBr$6) || findBr(true, root, pos, schema).isSome();
    const isAfterBr = (root, pos, schema) => getElementFromPrevPosition(pos).exists(isBr$6) || findBr(false, root, pos, schema).isSome();
    const findPreviousBr = curry(findBr, false);
    const findNextBr = curry(findBr, true);

const strongRtl = /[\u0591-\u07FF\uFB1D-\uFDFF\uFE70-\uFEFC]/;
    const hasStrongRtl = (text) => strongRtl.test(text);

// Reset the contenteditable state and fill the content with a padding br
    const cleanCells = (cells) => each$e(cells, (cell) => {
        remove$9(cell, 'contenteditable');
        fillWithPaddingBr(cell);
    });
    const getOutsideBlock = (editor, container) => Optional.from(editor.dom.getParent(container, editor.dom.isBlock)).map(SugarElement.fromDom);
    const handleEmptyBlock = (editor, startInTable, emptyBlock) => {
        emptyBlock.each((block) => {
            if (startInTable) {
                // Note that we don't need to set the selection as it'll be within the table
                remove$8(block);
            }
            else {
                // Set the cursor location as it'll move when filling with padding
                fillWithPaddingBr(block);
                editor.selection.setCursorLocation(block.dom, 0);
            }
        });
    };
    const deleteContentInsideCell = (editor, cell, rng, isFirstCellInSelection) => {
        const insideTableRng = rng.cloneRange();
        if (isFirstCellInSelection) {
            insideTableRng.setStart(rng.startContainer, rng.startOffset);
            insideTableRng.setEndAfter(cell.dom.lastChild);
        }
        else {
            insideTableRng.setStartBefore(cell.dom.firstChild);
            insideTableRng.setEnd(rng.endContainer, rng.endOffset);
        }
        deleteCellContents(editor, insideTableRng, cell, false).each((action) => action());
    };
    const collapseAndRestoreCellSelection = (editor) => {
        const selectedCells = getCellsFromEditor(editor);
        const selectedNode = SugarElement.fromDom(editor.selection.getNode());
        if (isTableCell$3(selectedNode.dom) && isEmpty$4(editor.schema, selectedNode)) {
            editor.selection.setCursorLocation(selectedNode.dom, 0);
        }
        else {
            editor.selection.collapse(true);
        }
        // Restore the data-mce-selected attribute if multiple cells were selected, as if it was a cef element
        // then selection overrides would remove it as it was using an offscreen selection clone.
        if (selectedCells.length > 1 && exists(selectedCells, (cell) => eq(cell, selectedNode))) {
            set$4(selectedNode, 'data-mce-selected', '1');
        }
    };
    /*
     * Runs when
     * - the start and end of the selection is contained within the same table (called directly from deleteRange)
     * - part of a table and content outside is selected
     */
    const emptySingleTableCells = (editor, cells, outsideDetails) => Optional.some(() => {
        const editorRng = editor.selection.getRng();
        const cellsToClean = outsideDetails.bind(({ rng, isStartInTable }) => {
            /*
             * Delete all content outside of the table that is in the selection
             * - Get the outside block before deleting the contents
             * - Delete the contents outside
             * - Handle the block outside the table if it is empty since rng.deleteContents leaves it
             */
            const outsideBlock = getOutsideBlock(editor, isStartInTable ? rng.endContainer : rng.startContainer);
            rng.deleteContents();
            handleEmptyBlock(editor, isStartInTable, outsideBlock.filter(curry(isEmpty$4, editor.schema)));
            /*
             * The only time we can have only part of the cell contents selected is when part of the selection
             * is outside the table (otherwise we use the Darwin fake selection, which always selects entire cells),
             * in which case we need to delete the contents inside and check if the entire contents of the cell have been deleted.
             *
             * Note: The endPointCell is the only cell which may have only part of its contents selected.
             */
            const endPointCell = isStartInTable ? cells[0] : cells[cells.length - 1];
            deleteContentInsideCell(editor, endPointCell, editorRng, isStartInTable);
            if (!isEmpty$4(editor.schema, endPointCell)) {
                return Optional.some(isStartInTable ? cells.slice(1) : cells.slice(0, -1));
            }
            else {
                return Optional.none();
            }
        }).getOr(cells);
        // Remove content from cells we need to clean
        cleanCells(cellsToClean);
        // Collapse the original selection after deleting everything
        collapseAndRestoreCellSelection(editor);
    });
    /*
     * Runs when the start of the selection is in a table and the end of the selection is in another table
     */
    const emptyMultiTableCells = (editor, startTableCells, endTableCells, betweenRng) => Optional.some(() => {
        const rng = editor.selection.getRng();
        const startCell = startTableCells[0];
        const endCell = endTableCells[endTableCells.length - 1];
        deleteContentInsideCell(editor, startCell, rng, true);
        deleteContentInsideCell(editor, endCell, rng, false);
        // Only clean empty cells, the first and last cells have the potential to still have content
        const startTableCellsToClean = isEmpty$4(editor.schema, startCell) ? startTableCells : startTableCells.slice(1);
        const endTableCellsToClean = isEmpty$4(editor.schema, endCell) ? endTableCells : endTableCells.slice(0, -1);
        cleanCells(startTableCellsToClean.concat(endTableCellsToClean));
        // Delete all content in between the start table and end table
        betweenRng.deleteContents();
        // This will collapse the selection into the cell of the start table
        collapseAndRestoreCellSelection(editor);
    });
    // Delete the contents of a range inside a cell. Runs on tables that are a single cell or partial selections that need to be cleaned up.
    const deleteCellContents = (editor, rng, cell, moveSelection = true) => Optional.some(() => {
        deleteRangeContents(editor, rng, cell, moveSelection);
    });
    const deleteTableElement = (editor, table) => Optional.some(() => deleteElement$2(editor, false, table));
    const deleteCellRange = (editor, rootElm, rng) => getActionFromRange(rootElm, rng)
        .bind((action) => action.fold(curry(deleteCellContents, editor), curry(deleteTableElement, editor), curry(emptySingleTableCells, editor), curry(emptyMultiTableCells, editor)));
    const deleteCaptionRange = (editor, caption) => emptyElement(editor, caption);
    const deleteTableRange = (editor, rootElm, rng, startElm) => getParentCaption(rootElm, startElm).fold(() => deleteCellRange(editor, rootElm, rng), (caption) => deleteCaptionRange(editor, caption));
    const deleteRange$4 = (editor, startElm, selectedCells) => {
        const rootNode = SugarElement.fromDom(editor.getBody());
        const rng = editor.selection.getRng();
        return selectedCells.length !== 0 ?
            emptySingleTableCells(editor, selectedCells, Optional.none()) :
            deleteTableRange(editor, rootNode, rng, startElm);
    };
    const getParentCell = (rootElm, elm) => find$2(parentsAndSelf(elm, rootElm), isTableCell$2);
    const getParentCaption = (rootElm, elm) => find$2(parentsAndSelf(elm, rootElm), isTag('caption'));
    const deleteBetweenCells = (editor, rootElm, forward, fromCell, from) => 
    // TODO: TINY-8865 - This may not be safe to cast as Node below and alternative solutions need to be looked into
    navigate(forward, editor.getBody(), from)
        .bind((to) => getParentCell(rootElm, SugarElement.fromDom(to.getNode()))
        .bind((toCell) => eq(toCell, fromCell) ? Optional.none() : Optional.some(noop)));
    const emptyElement = (editor, elm) => Optional.some(() => {
        fillWithPaddingBr(elm);
        editor.selection.setCursorLocation(elm.dom, 0);
    });
    const isDeleteOfLastCharPos = (fromCaption, forward, from, to) => firstPositionIn(fromCaption.dom).bind((first) => lastPositionIn(fromCaption.dom).map((last) => forward ?
        from.isEqual(first) && to.isEqual(last) :
        from.isEqual(last) && to.isEqual(first))).getOr(true);
    const emptyCaretCaption = (editor, elm) => emptyElement(editor, elm);
    const validateCaretCaption = (rootElm, fromCaption, to) => 
    // TODO: TINY-8865 - This may not be safe to cast as Node below and alternative solutions need to be looked into
    getParentCaption(rootElm, SugarElement.fromDom(to.getNode()))
        .fold(() => Optional.some(noop), (toCaption) => someIf(!eq(toCaption, fromCaption), noop));
    const deleteCaretInsideCaption = (editor, rootElm, forward, fromCaption, from) => navigate(forward, editor.getBody(), from).fold(() => Optional.some(noop), (to) => isDeleteOfLastCharPos(fromCaption, forward, from, to) ?
        emptyCaretCaption(editor, fromCaption) :
        validateCaretCaption(rootElm, fromCaption, to));
    const deleteCaretCells = (editor, forward, rootElm, startElm) => {
        const from = CaretPosition.fromRangeStart(editor.selection.getRng());
        return getParentCell(rootElm, startElm).bind((fromCell) => isEmpty$4(editor.schema, fromCell, { checkRootAsContent: false }) ?
            emptyElement(editor, fromCell) :
            deleteBetweenCells(editor, rootElm, forward, fromCell, from));
    };
    const deleteCaretCaption = (editor, forward, rootElm, fromCaption) => {
        const from = CaretPosition.fromRangeStart(editor.selection.getRng());
        return isEmpty$4(editor.schema, fromCaption) ?
            emptyElement(editor, fromCaption) :
            deleteCaretInsideCaption(editor, rootElm, forward, fromCaption, from);
    };
    const isNearTable = (forward, pos) => forward ? isBeforeTable(pos) : isAfterTable(pos);
    const isBeforeOrAfterTable = (editor, forward) => {
        const fromPos = CaretPosition.fromRangeStart(editor.selection.getRng());
        return isNearTable(forward, fromPos) || fromPosition(forward, editor.getBody(), fromPos)
            .exists((pos) => isNearTable(forward, pos));
    };
    const deleteCaret$3 = (editor, forward, startElm) => {
        const rootElm = SugarElement.fromDom(editor.getBody());
        return getParentCaption(rootElm, startElm).fold(() => deleteCaretCells(editor, forward, rootElm, startElm)
            .orThunk(() => someIf(isBeforeOrAfterTable(editor, forward), noop)), (fromCaption) => deleteCaretCaption(editor, forward, rootElm, fromCaption));
    };
    const backspaceDelete$d = (editor, forward) => {
        const startElm = SugarElement.fromDom(editor.selection.getStart(true));
        const cells = getCellsFromEditor(editor);
        return editor.selection.isCollapsed() && cells.length === 0 ?
            deleteCaret$3(editor, forward, startElm) :
            deleteRange$4(editor, startElm, cells);
    };

const isApplyFormat = (format) => !isArray$1(format.attributes) && !isArray$1(format.styles);

const isHeading = (node) => ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(node.name);
    const isSummary = (node) => node.name === 'summary';

const encodeData = (data) => data.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 const decodeData$1 = (data) => data.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');

// TINY-10350: A modification of the Regexes.link regex to specifically capture host.
    // eslint-disable-next-line max-len
    const hostCaptureRegex = /^(?:(?:(?:[A-Za-z][A-Za-z\d.+-]{0,14}:\/\/(?:[-.~*+=!&;:'%@?^${}(),\w]+@)?|www\.|[-;:&=+$,.\w]+@)([A-Za-z\d-]+(?:\.[A-Za-z\d-]+)*))(?::\d+)?(?:\/(?:[-.~*+=!;:'%@$(),\/\w]*[-~*+=%@$()\/\w])?)?(?:\?(?:[-.~*+=!&;:'%@?^${}(),\/\w]+)?)?(?:#(?:[-.~*+=!&;:'%@?^${}(),\/\w]+)?)?)$/;
    const extractHost = (url) => Optional.from(url.match(hostCaptureRegex)).bind((ms) => get$b(ms, 1)).map((h) => startsWith(h, 'www.') ? h.substring(4) : h);

/*! @license DOMPurify 3.2.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.6/LICENSE */

const {
 entries,
 setPrototypeOf,
 isFrozen,
 getPrototypeOf,
 getOwnPropertyDescriptor
 } = Object;
 let {
 freeze,
 seal,
 create: create$7
 } = Object; // eslint-disable-line import/no-mutable-exports
 let {
 apply,
 construct
 } = typeof Reflect !== 'undefined' && Reflect;
 if (!freeze) {
 freeze = function freeze(x) {
 return x;
 };
 }
 if (!seal) {
 seal = function seal(x) {
 return x;
 };
 }
 if (!apply) {
 apply = function apply(fun, thisValue, args) {
 return fun.apply(thisValue, args);
 };
 }
 if (!construct) {
 construct = function construct(Func, args) {
 return new Func(...args);
 };
 }
 const arrayForEach = unapply(Array.prototype.forEach);
 const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
 const arrayPop = unapply(Array.prototype.pop);
 const arrayPush = unapply(Array.prototype.push);
 const arraySplice = unapply(Array.prototype.splice);
 const stringToLowerCase = unapply(String.prototype.toLowerCase);
 const stringToString = unapply(String.prototype.toString);
 const stringMatch = unapply(String.prototype.match);
 const stringReplace = unapply(String.prototype.replace);
 const stringIndexOf = unapply(String.prototype.indexOf);
 const stringTrim = unapply(String.prototype.trim);
 const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
 const regExpTest = unapply(RegExp.prototype.test);
 const typeErrorCreate = unconstruct(TypeError);
 /**
 * Creates a new function that calls the given function with a specified thisArg and arguments.
 *
 * @param func - The function to be wrapped and called.
 * @returns A new function that calls the given function with a specified thisArg and arguments.
 */
 function unapply(func) {
 return function (thisArg) {
 if (thisArg instanceof RegExp) {
 thisArg.lastIndex = 0;
 }
 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
 args[_key - 1] = arguments[_key];
 }
 return apply(func, thisArg, args);
 };
 }
 /**
 * Creates a new function that constructs an instance of the given constructor function with the provided arguments.
 *
 * @param func - The constructor function to be wrapped and called.
 * @returns A new function that constructs an instance of the given constructor function with the provided arguments.
 */
 function unconstruct(func) {
 return function () {
 for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
 args[_key2] = arguments[_key2];
 }
 return construct(func, args);
 };
 }
 /**
 * Add properties to a lookup table
 *
 * @param set - The set to which elements will be added.
 * @param array - The array containing elements to be added to the set.
 * @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
 * @returns The modified set with added elements.
 */
 function addToSet(set, array) {
 let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;
 if (setPrototypeOf) {
 // Make 'in' and truthy checks like Boolean(set.constructor)
 // independent of any properties defined on Object.prototype.
 // Prevent prototype setters from intercepting set as a this value.
 setPrototypeOf(set, null);
 }
 let l = array.length;
 while (l--) {
 let element = array[l];
 if (typeof element === 'string') {
 const lcElement = transformCaseFunc(element);
 if (lcElement !== element) {
 // Config presets (e.g. tags.js, attrs.js) are immutable.
 if (!isFrozen(array)) {
 array[l] = lcElement;
 }
 element = lcElement;
 }
 }
 set[element] = true;
 }
 return set;
 }
 /**
 * Clean up an array to harden against CSPP
 *
 * @param array - The array to be cleaned.
 * @returns The cleaned version of the array
 */
 function cleanArray(array) {
 for (let index = 0; index < array.length; index++) {
 const isPropertyExist = objectHasOwnProperty(array, index);
 if (!isPropertyExist) {
 array[index] = null;
 }
 }
 return array;
 }
 /**
 * Shallow clone an object
 *
 * @param object - The object to be cloned.
 * @returns A new object that copies the original.
 */
 function clone(object) {
 const newObject = create$7(null);
 for (const [property, value] of entries(object)) {
 const isPropertyExist = objectHasOwnProperty(object, property);
 if (isPropertyExist) {
 if (Array.isArray(value)) {
 newObject[property] = cleanArray(value);
 } else if (value && typeof value === 'object' && value.constructor === Object) {
 newObject[property] = clone(value);
 } else {
 newObject[property] = value;
 }
 }
 }
 return newObject;
 }
 /**
 * This method automatically checks if the prop is function or getter and behaves accordingly.
 *
 * @param object - The object to look up the getter function in its prototype chain.
 * @param prop - The property name for which to find the getter function.
 * @returns The getter function found in the prototype chain or a fallback function.
 */
 function lookupGetter(object, prop) {
 while (object !== null) {
 const desc = getOwnPropertyDescriptor(object, prop);
 if (desc) {
 if (desc.get) {
 return unapply(desc.get);
 }
 if (typeof desc.value === 'function') {
 return unapply(desc.value);
 }
 }
 object = getPrototypeOf(object);
 }
 function fallbackValue() {
 return null;
 }
 return fallbackValue;
 }

const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
    const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
    const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
    // List of SVG elements that are disallowed by default.
    // We still need to know them so that we can do namespace
    // checks properly in case one wants to add them to
    // allow-list.
    const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
    const mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover', 'mprescripts']);
    // Similarly to SVG, we want to know all MathML elements,
    // even those that we disallow by default.
    const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
    const text = freeze(['#text']);

const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);
    const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
    const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
    const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);

// eslint-disable-next-line unicorn/better-regex
 const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
 const ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
 const TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm); // eslint-disable-line unicorn/better-regex
 const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/); // eslint-disable-line no-useless-escape
 const ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
 const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
 );
 const IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
 const ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
 );
 const DOCTYPE_NAME = seal(/^html$/i);
 const CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);

var EXPRESSIONS = /*#__PURE__*/Object.freeze({
      __proto__: null,
      ARIA_ATTR: ARIA_ATTR,
      ATTR_WHITESPACE: ATTR_WHITESPACE,
      CUSTOM_ELEMENT: CUSTOM_ELEMENT,
      DATA_ATTR: DATA_ATTR,
      DOCTYPE_NAME: DOCTYPE_NAME,
      ERB_EXPR: ERB_EXPR,
      IS_ALLOWED_URI: IS_ALLOWED_URI,
      IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,
      MUSTACHE_EXPR: MUSTACHE_EXPR,
      TMPLIT_EXPR: TMPLIT_EXPR
    });

/* eslint-disable @typescript-eslint/indent */
 // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
 const NODE_TYPE = {
 element: 1,
 attribute: 2,
 text: 3,
 cdataSection: 4,
 entityReference: 5,
 // Deprecated
 entityNode: 6,
 // Deprecated
 progressingInstruction: 7,
 comment: 8,
 document: 9,
 documentType: 10,
 documentFragment: 11,
 notation: 12 // Deprecated
 };
 const getGlobal = function getGlobal() {
 return typeof window === 'undefined' ? null : window;
 };
 /**
 * Creates a no-op policy for internal use only.
 * Don't export this function outside this module!
 * @param trustedTypes The policy factory.
 * @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
 * @return The policy created (or null, if Trusted Types
 * are not supported or creating the policy failed).
 */
 const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
 if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
 return null;
 }
 // Allow the callers to control the unique policy name
 // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
 // Policy creation with duplicate names throws in Trusted Types.
 let suffix = null;
 const ATTR_NAME = 'data-tt-policy-suffix';
 if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
 suffix = purifyHostElement.getAttribute(ATTR_NAME);
 }
 const policyName = 'dompurify' + (suffix ? '#' + suffix : '');
 try {
 return trustedTypes.createPolicy(policyName, {
 createHTML(html) {
 return html;
 },
 createScriptURL(scriptUrl) {
 return scriptUrl;
 }
 });
 } catch (_) {
 // Policy creation failed (most likely another DOMPurify script has
 // already run). Skip creating the policy, as this will only cause errors
 // if TT are enforced.
 console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
 return null;
 }
 };
 const _createHooksMap = function _createHooksMap() {
 return {
 afterSanitizeAttributes: [],
 afterSanitizeElements: [],
 afterSanitizeShadowDOM: [],
 beforeSanitizeAttributes: [],
 beforeSanitizeElements: [],
 beforeSanitizeShadowDOM: [],
 uponSanitizeAttribute: [],
 uponSanitizeElement: [],
 uponSanitizeShadowNode: []
 };
 };
 function createDOMPurify() {
 let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
 const DOMPurify = root => createDOMPurify(root);
 DOMPurify.version = '3.2.6';
 DOMPurify.removed = [];
 if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
 // Not running in a browser, provide a factory function
 // so that you can pass your own Window
 DOMPurify.isSupported = false;
 return DOMPurify;
 }
 let {
 document
 } = window;
 const originalDocument = document;
 const currentScript = originalDocument.currentScript;
 const {
 DocumentFragment,
 HTMLTemplateElement,
 Node,
 Element,
 NodeFilter,
 NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,
 HTMLFormElement,
 DOMParser,
 trustedTypes
 } = window;
 const ElementPrototype = Element.prototype;
 const cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
 const remove = lookupGetter(ElementPrototype, 'remove');
 const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
 const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
 const getParentNode = lookupGetter(ElementPrototype, 'parentNode');
 // As per issue #47, the web-components registry is inherited by a
 // new document created via createHTMLDocument. As per the spec
 // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
 // a new empty registry is used when creating a template contents owner
 // document, so we use that as our parent document to ensure nothing
 // is inherited.
 if (typeof HTMLTemplateElement === 'function') {
 const template = document.createElement('template');
 if (template.content && template.content.ownerDocument) {
 document = template.content.ownerDocument;
 }
 }
 let trustedTypesPolicy;
 let emptyHTML = '';
 const {
 implementation,
 createNodeIterator,
 createDocumentFragment,
 getElementsByTagName
 } = document;
 const {
 importNode
 } = originalDocument;
 let hooks = _createHooksMap();
 /**
 * Expose whether this browser supports running the full DOMPurify.
 */
 DOMPurify.isSupported = typeof entries === 'function' && typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined;
 const {
 MUSTACHE_EXPR,
 ERB_EXPR,
 TMPLIT_EXPR,
 DATA_ATTR,
 ARIA_ATTR,
 IS_SCRIPT_OR_DATA,
 ATTR_WHITESPACE,
 CUSTOM_ELEMENT
 } = EXPRESSIONS;
 let {
 IS_ALLOWED_URI: IS_ALLOWED_URI$1
 } = EXPRESSIONS;
 /**
 * We consider the elements and attributes below to be safe. Ideally
 * don't add any new ones but feel free to remove unwanted ones.
 */
 /* allowed element names */
 let ALLOWED_TAGS = null;
 const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
 /* Allowed attribute names */
 let ALLOWED_ATTR = null;
 const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
 /*
 * Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
 * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
 * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
 * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
 */
 let CUSTOM_ELEMENT_HANDLING = Object.seal(create$7(null, {
 tagNameCheck: {
 writable: true,
 configurable: false,
 enumerable: true,
 value: null
 },
 attributeNameCheck: {
 writable: true,
 configurable: false,
 enumerable: true,
 value: null
 },
 allowCustomizedBuiltInElements: {
 writable: true,
 configurable: false,
 enumerable: true,
 value: false
 }
 }));
 /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
 let FORBID_TAGS = null;
 /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
 let FORBID_ATTR = null;
 /* Decide if ARIA attributes are okay */
 let ALLOW_ARIA_ATTR = true;
 /* Decide if custom data attributes are okay */
 let ALLOW_DATA_ATTR = true;
 /* Decide if unknown protocols are okay */
 let ALLOW_UNKNOWN_PROTOCOLS = false;
 /* Decide if self-closing tags in attributes are allowed.
 * Usually removed due to a mXSS issue in jQuery 3.0 */
 let ALLOW_SELF_CLOSE_IN_ATTR = true;
 /* Output should be safe for common template engines.
 * This means, DOMPurify removes data attributes, mustaches and ERB
 */
 let SAFE_FOR_TEMPLATES = false;
 /* Output should be safe even for XML used within HTML and alike.
 * This means, DOMPurify removes comments when containing risky content.
 */
 let SAFE_FOR_XML = true;
 /* Decide if document with <html>... should be returned */
 let WHOLE_DOCUMENT = false;
 /* Track whether config is already set on this instance of DOMPurify. */
 let SET_CONFIG = false;
 /* Decide if all elements (e.g. style, script) must be children of
 * document.body. By default, browsers might move them to document.head */
 let FORCE_BODY = false;
 /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
 * string (or a TrustedHTML object if Trusted Types are supported).
 * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
 */
 let RETURN_DOM = false;
 /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
 * string (or a TrustedHTML object if Trusted Types are supported) */
 let RETURN_DOM_FRAGMENT = false;
 /* Try to return a Trusted Type object instead of a string, return a string in
 * case Trusted Types are not supported */
 let RETURN_TRUSTED_TYPE = false;
 /* Output should be free from DOM clobbering attacks?
 * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
 */
 let SANITIZE_DOM = true;
 /* Achieve full DOM Clobbering protection by isolating the namespace of named
 * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
 *
 * HTML/DOM spec rules that enable DOM Clobbering:
 * - Named Access on Window (§7.3.3)
 * - DOM Tree Accessors (§3.1.5)
 * - Form Element Parent-Child Relations (§4.10.3)
 * - Iframe srcdoc / Nested WindowProxies (§4.8.5)
 * - HTMLCollection (§4.2.10.2)
 *
 * Namespace isolation is implemented by prefixing `id` and `name` attributes
 * with a constant string, i.e., `user-content-`
 */
 let SANITIZE_NAMED_PROPS = false;
 const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';
 /* Keep element content when removing element? */
 let KEEP_CONTENT = true;
 /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
 * of importing it into a new Document and returning a sanitized copy */
 let IN_PLACE = false;
 /* Allow usage of profiles like html, svg and mathMl */
 let USE_PROFILES = {};
 /* Tags to ignore content of when KEEP_CONTENT is true */
 let FORBID_CONTENTS = null;
 const DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
 /* Tags that are safe for data: URIs */
 let DATA_URI_TAGS = null;
 const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
 /* Attributes safe for values like "javascript:" */
 let URI_SAFE_ATTRIBUTES = null;
 const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
 const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
 const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
 const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
 /* Document namespace */
 let NAMESPACE = HTML_NAMESPACE;
 let IS_EMPTY_INPUT = false;
 /* Allowed XHTML+XML namespaces */
 let ALLOWED_NAMESPACES = null;
 const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
 let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
 let HTML_INTEGRATION_POINTS = addToSet({}, ['annotation-xml']);
 // Certain elements are allowed in both SVG and HTML
 // namespace. We need to specify them explicitly
 // so that they don't get erroneously deleted from
 // HTML namespace.
 const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
 /* Parsing of strict XHTML documents */
 let PARSER_MEDIA_TYPE = null;
 const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
 const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
 let transformCaseFunc = null;
 /* Keep a reference to config to pass to hooks */
 let CONFIG = null;
 /* Ideally, do not touch anything below this line */
 /* ______________________________________________ */
 const formElement = document.createElement('form');
 const isRegexOrFunction = function isRegexOrFunction(testValue) {
 return testValue instanceof RegExp || testValue instanceof Function;
 };
 /**
 * _parseConfig
 *
 * @param cfg optional config literal
 */
 // eslint-disable-next-line complexity
 const _parseConfig = function _parseConfig() {
 let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 if (CONFIG && CONFIG === cfg) {
 return;
 }
 /* Shield configuration object from tampering */
 if (!cfg || typeof cfg !== 'object') {
 cfg = {};
 }
 /* Shield configuration object from prototype pollution */
 cfg = clone(cfg);
 PARSER_MEDIA_TYPE =
 // eslint-disable-next-line unicorn/prefer-includes
 SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
 // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
 transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;
 /* Set configuration parameters */
 ALLOWED_TAGS = objectHasOwnProperty(cfg, 'ALLOWED_TAGS') ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
 ALLOWED_ATTR = objectHasOwnProperty(cfg, 'ALLOWED_ATTR') ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
 ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, 'ALLOWED_NAMESPACES') ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
 URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
 DATA_URI_TAGS = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
 FORBID_CONTENTS = objectHasOwnProperty(cfg, 'FORBID_CONTENTS') ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
 FORBID_TAGS = objectHasOwnProperty(cfg, 'FORBID_TAGS') ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
 FORBID_ATTR = objectHasOwnProperty(cfg, 'FORBID_ATTR') ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
 USE_PROFILES = objectHasOwnProperty(cfg, 'USE_PROFILES') ? cfg.USE_PROFILES : false;
 ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
 ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
 ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
 ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true
 SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
 SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false; // Default true
 WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
 RETURN_DOM = cfg.RETURN_DOM || false; // Default false
 RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
 RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
 FORCE_BODY = cfg.FORCE_BODY || false; // Default false
 SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
 SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false
 KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
 IN_PLACE = cfg.IN_PLACE || false; // Default false
 IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
 NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
 MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
 HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
 CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
 if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
 CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
 }
 if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
 CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
 }
 if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {
 CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
 }
 if (SAFE_FOR_TEMPLATES) {
 ALLOW_DATA_ATTR = false;
 }
 if (RETURN_DOM_FRAGMENT) {
 RETURN_DOM = true;
 }
 /* Parse profile info */
 if (USE_PROFILES) {
 ALLOWED_TAGS = addToSet({}, text);
 ALLOWED_ATTR = [];
 if (USE_PROFILES.html === true) {
 addToSet(ALLOWED_TAGS, html$1);
 addToSet(ALLOWED_ATTR, html);
 }
 if (USE_PROFILES.svg === true) {
 addToSet(ALLOWED_TAGS, svg$1);
 addToSet(ALLOWED_ATTR, svg);
 addToSet(ALLOWED_ATTR, xml);
 }
 if (USE_PROFILES.svgFilters === true) {
 addToSet(ALLOWED_TAGS, svgFilters);
 addToSet(ALLOWED_ATTR, svg);
 addToSet(ALLOWED_ATTR, xml);
 }
 if (USE_PROFILES.mathMl === true) {
 addToSet(ALLOWED_TAGS, mathMl$1);
 addToSet(ALLOWED_ATTR, mathMl);
 addToSet(ALLOWED_ATTR, xml);
 }
 }
 /* Merge configuration parameters */
 if (cfg.ADD_TAGS) {
 if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
 ALLOWED_TAGS = clone(ALLOWED_TAGS);
 }
 addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
 }
 if (cfg.ADD_ATTR) {
 if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
 ALLOWED_ATTR = clone(ALLOWED_ATTR);
 }
 addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
 }
 if (cfg.ADD_URI_SAFE_ATTR) {
 addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
 }
 if (cfg.FORBID_CONTENTS) {
 if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
 FORBID_CONTENTS = clone(FORBID_CONTENTS);
 }
 addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
 }
 /* Add #text in case KEEP_CONTENT is set to true */
 if (KEEP_CONTENT) {
 ALLOWED_TAGS['#text'] = true;
 }
 /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
 if (WHOLE_DOCUMENT) {
 addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
 }
 /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
 if (ALLOWED_TAGS.table) {
 addToSet(ALLOWED_TAGS, ['tbody']);
 delete FORBID_TAGS.tbody;
 }
 if (cfg.TRUSTED_TYPES_POLICY) {
 if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== 'function') {
 throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
 }
 if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== 'function') {
 throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
 }
 // Overwrite existing TrustedTypes policy.
 trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
 // Sign local variables required by `sanitize`.
 emptyHTML = trustedTypesPolicy.createHTML('');
 } else {
 // Uninitialized policy, attempt to initialize the internal dompurify policy.
 if (trustedTypesPolicy === undefined) {
 trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
 }
 // If creating the internal policy succeeded sign internal variables.
 if (trustedTypesPolicy !== null && typeof emptyHTML === 'string') {
 emptyHTML = trustedTypesPolicy.createHTML('');
 }
 }
 // Prevent further manipulation of configuration.
 // Not available in IE8, Safari 5, etc.
 if (freeze) {
 freeze(cfg);
 }
 CONFIG = cfg;
 };
 /* Keep track of all possible SVG and MathML tags
 * so that we can perform the namespace checks
 * correctly. */
 const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
 const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
 /**
 * @param element a DOM element whose namespace is being checked
 * @returns Return false if the element has a
 * namespace that a spec-compliant parser would never
 * return. Return true otherwise.
 */
 const _checkValidNamespace = function _checkValidNamespace(element) {
 let parent = getParentNode(element);
 // In JSDOM, if we're inside shadow DOM, then parentNode
 // can be null. We just simulate parent in this case.
 if (!parent || !parent.tagName) {
 parent = {
 namespaceURI: NAMESPACE,
 tagName: 'template'
 };
 }
 const tagName = stringToLowerCase(element.tagName);
 const parentTagName = stringToLowerCase(parent.tagName);
 if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
 return false;
 }
 if (element.namespaceURI === SVG_NAMESPACE) {
 // The only way to switch from HTML namespace to SVG
 // is via <svg>. If it happens via any other tag, then
 // it should be killed.
 if (parent.namespaceURI === HTML_NAMESPACE) {
 return tagName === 'svg';
 }
 // The only way to switch from MathML to SVG is via`
 // svg if parent is either <annotation-xml> or MathML
 // text integration points.
 if (parent.namespaceURI === MATHML_NAMESPACE) {
 return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
 }
 // We only allow elements that are defined in SVG
 // spec. All others are disallowed in SVG namespace.
 return Boolean(ALL_SVG_TAGS[tagName]);
 }
 if (element.namespaceURI === MATHML_NAMESPACE) {
 // The only way to switch from HTML namespace to MathML
 // is via <math>. If it happens via any other tag, then
 // it should be killed.
 if (parent.namespaceURI === HTML_NAMESPACE) {
 return tagName === 'math';
 }
 // The only way to switch from SVG to MathML is via
 // <math> and HTML integration points
 if (parent.namespaceURI === SVG_NAMESPACE) {
 return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
 }
 // We only allow elements that are defined in MathML
 // spec. All others are disallowed in MathML namespace.
 return Boolean(ALL_MATHML_TAGS[tagName]);
 }
 if (element.namespaceURI === HTML_NAMESPACE) {
 // The only way to switch from SVG to HTML is via
 // HTML integration points, and from MathML to HTML
 // is via MathML text integration points
 if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
 return false;
 }
 if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
 return false;
 }
 // We disallow tags that are specific for MathML
 // or SVG and should never appear in HTML namespace
 return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
 }
 // For XHTML and XML documents that support custom namespaces
 if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {
 return true;
 }
 // The code should never reach this place (this means
 // that the element somehow got namespace that is not
 // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).
 // Return false just in case.
 return false;
 };
 /**
 * _forceRemove
 *
 * @param node a DOM node
 */
 const _forceRemove = function _forceRemove(node) {
 arrayPush(DOMPurify.removed, {
 element: node
 });
 try {
 // eslint-disable-next-line unicorn/prefer-dom-node-remove
 getParentNode(node).removeChild(node);
 } catch (_) {
 remove(node);
 }
 };
 /**
 * _removeAttribute
 *
 * @param name an Attribute name
 * @param element a DOM node
 */
 const _removeAttribute = function _removeAttribute(name, element) {
 try {
 arrayPush(DOMPurify.removed, {
 attribute: element.getAttributeNode(name),
 from: element
 });
 } catch (_) {
 arrayPush(DOMPurify.removed, {
 attribute: null,
 from: element
 });
 }
 element.removeAttribute(name);
 // We void attribute values for unremovable "is" attributes
 if (name === 'is') {
 if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
 try {
 _forceRemove(element);
 } catch (_) {}
 } else {
 try {
 element.setAttribute(name, '');
 } catch (_) {}
 }
 }
 };
 /**
 * _initDocument
 *
 * @param dirty - a string of dirty markup
 * @return a DOM, filled with the dirty markup
 */
 const _initDocument = function _initDocument(dirty) {
 /* Create a HTML document */
 let doc = null;
 let leadingWhitespace = null;
 if (FORCE_BODY) {
 dirty = '<remove></remove>' + dirty;
 } else {
 /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
 const matches = stringMatch(dirty, /^[\r\n\t ]+/);
 leadingWhitespace = matches && matches[0];
 }
 if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {
 // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
 dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + '</body></html>';
 }
 const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
 /*
 * Use the DOMParser API by default, fallback later if needs be
 * DOMParser not work for svg when has multiple root element.
 */
 if (NAMESPACE === HTML_NAMESPACE) {
 try {
 doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
 } catch (_) {}
 }
 /* Use createHTMLDocument in case DOMParser is not available */
 if (!doc || !doc.documentElement) {
 doc = implementation.createDocument(NAMESPACE, 'template', null);
 try {
 doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
 } catch (_) {
 // Syntax error if dirtyPayload is invalid xml
 }
 }
 const body = doc.body || doc.documentElement;
 if (dirty && leadingWhitespace) {
 body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
 }
 /* Work on whole document or just its body */
 if (NAMESPACE === HTML_NAMESPACE) {
 return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
 }
 return WHOLE_DOCUMENT ? doc.documentElement : body;
 };
 /**
 * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
 *
 * @param root The root element or node to start traversing on.
 * @return The created NodeIterator
 */
 const _createNodeIterator = function _createNodeIterator(root) {
 return createNodeIterator.call(root.ownerDocument || root, root,
 // eslint-disable-next-line no-bitwise
 NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);
 };
 /**
 * _isClobbered
 *
 * @param element element to check for clobbering attacks
 * @return true if clobbered, false if safe
 */
 const _isClobbered = function _isClobbered(element) {
 return element instanceof HTMLFormElement && (typeof element.nodeName !== 'string' || typeof element.textContent !== 'string' || typeof element.removeChild !== 'function' || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== 'function' || typeof element.setAttribute !== 'function' || typeof element.namespaceURI !== 'string' || typeof element.insertBefore !== 'function' || typeof element.hasChildNodes !== 'function');
 };
 /**
 * Checks whether the given object is a DOM node.
 *
 * @param value object to check whether it's a DOM node
 * @return true is object is a DOM node
 */
 const _isNode = function _isNode(value) {
 return typeof Node === 'function' && value instanceof Node;
 };
 function _executeHooks(hooks, currentNode, data) {
 arrayForEach(hooks, hook => {
 hook.call(DOMPurify, currentNode, data, CONFIG);
 });
 }
 /**
 * _sanitizeElements
 *
 * @protect nodeName
 * @protect textContent
 * @protect removeChild
 * @param currentNode to check for permission to exist
 * @return true if node was killed, false if left alive
 */
 const _sanitizeElements = function _sanitizeElements(currentNode) {
 let content = null;
 /* Execute a hook if present */
 _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
 /* Check if element is clobbered or can clobber */
 if (_isClobbered(currentNode)) {
 _forceRemove(currentNode);
 return true;
 }
 /* Now let's check the element's type and name */
 const tagName = transformCaseFunc(currentNode.nodeName);
 /* Execute a hook if present */
 _executeHooks(hooks.uponSanitizeElement, currentNode, {
 tagName,
 allowedTags: ALLOWED_TAGS
 });
 /* Detect mXSS attempts abusing namespace confusion */
 if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
 _forceRemove(currentNode);
 return true;
 }
 /* Remove any occurrence of processing instructions */
 if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
 _forceRemove(currentNode);
 return true;
 }
 /* Remove any kind of possibly harmful comments */
 if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
 _forceRemove(currentNode);
 return true;
 }
 /* Remove element if anything forbids its presence */
 if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
 /* Check if we have a custom element to handle */
 if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
 if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
 return false;
 }
 if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
 return false;
 }
 }
 /* Keep content except for bad-listed elements */
 if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
 const parentNode = getParentNode(currentNode) || currentNode.parentNode;
 const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
 if (childNodes && parentNode) {
 const childCount = childNodes.length;
 for (let i = childCount - 1; i >= 0; --i) {
 const childClone = cloneNode(childNodes[i], true);
 childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
 parentNode.insertBefore(childClone, getNextSibling(currentNode));
 }
 }
 }
 _forceRemove(currentNode);
 return true;
 }
 /* Check whether element has a valid namespace */
 if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
 _forceRemove(currentNode);
 return true;
 }
 /* Make sure that older browsers don't get fallback-tag mXSS */
 if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
 _forceRemove(currentNode);
 return true;
 }
 /* Sanitize element content to be template-safe */
 if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
 /* Get the element's text content */
 content = currentNode.textContent;
 arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
 content = stringReplace(content, expr, ' ');
 });
 if (currentNode.textContent !== content) {
 arrayPush(DOMPurify.removed, {
 element: currentNode.cloneNode()
 });
 currentNode.textContent = content;
 }
 }
 /* Execute a hook if present */
 _executeHooks(hooks.afterSanitizeElements, currentNode, null);
 return false;
 };
 /**
 * _isValidAttribute
 *
 * @param lcTag Lowercase tag name of containing element.
 * @param lcName Lowercase attribute name.
 * @param value Attribute value.
 * @return Returns true if `value` is valid, otherwise false.
 */
 // eslint-disable-next-line complexity
 const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
 /* Make sure attribute cannot clobber */
 if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
 return false;
 }
 /* Allow valid data-* attributes: At least one character after "-"
 (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
 XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
 We don't need to check the value; it's always URI safe. */
 if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
 if (
 // First condition does a very basic check if a) it's basically a valid custom element tagname AND
 // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
 // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
 _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||
 // Alternative, second condition checks if it's an `is`-attribute, AND
 // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
 lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ; else {
 return false;
 }
 /* Check value is safe. First, is attr inert? If so, is safe */
 } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if (value) {
 return false;
 } else ;
 return true;
 };
 /**
 * _isBasicCustomElement
 * checks if at least one dash is included in tagName, and it's not the first char
 * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
 *
 * @param tagName name of the tag of the node to sanitize
 * @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
 */
 const _isBasicCustomElement = function _isBasicCustomElement(tagName) {
 return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);
 };
 /**
 * _sanitizeAttributes
 *
 * @protect attributes
 * @protect nodeName
 * @protect removeAttribute
 * @protect setAttribute
 *
 * @param currentNode to sanitize
 */
 const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
 /* Execute a hook if present */
 _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
 const {
 attributes
 } = currentNode;
 /* Check if we have attributes; if not we might have a text node */
 if (!attributes || _isClobbered(currentNode)) {
 return;
 }
 const hookEvent = {
 attrName: '',
 attrValue: '',
 keepAttr: true,
 allowedAttributes: ALLOWED_ATTR,
 forceKeepAttr: undefined
 };
 let l = attributes.length;
 /* Go backwards over all attributes; safely remove bad ones */
 while (l--) {
 const attr = attributes[l];
 const {
 name,
 namespaceURI,
 value: attrValue
 } = attr;
 const lcName = transformCaseFunc(name);
 const initValue = attrValue;
 let value = name === 'value' ? initValue : stringTrim(initValue);
 /* Execute a hook if present */
 hookEvent.attrName = lcName;
 hookEvent.attrValue = value;
 hookEvent.keepAttr = true;
 hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
 _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
 value = hookEvent.attrValue;
 /* Full DOM Clobbering protection via namespace isolation,
 * Prefix id and name attributes with `user-content-`
 */
 if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
 // Remove the attribute with this value
 _removeAttribute(name, currentNode);
 // Prefix the value and later re-create the attribute with the sanitized value
 value = SANITIZE_NAMED_PROPS_PREFIX + value;
 }
 /* Work around a security issue with comments inside attributes */
 if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
 _removeAttribute(name, currentNode);
 continue;
 }
 /* Did the hooks approve of the attribute? */
 if (hookEvent.forceKeepAttr) {
 continue;
 }
 /* Did the hooks approve of the attribute? */
 if (!hookEvent.keepAttr) {
 _removeAttribute(name, currentNode);
 continue;
 }
 /* Work around a security issue in jQuery 3.0 */
 if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
 _removeAttribute(name, currentNode);
 continue;
 }
 /* Sanitize attribute content to be template-safe */
 if (SAFE_FOR_TEMPLATES) {
 arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
 value = stringReplace(value, expr, ' ');
 });
 }
 /* Is `value` valid for this attribute? */
 const lcTag = transformCaseFunc(currentNode.nodeName);
 if (!_isValidAttribute(lcTag, lcName, value)) {
 _removeAttribute(name, currentNode);
 continue;
 }
 /* Handle attributes that require Trusted Types */
 if (trustedTypesPolicy && typeof trustedTypes === 'object' && typeof trustedTypes.getAttributeType === 'function') {
 if (namespaceURI) ; else {
 switch (trustedTypes.getAttributeType(lcTag, lcName)) {
 case 'TrustedHTML':
 {
 value = trustedTypesPolicy.createHTML(value);
 break;
 }
 case 'TrustedScriptURL':
 {
 value = trustedTypesPolicy.createScriptURL(value);
 break;
 }
 }
 }
 }
 /* Handle invalid data-* attribute set by try-catching it */
 if (value !== initValue) {
 try {
 if (namespaceURI) {
 currentNode.setAttributeNS(namespaceURI, name, value);
 } else {
 /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
 currentNode.setAttribute(name, value);
 }
 if (_isClobbered(currentNode)) {
 _forceRemove(currentNode);
 } else {
 arrayPop(DOMPurify.removed);
 }
 } catch (_) {
 _removeAttribute(name, currentNode);
 }
 }
 }
 /* Execute a hook if present */
 _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
 };
 /**
 * _sanitizeShadowDOM
 *
 * @param fragment to iterate over recursively
 */
 const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
 let shadowNode = null;
 const shadowIterator = _createNodeIterator(fragment);
 /* Execute a hook if present */
 _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
 while (shadowNode = shadowIterator.nextNode()) {
 /* Execute a hook if present */
 _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
 /* Sanitize tags and elements */
 _sanitizeElements(shadowNode);
 /* Check attributes next */
 _sanitizeAttributes(shadowNode);
 /* Deep shadow DOM detected */
 if (shadowNode.content instanceof DocumentFragment) {
 _sanitizeShadowDOM(shadowNode.content);
 }
 }
 /* Execute a hook if present */
 _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
 };
 // eslint-disable-next-line complexity
 DOMPurify.sanitize = function (dirty) {
 let cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 let body = null;
 let importedNode = null;
 let currentNode = null;
 let returnNode = null;
 /* Make sure we have a string to sanitize.
 DO NOT return early, as this will return the wrong type if
 the user has requested a DOM object rather than a string */
 IS_EMPTY_INPUT = !dirty;
 if (IS_EMPTY_INPUT) {
 dirty = '');
 importedNode = body.ownerDocument.importNode(dirty, true);
 if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === 'BODY') {
 /* Node is already a body, use as is */
 body = importedNode;
 } else if (importedNode.nodeName === 'HTML') {
 body = importedNode;
 } else {
 // eslint-disable-next-line unicorn/prefer-dom-node-append
 body.appendChild(importedNode);
 }
 } else {
 /* Exit directly if we have nothing to do */
 if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&
 // eslint-disable-next-line unicorn/prefer-includes
 dirty.indexOf('<') === -1) {
 return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
 }
 /* Initialize the document to work on */
 body = _initDocument(dirty);
 /* Check we have a DOM node from the data */
 if (!body) {
 return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';
 }
 }
 /* Remove first element node (ours) if FORCE_BODY is set */
 if (body && FORCE_BODY) {
 _forceRemove(body.firstChild);
 }
 /* Get node iterator */
 const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
 /* Now start iterating over the created document */
 while (currentNode = nodeIterator.nextNode()) {
 /* Sanitize tags and elements */
 _sanitizeElements(currentNode);
 /* Check attributes next */
 _sanitizeAttributes(currentNode);
 /* Shadow DOM detected, sanitize it */
 if (currentNode.content instanceof DocumentFragment) {
 _sanitizeShadowDOM(currentNode.content);
 }
 }
 /* If we sanitized `dirty` in-place, return it. */
 if (IN_PLACE) {
 return dirty;
 }
 /* Return sanitized string or DOM */
 if (RETURN_DOM) {
 if (RETURN_DOM_FRAGMENT) {
 returnNode = createDocumentFragment.call(body.ownerDocument);
 while (body.firstChild) {
 // eslint-disable-next-line unicorn/prefer-dom-node-append
 returnNode.appendChild(body.firstChild);
 }
 } else {
 returnNode = body;
 }
 if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
 /*
 AdoptNode() is not used because internal state is not reset
 (e.g. the past names map of a HTMLFormElement), this is safe
 in theory but we would rather not risk another attack vector.
 The state that is cloned by importNode() is explicitly defined
 by the specs.
 */
 returnNode = importNode.call(originalDocument, returnNode, true);
 }
 return returnNode;
 }
 let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
 /* Serialize doctype if allowed */
 if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
 serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\n' + serializedHTML;
 }
 /* Sanitize final string template-safe */
 if (SAFE_FOR_TEMPLATES) {
 arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
 serializedHTML = stringReplace(serializedHTML, expr, ' ');
 });
 }
 return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
 };
 DOMPurify.setConfig = function () {
 let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 _parseConfig(cfg);
 SET_CONFIG = true;
 };
 DOMPurify.clearConfig = function () {
 CONFIG = null;
 SET_CONFIG = false;
 };
 DOMPurify.isValidAttribute = function (tag, attr, value) {
 /* Initialize shared config vars if necessary. */
 if (!CONFIG) {
 _parseConfig({});
 }
 const lcTag = transformCaseFunc(tag);
 const lcName = transformCaseFunc(attr);
 return _isValidAttribute(lcTag, lcName, value);
 };
 DOMPurify.addHook = function (entryPoint, hookFunction) {
 if (typeof hookFunction !== 'function') {
 return;
 }
 arrayPush(hooks[entryPoint], hookFunction);
 };
 DOMPurify.removeHook = function (entryPoint, hookFunction) {
 if (hookFunction !== undefined) {
 const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
 return index === -1 ? undefined : arraySplice(hooks[entryPoint], index, 1)[0];
 }
 return arrayPop(hooks[entryPoint]);
 };
 DOMPurify.removeHooks = function (entryPoint) {
 hooks[entryPoint] = [];
 };
 DOMPurify.removeAllHooks = function () {
 hooks = _createHooksMap();
 };
 return DOMPurify;
 }
 var purify = createDOMPurify();

/**
 * This class handles parsing, modification and serialization of URI/URL strings.
 * @class tinymce.util.URI
 */
 const each$6 = Tools.each, trim = Tools.trim;
 const queryParts = [
 'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host',
 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
 ];
 const DEFAULT_PORTS = {
 ftp: 21,
 http: 80,
 https: 443,
 mailto: 25
 };
 const safeSvgDataUrlElements = ['img', 'video'];
 const blockSvgDataUris = (allowSvgDataUrls, tagName) => {
 if (isNonNullable(allowSvgDataUrls)) {
 return !allowSvgDataUrls;
 }
 else {
 // Only allow SVGs by default on images/videos since the browser won't execute scripts on those elements
 return isNonNullable(tagName) ? !contains$2(safeSvgDataUrlElements, tagName) : true;
 }
 };
 const decodeUri = (encodedUri) => {
 try {
 // Might throw malformed URI sequence
 return decodeURIComponent(encodedUri);
 }
 catch {
 // Fallback to non UTF-8 decoder
 return unescape(encodedUri);
 }
 };
 const isInvalidUri = (settings, uri, tagName) => {
 // remove all whitespaces from decoded uri to prevent impact on regex matching
 const decodedUri = decodeUri(uri).replace(/\s/g, '');
 if (settings.allow_script_urls) {
 return false;
 // Ensure we don't have a javascript URI, as that is not safe since it allows arbitrary JavaScript execution
 }
 else if (/((java|vb)script|mhtml):/i.test(decodedUri)) {
 return true;
 }
 else if (settings.allow_html_data_urls) {
 return false;
 }
 else if (/^data:image\//i.test(decodedUri)) {
 return blockSvgDataUris(settings.allow_svg_data_urls, tagName) && /^data:image\/svg\+xml/i.test(decodedUri);
 }
 else {
 return /^data:/i.test(decodedUri);
 }
 };
 class URI {
 static parseDataUri(uri) {
 let type;
 const uriComponents = decodeURIComponent(uri).split(',');
 const matches = /data:([^;]+)/.exec(uriComponents[0]);
 if (matches) {
 type = matches[1];
 }
 return {
 type,
 data: uriComponents[1]
 };
 }
 /**
 * Check to see if a URI is safe to use in the Document Object Model (DOM). This will return
 * true if the URI can be used in the DOM without potentially triggering a security issue.
 *
 * @method isDomSafe
 * @static
 * @param {String} uri The URI to be validated.
 * @param {Object} context An optional HTML tag name where the element is being used.
 * @param {Object} options An optional set of options to use when determining if the URI is safe.
 * @return {Boolean} True if the URI is safe, otherwise false.
 */
 static isDomSafe(uri, context, options = {}) {
 if (options.allow_script_urls) {
 return true;
 }
 else {
 const decodedUri = Entities.decode(uri).replace(/[\s\u0000-\u001F]+/g, '');
 return !isInvalidUri(options, decodedUri, context);
 }
 }
 static getDocumentBaseUrl(loc) {
 let baseUrl;
 // Pass applewebdata:// and other non web protocols though
 if (loc.protocol.indexOf('http') !== 0 && loc.protocol !== 'file:') {
 baseUrl = loc.href ?? '';
 }
 else {
 baseUrl = loc.protocol + '//' + loc.host + loc.pathname;
 }
 if (/^[^:]+:\/\/\/?[^\/]+\//.test(baseUrl)) {
 baseUrl = baseUrl.replace(/[\?#].*$/, '').replace(/[\/\\][^\/]+$/, '');
 if (!/[\/\\]$/.test(baseUrl)) {
 baseUrl += '/';
 }
 }
 return baseUrl;
 }
 source;
 protocol;
 authority;
 userInfo;
 user;
 password;
 host;
 port;
 relative;
 path = '';
 directory = '';
 file;
 query;
 anchor;
 settings;
 /**
 * Constructs a new URI instance.
 *
 * @constructor
 * @method URI
 * @param {String} url URI string to parse.
 * @param {Object} settings Optional settings object.
 */
 constructor(url, settings = {}) {
 url = trim(url);
 this.settings = settings;
 const baseUri = settings.base_uri;
 const self = this;
 // Strange app protocol that isn't http/https or local anchor
 // For example: mailto,skype,tel etc.
 if (/^([\w\-]+):([^\/]{2})/i.test(url) || /^\s*#/.test(url)) {
 self.source = url;
 return;
 }
 const isProtocolRelative = url.indexOf('//') === 0;
 // Absolute path with no host, fake host and protocol
 if (url.indexOf('/') === 0 && !isProtocolRelative) {
 url = (baseUri ? baseUri.protocol || 'http' : 'http') + '://mce_host' + url;
 }
 // Relative path http:// or protocol relative //path
 if (!/^[\w\-]*:?\/\//.test(url)) {
 const baseUrl = baseUri ? baseUri.path : new URI(document.location.href).directory;
 if (baseUri?.protocol === '') {
 url = '//mce_host' + self.toAbsPath(baseUrl, url);
 }
 else {
 const match = /([^#?]*)([#?]?.*)/.exec(url);
 if (match) {
 url = ((baseUri && baseUri.protocol) || 'http') + '://mce_host' + self.toAbsPath(baseUrl, match[1]) + match[2];
 }
 }
 }
 // Parse URL (Credits goes to Steave, http://blog.stevenlevithan.com/archives/parseuri)
 url = url.replace(/@@/g, '(mce_at)'); // Zope 3 workaround, they use @@something
 const urlMatch = /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@\/]*):?([^:@\/]*))?@)?(\[[a-zA-Z0-9:.%]+\]|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/.exec(url);
 if (urlMatch) {
 each$6(queryParts, (v, i) => {
 let part = urlMatch[i];
 // Zope 3 workaround, they use @@something
 if (part) {
 part = part.replace(/$mce_at$/g, '@@');
 }
 self[v] = part;
 });
 }
 if (baseUri) {
 if (!self.protocol) {
 self.protocol = baseUri.protocol;
 }
 if (!self.userInfo) {
 self.userInfo = baseUri.userInfo;
 }
 if (!self.port && self.host === 'mce_host') {
 self.port = baseUri.port;
 }
 if (!self.host || self.host === 'mce_host') {
 self.host = baseUri.host;
 }
 self.source = '';
 }
 if (isProtocolRelative) {
 self.protocol = '';
 }
 }
 /**
 * Sets the internal path part of the URI.
 *
 * @method setPath
 * @param {String} path Path string to set.
 */
 setPath(path) {
 const pathMatch = /^(.*?)\/?(\w+)?$/.exec(path);
 // Update path parts
 if (pathMatch) {
 this.path = pathMatch[0];
 this.directory = pathMatch[1];
 this.file = pathMatch[2];
 }
 // Rebuild source
 this.source = '';
 this.getURI();
 }
 /**
 * Converts the specified URI into a relative URI based on the current URI instance location.
 *
 * @method toRelative
 * @param {String} uri URI to convert into a relative path/URI.
 * @return {String} Relative URI from the point specified in the current URI instance.
 * @example
 * // Converts an absolute URL to an relative URL url will be somedir/somefile.htm
 * const url = new tinymce.util.URI('http://www.site.com/dir/').toRelative('http://www.site.com/dir/somedir/somefile.htm');
 */
 toRelative(uri) {
 if (uri === './') {
 return uri;
 }
 const relativeUri = new URI(uri, { base_uri: this });
 // Not on same domain/port or protocol
 if ((relativeUri.host !== 'mce_host' && this.host !== relativeUri.host && relativeUri.host) || this.port !== relativeUri.port ||
 (this.protocol !== relativeUri.protocol && relativeUri.protocol !== '')) {
 return relativeUri.getURI();
 }
 const tu = this.getURI(), uu = relativeUri.getURI();
 // Allow usage of the base_uri when relative_urls = true
 if (tu === uu || (tu.charAt(tu.length - 1) === '/' && tu.substr(0, tu.length - 1) === uu)) {
 return tu;
 }
 let output = this.toRelPath(this.path, relativeUri.path);
 // Add query
 if (relativeUri.query) {
 output += '?' + relativeUri.query;
 }
 // Add anchor
 if (relativeUri.anchor) {
 output += '#' + relativeUri.anchor;
 }
 return output;
 }
 /**
 * Converts the specified URI into a absolute URI based on the current URI instance location.
 *
 * @method toAbsolute
 * @param {String} uri URI to convert into a relative path/URI.
 * @param {Boolean} noHost No host and protocol prefix.
 * @return {String} Absolute URI from the point specified in the current URI instance.
 * @example
 * // Converts an relative URL to an absolute URL url will be http://www.site.com/dir/somedir/somefile.htm
 * const url = new tinymce.util.URI('http://www.site.com/dir/').toAbsolute('somedir/somefile.htm');
 */
 toAbsolute(uri, noHost) {
 const absoluteUri = new URI(uri, { base_uri: this });
 return absoluteUri.getURI(noHost && this.isSameOrigin(absoluteUri));
 }
 /**
 * Determine whether the given URI has the same origin as this URI. Based on RFC-6454.
 * Supports default ports for protocols listed in DEFAULT_PORTS. Unsupported protocols will fail safe: they
 * won't match, if the port specifications differ.
 *
 * @method isSameOrigin
 * @param {tinymce.util.URI} uri Uri instance to compare.
 * @returns {Boolean} True if the origins are the same.
 */
 isSameOrigin(uri) {
 // eslint-disable-next-line eqeqeq
 if (this.host == uri.host && this.protocol == uri.protocol) {
 // eslint-disable-next-line eqeqeq
 if (this.port == uri.port) {
 return true;
 }
 const defaultPort = this.protocol ? DEFAULT_PORTS[this.protocol] : null;
 // eslint-disable-next-line eqeqeq
 if (defaultPort && ((this.port || defaultPort) == (uri.port || defaultPort))) {
 return true;
 }
 }
 return false;
 }
 /**
 * Converts a absolute path into a relative path.
 *
 * @method toRelPath
 * @param {String} base Base point to convert the path from.
 * @param {String} path Absolute path to convert into a relative path.
 */
 toRelPath(base, path) {
 let breakPoint = 0, out = '', i, l;
 // Split the paths
 const normalizedBase = base.substring(0, base.lastIndexOf('/')).split('/');
 const items = path.split('/');
 if (normalizedBase.length >= items.length) {
 for (i = 0, l = normalizedBase.length; i < l; i++) {
 if (i >= items.length || normalizedBase[i] !== items[i]) {
 breakPoint = i + 1;
 break;
 }
 }
 }
 if (normalizedBase.length < items.length) {
 for (i = 0, l = items.length; i < l; i++) {
 if (i >= normalizedBase.length || normalizedBase[i] !== items[i]) {
 breakPoint = i + 1;
 break;
 }
 }
 }
 if (breakPoint === 1) {
 return path;
 }
 for (i = 0, l = normalizedBase.length - (breakPoint - 1); i < l; i++) {
 out += '../';
 }
 for (i = breakPoint - 1, l = items.length; i < l; i++) {
 if (i !== breakPoint - 1) {
 out += '/' + items[i];
 }
 else {
 out += items[i];
 }
 }
 return out;
 }
 /**
 * Converts a relative path into a absolute path.
 *
 * @method toAbsPath
 * @param {String} base Base point to convert the path from.
 * @param {String} path Relative path to convert into an absolute path.
 */
 toAbsPath(base, path) {
 let nb = 0;
 // Split paths
 const tr = /\/$/.test(path) ? '/' : '';
 const normalizedBase = base.split('/');
 const normalizedPath = path.split('/');
 // Remove empty chunks
 const baseParts = [];
 each$6(normalizedBase, (k) => {
 if (k) {
 baseParts.push(k);
 }
 });
 // Merge relURLParts chunks
 const pathParts = [];
 for (let i = normalizedPath.length - 1; i >= 0; i--) {
 // Ignore empty or .
 if (normalizedPath[i].length === 0 || normalizedPath[i] === '.') {
 continue;
 }
 // Is parent
 if (normalizedPath[i] === '..') {
 nb++;
 continue;
 }
 // Move up
 if (nb > 0) {
 nb--;
 continue;
 }
 pathParts.push(normalizedPath[i]);
 }
 const i = baseParts.length - nb;
 // If /a/b/c or /
 let outPath;
 if (i <= 0) {
 outPath = reverse(pathParts).join('/');
 }
 else {
 outPath = baseParts.slice(0, i).join('/') + '/' + reverse(pathParts).join('/');
 }
 // Add front / if it's needed
 if (outPath.indexOf('/') !== 0) {
 outPath = '/' + outPath;
 }
 // Add trailing / if it's needed
 if (tr && outPath.lastIndexOf('/') !== outPath.length - 1) {
 outPath += tr;
 }
 return outPath;
 }
 /**
 * Returns the full URI of the internal structure.
 *
 * @method getURI
 * @param {Boolean} noProtoHost Optional no host and protocol part. Defaults to false.
 */
 getURI(noProtoHost = false) {
 let s;
 // Rebuild source
 if (!this.source || noProtoHost) {
 s = '';
 if (!noProtoHost) {
 if (this.protocol) {
 s += this.protocol + '://';
 }
 else {
 s += '//';
 }
 if (this.userInfo) {
 s += this.userInfo + '@';
 }
 if (this.host) {
 s += this.host;
 }
 if (this.port) {
 s += ':' + this.port;
 }
 }
 if (this.path) {
 s += this.path;
 }
 if (this.query) {
 s += '?' + this.query;
 }
 if (this.anchor) {
 s += '#' + this.anchor;
 }
 this.source = s;
 }
 return this.source;
 }
 }

// A list of attributes that should be filtered further based on the parser settings
    const filteredUrlAttrs = Tools.makeMap('src,href,data,background,action,formaction,poster,xlink:href');
    const internalElementAttr = 'data-mce-type';
    let uid = 0;
    const processNode = (node, settings, schema, scope, evt) => {
        const validate = settings.validate;
        const specialElements = schema.getSpecialElements();
        if (node.nodeType === COMMENT) {
            // Pad conditional comments if they aren't allowed
            if (!settings.allow_conditional_comments && /^\[if/i.test(node.nodeValue ?? '')) {
                node.nodeValue = ' ' + node.nodeValue;
            }
            if (settings.sanitize && settings.allow_html_in_comments && isString(node.nodeValue)) {
                node.nodeValue = encodeData(node.nodeValue);
            }
        }
        const lcTagName = evt?.tagName ?? node.nodeName.toLowerCase();
        if (scope !== 'html' && schema.isValid(scope)) {
            if (isNonNullable(evt)) {
                evt.allowedTags[lcTagName] = true;
            }
            return;
        }
        // Just leave non-elements such as text and comments up to dompurify
        if (node.nodeType !== ELEMENT || lcTagName === 'body') {
            return;
        }
        // Construct the sugar element wrapper
        const element = SugarElement.fromDom(node);
        // Determine if we're dealing with an internal attribute
        const isInternalElement = has$1(element, internalElementAttr);
        // Cleanup bogus elements
        const bogus = get$9(element, 'data-mce-bogus');
        if (!isInternalElement && isString(bogus)) {
            if (bogus === 'all') {
                remove$8(element);
            }
            else {
                unwrap(element);
            }
            return;
        }
        // Determine if the schema allows the element and either add it or remove it
        const rule = schema.getElementRule(lcTagName);
        if (validate && !rule) {
            // If a special element is invalid, then remove the entire element instead of unwrapping
            if (has$2(specialElements, lcTagName)) {
                remove$8(element);
            }
            else {
                unwrap(element);
            }
            return;
        }
        else {
            if (isNonNullable(evt)) {
                evt.allowedTags[lcTagName] = true;
            }
        }
        // Validate the element using the attribute rules
        if (validate && rule && !isInternalElement) {
            // Fix the attributes for the element, unwrapping it if we have to
            each$e(rule.attributesForced ?? [], (attr) => {
                set$4(element, attr.name, attr.value === '{$uid}' ? `mce_${uid++}` : attr.value);
            });
            each$e(rule.attributesDefault ?? [], (attr) => {
                if (!has$1(element, attr.name)) {
                    set$4(element, attr.name, attr.value === '{$uid}' ? `mce_${uid++}` : attr.value);
                }
            });
            // If none of the required attributes were found then remove
            if (rule.attributesRequired && !exists(rule.attributesRequired, (attr) => has$1(element, attr))) {
                unwrap(element);
                return;
            }
            // If there are no attributes then remove
            if (rule.removeEmptyAttrs && hasNone(element)) {
                unwrap(element);
                return;
            }
            // Change the node name if the schema says to
            if (rule.outputName && rule.outputName !== lcTagName) {
                mutate(element, rule.outputName);
            }
        }
    };
    const processAttr = (ele, settings, schema, scope, evt) => {
        const tagName = ele.tagName.toLowerCase();
        const { attrName, attrValue } = evt;
        evt.keepAttr = shouldKeepAttribute(settings, schema, scope, tagName, attrName, attrValue);
        if (evt.keepAttr) {
            evt.allowedAttributes[attrName] = true;
            if (isBooleanAttributeOfNonCustomElement(attrName, schema, ele.nodeName)) {
                evt.attrValue = attrName;
            }
            // We need to tell DOMPurify to forcibly keep the attribute if it's an SVG data URI and svg data URIs are allowed
            if (settings.allow_svg_data_urls && startsWith(attrValue, 'data:image/svg+xml')) {
                evt.forceKeepAttr = true;
            }
            // For internal elements always keep the attribute if the attribute name is id, class or style
        }
        else if (isRequiredAttributeOfInternalElement(ele, attrName)) {
            evt.forceKeepAttr = true;
        }
    };
    const shouldKeepAttribute = (settings, schema, scope, tagName, attrName, attrValue) => {
        // All attributes within non HTML namespaces elements are considered valid
        if (scope !== 'html' && !isNonHtmlElementRootName(tagName)) {
            return true;
        }
        return !(attrName in filteredUrlAttrs && isInvalidUri(settings, attrValue, tagName)) &&
            (!settings.validate || schema.isValid(tagName, attrName) || startsWith(attrName, 'data-') || startsWith(attrName, 'aria-'));
    };
    const isRequiredAttributeOfInternalElement = (ele, attrName) => ele.hasAttribute(internalElementAttr) && (attrName === 'id' || attrName === 'class' || attrName === 'style');
    const isBooleanAttributeOfNonCustomElement = (attrName, schema, nodeName) => attrName in schema.getBoolAttrs() && !has$2(schema.getCustomElements(), nodeName.toLowerCase());
    const filterAttributes = (ele, settings, schema, scope) => {
        const { attributes } = ele;
        for (let i = attributes.length - 1; i >= 0; i--) {
            const attr = attributes[i];
            const attrName = attr.name;
            const attrValue = attr.value;
            if (!shouldKeepAttribute(settings, schema, scope, ele.tagName.toLowerCase(), attrName, attrValue) && !isRequiredAttributeOfInternalElement(ele, attrName)) {
                ele.removeAttribute(attrName);
            }
            else if (isBooleanAttributeOfNonCustomElement(attrName, schema, ele.nodeName)) {
                ele.setAttribute(attrName, attrName);
            }
        }
    };
    const setupPurify = (settings, schema, namespaceTracker) => {
        const purify$1 = purify();
        // We use this to add new tags to the allow-list as we parse, if we notice that a tag has been banned but it's still in the schema
        purify$1.addHook('uponSanitizeElement', (ele, evt) => {
            processNode(ele, settings, schema, namespaceTracker.track(ele), evt);
        });
        // Let's do the same thing for attributes
        purify$1.addHook('uponSanitizeAttribute', (ele, evt) => {
            processAttr(ele, settings, schema, namespaceTracker.current(), evt);
        });
        return purify$1;
    };
    const getPurifyConfig = (settings, mimeType) => {
        const basePurifyConfig = {
            IN_PLACE: true,
            ALLOW_UNKNOWN_PROTOCOLS: true,
            // Deliberately ban all tags and attributes by default, and then un-ban them on demand in hooks
            // #comment and #cdata-section are always allowed as they aren't controlled via the schema
            // body is also allowed due to the DOMPurify checking the root node before sanitizing
            ALLOWED_TAGS: ['#comment', '#cdata-section', 'body', 'html'],
            ALLOWED_ATTR: []
        };
        const config = { ...basePurifyConfig };
        // Set the relevant parser mimetype
        config.PARSER_MEDIA_TYPE = mimeType;
        // Allow any URI when allowing script urls
        if (settings.allow_script_urls) {
            config.ALLOWED_URI_REGEXP = /.*/;
            // Allow anything except javascript (or similar) URIs if all html data urls are allowed
        }
        else if (settings.allow_html_data_urls) {
            config.ALLOWED_URI_REGEXP = /^(?!(\w+script|mhtml):)/i;
        }
        return config;
    };
    const sanitizeSvgElement = (ele) => {
        // xlink:href used to be the way to do links in SVG 1.x https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/xlink:href
        const xlinkAttrs = ['type', 'href', 'role', 'arcrole', 'title', 'show', 'actuate', 'label', 'from', 'to'].map((name) => `xlink:${name}`);
        const config = {
            IN_PLACE: true,
            USE_PROFILES: {
                html: true,
                svg: true,
                svgFilters: true
            },
            ALLOWED_ATTR: xlinkAttrs
        };
        purify().sanitize(ele, config);
    };
    const sanitizeMathmlElement = (node, settings) => {
        const config = {
            IN_PLACE: true,
            USE_PROFILES: {
                mathMl: true
            },
        };
        const purify$1 = purify();
        const allowedEncodings = settings.allow_mathml_annotation_encodings;
        const hasAllowedEncodings = isArray$1(allowedEncodings) && allowedEncodings.length > 0;
        const hasValidEncoding = (el) => {
            const encoding = el.getAttribute('encoding');
            return hasAllowedEncodings && isString(encoding) && contains$2(allowedEncodings, encoding);
        };
        const isValidElementOpt = (node, lcTagName) => {
            if (hasAllowedEncodings && lcTagName === 'semantics') {
                return Optional.some(true);
            }
            else if (lcTagName === 'annotation') {
                return Optional.some(isElement$7(node) && hasValidEncoding(node));
            }
            else if (isArray$1(settings.extended_mathml_elements)) {
                if (settings.extended_mathml_elements.includes(lcTagName)) {
                    return Optional.from(true);
                }
                else {
                    return Optional.none();
                }
            }
            else {
                return Optional.none();
            }
        };
        purify$1.addHook('uponSanitizeElement', (node, evt) => {
            // We know the node is an element as we have
            // passed an element to the purify.sanitize function below
            const lcTagName = evt.tagName ?? node.nodeName.toLowerCase();
            const keepElementOpt = isValidElementOpt(node, lcTagName);
            keepElementOpt.each((keepElement) => {
                evt.allowedTags[lcTagName] = keepElement;
                if (!keepElement && settings.sanitize) {
                    if (isElement$7(node)) {
                        node.remove();
                    }
                }
            });
        });
        purify$1.addHook('uponSanitizeAttribute', (_node, event) => {
            if (isArray$1(settings.extended_mathml_attributes)) {
                const keepAttribute = settings.extended_mathml_attributes.includes(event.attrName);
                if (keepAttribute) {
                    event.forceKeepAttr = true;
                }
            }
        });
        purify$1.sanitize(node, config);
    };
    const mkSanitizeNamespaceElement = (settings) => (ele) => {
        const namespaceType = toScopeType(ele);
        if (namespaceType === 'svg') {
            sanitizeSvgElement(ele);
        }
        else if (namespaceType === 'math') {
            sanitizeMathmlElement(ele, settings);
        }
        else {
            throw new Error('Not a namespace element');
        }
    };
    const getSanitizer = (settings, schema) => {
        const namespaceTracker = createNamespaceTracker();
        if (settings.sanitize) {
            const purify = setupPurify(settings, schema, namespaceTracker);
            const sanitizeHtmlElement = (body, mimeType) => {
                purify.sanitize(body, getPurifyConfig(settings, mimeType));
                purify.removed = [];
                namespaceTracker.reset();
            };
            return {
                sanitizeHtmlElement,
                sanitizeNamespaceElement: mkSanitizeNamespaceElement(settings)
            };
        }
        else {
            const sanitizeHtmlElement = (body, _mimeType) => {
                // eslint-disable-next-line no-bitwise
                const nodeIterator = document.createNodeIterator(body, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT);
                let node;
                while ((node = nodeIterator.nextNode())) {
                    const currentScope = namespaceTracker.track(node);
                    processNode(node, settings, schema, currentScope);
                    if (isElement$7(node)) {
                        filterAttributes(node, settings, schema, currentScope);
                    }
                }
                namespaceTracker.reset();
            };
            const sanitizeNamespaceElement = noop;
            return {
                sanitizeHtmlElement,
                sanitizeNamespaceElement
            };
        }
    };

/**
 * @summary
 * This class parses HTML code into a DOM like structure of nodes it will remove redundant whitespace and make
 * sure that the node tree is valid according to the specified schema.
 * So for example: `abc` will become `abc`.
 *
 * @example
 * const parser = tinymce.html.DomParser({ validate: true }, schema);
 * const rootNode = parser.parse('<h1>content</h1>');
 *
 * @class tinymce.html.DomParser
 * @version 3.4
 */
 const extraBlockLikeElements = ['script', 'style', 'template', 'param', 'meta', 'title', 'link'];
 const makeMap = Tools.makeMap, extend$1 = Tools.extend;
 const transferChildren = (parent, nativeParent, specialElements, nsSanitizer, decodeComments) => {
 const parentName = parent.name;
 // Exclude the special elements where the content is RCDATA as their content needs to be parsed instead of being left as plain text
 // See: https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
 const isSpecial = parentName in specialElements && parentName !== 'title' && parentName !== 'textarea' && parentName !== 'noscript';
 const childNodes = nativeParent.childNodes;
 for (let ni = 0, nl = childNodes.length; ni < nl; ni++) {
 const nativeChild = childNodes[ni];
 const child = new AstNode(nativeChild.nodeName.toLowerCase(), nativeChild.nodeType);
 if (isElement$7(nativeChild)) {
 const attributes = nativeChild.attributes;
 for (let ai = 0, al = attributes.length; ai < al; ai++) {
 const attr = attributes[ai];
 child.attr(attr.name, attr.value);
 }
 if (isNonHtmlElementRootName(child.name)) {
 nsSanitizer(nativeChild);
 child.value = nativeChild.innerHTML;
 }
 }
 else if (isText$b(nativeChild)) {
 child.value = nativeChild.data;
 if (isSpecial) {
 child.raw = true;
 }
 }
 else if (isComment(nativeChild)) {
 child.value = decodeComments ? decodeData$1(nativeChild.data) : nativeChild.data;
 }
 else if (isCData(nativeChild) || isPi(nativeChild)) {
 child.value = nativeChild.data;
 }
 if (isTemplate(nativeChild)) {
 const content = AstNode.create('#text');
 content.value = nativeChild.innerHTML;
 content.raw = true;
 child.append(content);
 }
 else if (!isNonHtmlElementRootName(child.name)) {
 transferChildren(child, nativeChild, specialElements, nsSanitizer, decodeComments);
 }
 parent.append(child);
 }
 };
 const walkTree = (root, preprocessors, postprocessors) => {
 const traverseOrder = [];
 for (let node = root, lastNode = node; node; lastNode = node, node = node.walk()) {
 const tempNode = node;
 each$e(preprocessors, (preprocess) => preprocess(tempNode));
 if (isNullable(tempNode.parent) && tempNode !== root) {
 // The node has been detached, so rewind a little and don't add it to our traversal
 node = lastNode;
 }
 else {
 traverseOrder.push(tempNode);
 }
 }
 for (let i = traverseOrder.length - 1; i >= 0; i--) {
 const node = traverseOrder[i];
 each$e(postprocessors, (postprocess) => postprocess(node));
 }
 };
 // All the dom operations we want to perform, regardless of whether we're trying to properly validate things
 // e.g. removing excess whitespace
 // e.g. removing empty nodes (or padding them with )
 //
 // Returns [ preprocess, postprocess ]
 const whitespaceCleaner = (root, schema, settings, args) => {
 const validate = settings.validate;
 const nonEmptyElements = schema.getNonEmptyElements();
 const whitespaceElements = schema.getWhitespaceElements();
 const blockElements = extend$1(makeMap(extraBlockLikeElements), schema.getBlockElements());
 const textRootBlockElements = getTextRootBlockElements(schema);
 const allWhiteSpaceRegExp = /[ \t\r\n]+/g;
 const startWhiteSpaceRegExp = /^[ \t\r\n]+/;
 const endWhiteSpaceRegExp = /[ \t\r\n]+$/;
 const hasWhitespaceParent = (node) => {
 let tempNode = node.parent;
 while (isNonNullable(tempNode)) {
 if (tempNode.name in whitespaceElements) {
 return true;
 }
 else {
 tempNode = tempNode.parent;
 }
 }
 return false;
 };
 const isTextRootBlockEmpty = (node) => {
 let tempNode = node;
 while (isNonNullable(tempNode)) {
 if (tempNode.name in textRootBlockElements) {
 return isEmpty$2(schema, nonEmptyElements, whitespaceElements, tempNode);
 }
 else {
 tempNode = tempNode.parent;
 }
 }
 return false;
 };
 const isBlock = (node) => node.name in blockElements || isTransparentAstBlock(schema, node) || (isNonHtmlElementRootName(node.name) && node.parent === root);
 const isAtEdgeOfBlock = (node, start) => {
 const neighbour = start ? node.prev : node.next;
 if (isNonNullable(neighbour) || isNullable(node.parent)) {
 return false;
 }
 // Make sure our parent is actually a block, and also make sure it isn't a temporary "context" element
 // that we're probably going to unwrap as soon as we insert this content into the editor
 return isBlock(node.parent) && (node.parent !== root || args.isRootContent === true);
 };
 const preprocess = (node) => {
 if (node.type === 3) {
 // Remove leading whitespace here, so that all whitespace in nodes to the left of us has already been fixed
 if (!hasWhitespaceParent(node)) {
 let text = node.value ?? '';
 text = text.replace(allWhiteSpaceRegExp, ' ');
 if (isLineBreakNode(node.prev, isBlock) || isAtEdgeOfBlock(node, true)) {
 text = text.replace(startWhiteSpaceRegExp, '');
 }
 if (text.length === 0) {
 node.remove();
 }
 else if (text === ' ' && node.prev && node.prev.type === COMMENT && node.next && node.next.type === COMMENT) {
 node.remove();
 }
 else {
 node.value = text;
 }
 }
 }
 };
 const postprocess = (node) => {
 if (node.type === 1) {
 // Check for empty nodes here, because children will have been processed and (if necessary) emptied / removed already
 const elementRule = schema.getElementRule(node.name);
 if (validate && elementRule) {
 const isNodeEmpty = isEmpty$2(schema, nonEmptyElements, whitespaceElements, node);
 if (elementRule.paddInEmptyBlock && isNodeEmpty && isTextRootBlockEmpty(node)) {
 paddEmptyNode(settings, args, isBlock, node);
 }
 else if (elementRule.removeEmpty && isNodeEmpty) {
 if (isBlock(node)) {
 node.remove();
 }
 else {
 node.unwrap();
 }
 }
 else if (elementRule.paddEmpty && (isNodeEmpty || isPaddedWithNbsp(node))) {
 paddEmptyNode(settings, args, isBlock, node);
 }
 }
 }
 else if (node.type === 3) {
 // Removing trailing whitespace here, so that all whitespace in nodes to the right of us has already been fixed
 if (!hasWhitespaceParent(node)) {
 let text = node.value ?? '';
 if (node.next && isBlock(node.next) || isAtEdgeOfBlock(node, false)) {
 text = text.replace(endWhiteSpaceRegExp, '');
 }
 if (text.length === 0) {
 node.remove();
 }
 else {
 node.value = text;
 }
 }
 }
 };
 return [preprocess, postprocess];
 };
 const getRootBlockName = (settings, args) => {
 const name = args.forced_root_block ?? settings.forced_root_block;
 if (name === false) {
 return '';
 }
 else if (name === true) {
 return 'p';
 }
 else {
 return name;
 }
 };
 const xhtmlAttribte = ' xmlns="http://www.w3.org/1999/xhtml"';
 const DomParser = (settings = {}, schema = Schema()) => {
 const nodeFilterRegistry = create$8();
 const attributeFilterRegistry = create$8();
 // Apply setting defaults
 const defaultedSettings = {
 validate: true,
 root_name: 'body',
 sanitize: true,
 allow_html_in_comments: false,
 ...settings
 };
 const parser = new DOMParser();
 const sanitizer = getSanitizer(defaultedSettings, schema);
 const parseAndSanitizeWithContext = (html, rootName, format = 'html', useDocumentNotBody = false) => {
 const isxhtml = format === 'xhtml';
 const mimeType = isxhtml ? 'application/xhtml+xml' : 'text/html';
 // Determine the root element to wrap the HTML in when parsing. If we're dealing with a
 // special element then we need to wrap it so the internal content is handled appropriately.
 const isSpecialRoot = has$2(schema.getSpecialElements(), rootName.toLowerCase());
 const content = isSpecialRoot ? `<${rootName}>${html}</${rootName}>` : html;
 const makeWrap = () => {
 if (/^[\s]*<head/i.test(html) || /^[\s]*<html/i.test(html) || /^[\s]*<!DOCTYPE/i.test(html)) {
 return `<html${isxhtml ? xhtmlAttribte : ''}>${content}</html>`;
 }
 else {
 if (isxhtml) {
 return `<html${xhtmlAttribte}><head></head><body>${content}</body></html>`;
 }
 else {
 return `<body>${content}</body>`;
 }
 }
 };
 const document = parser.parseFromString(makeWrap(), mimeType);
 const body = useDocumentNotBody ? document.documentElement : document.body;
 sanitizer.sanitizeHtmlElement(body, mimeType);
 return isSpecialRoot ? body.firstChild : body;
 };
 /**
 * Adds a node filter function to the parser, the parser will collect the specified nodes by name
 * and then execute the callback once it has finished parsing the document.
 *
 * @method addNodeFilter
 * @param {String} name Comma separated list of nodes to collect.
 * @param {Function} callback Callback function to execute once it has collected nodes.
 * @example
 * parser.addNodeFilter('p,h1', (nodes, name) => {
 * for (var i = 0; i < nodes.length; i++) {
 * console.log(nodes[i].name);
 * }
 * });
 */
 const addNodeFilter = nodeFilterRegistry.addFilter;
 const getNodeFilters = nodeFilterRegistry.getFilters;
 /**
 * Removes a node filter function or removes all filter functions from the parser for the node names provided.
 *
 * @method removeNodeFilter
 * @param {String} name Comma separated list of node names to remove filters for.
 * @param {Function} callback Optional callback function to only remove a specific callback.
 * @example
 * // Remove a single filter
 * parser.removeNodeFilter('p,h1', someCallback);
 *
 * // Remove all filters
 * parser.removeNodeFilter('p,h1');
 */
 const removeNodeFilter = nodeFilterRegistry.removeFilter;
 /**
 * Adds an attribute filter function to the parser, the parser will collect nodes that has the specified attributes
 * and then execute the callback once it has finished parsing the document.
 *
 * @method addAttributeFilter
 * @param {String} name Comma separated list of attributes to collect.
 * @param {Function} callback Callback function to execute once it has collected nodes.
 * @example
 * parser.addAttributeFilter('src,href', (nodes, name) => {
 * for (let i = 0; i < nodes.length; i++) {
 * console.log(nodes[i].name);
 * }
 * });
 */
 const addAttributeFilter = attributeFilterRegistry.addFilter;
 const getAttributeFilters = attributeFilterRegistry.getFilters;
 /**
 * Removes an attribute filter function or removes all filter functions from the parser for the attribute names provided.
 *
 * @method removeAttributeFilter
 * @param {String} name Comma separated list of attribute names to remove filters for.
 * @param {Function} callback Optional callback function to only remove a specific callback.
 * @example
 * // Remove a single filter
 * parser.removeAttributeFilter('src,href', someCallback);
 *
 * // Remove all filters
 * parser.removeAttributeFilter('src,href');
 */
 const removeAttributeFilter = attributeFilterRegistry.removeFilter;
 const findInvalidChildren = (node, invalidChildren) => {
 if (isInvalid(schema, node)) {
 invalidChildren.push(node);
 }
 };
 const isWrappableNode = (blockElements, node) => {
 const isInternalElement = isString(node.attr(internalElementAttr));
 const isInlineElement = node.type === 1 && (!has$2(blockElements, node.name) && !isTransparentAstBlock(schema, node)) && !isNonHtmlElementRootName(node.name);
 return node.type === 3 || (isInlineElement && !isInternalElement);
 };
 const addRootBlocks = (rootNode, rootBlockName) => {
 const blockElements = extend$1(makeMap(extraBlockLikeElements), schema.getBlockElements());
 const startWhiteSpaceRegExp = /^[ \t\r\n]+/;
 const endWhiteSpaceRegExp = /[ \t\r\n]+$/;
 let node = rootNode.firstChild, rootBlockNode = null;
 // Removes whitespace at beginning and end of block so:
 // x -> x
 const trim = (rootBlock) => {
 if (rootBlock) {
 node = rootBlock.firstChild;
 if (node && node.type === 3) {
 node.value = node.value?.replace(startWhiteSpaceRegExp, '');
 }
 node = rootBlock.lastChild;
 if (node && node.type === 3) {
 node.value = node.value?.replace(endWhiteSpaceRegExp, '');
 }
 }
 };
 // Check if rootBlock is valid within rootNode for example if P is valid in H1 if H1 is the contentEditable root
 if (!schema.isValidChild(rootNode.name, rootBlockName.toLowerCase())) {
 return;
 }
 while (node) {
 const next = node.next;
 if (isWrappableNode(blockElements, node)) {
 if (!rootBlockNode) {
 // Create a new root block element
 rootBlockNode = new AstNode(rootBlockName, 1);
 rootBlockNode.attr(defaultedSettings.forced_root_block_attrs);
 rootNode.insert(rootBlockNode, node);
 rootBlockNode.append(node);
 }
 else {
 rootBlockNode.append(node);
 }
 }
 else {
 trim(rootBlockNode);
 rootBlockNode = null;
 }
 node = next;
 }
 trim(rootBlockNode);
 };
 /**
 * Parses the specified HTML string into a DOM like node tree and returns the result.
 *
 * @method parse
 * @param {String} html Html string to sax parse.
 * @param {Object} args Optional args object that gets passed to all filter functions.
 * @return {tinymce.html.Node} Root node containing the tree.
 * @example
 * const rootNode = tinymce.html.DomParser({...}).parse('text');
 */
 const parse = (html, args = {}) => {
 const validate = defaultedSettings.validate;
 const preferFullDocument = (args.context ?? defaultedSettings.root_name) === '#document';
 const rootName = args.context ?? (preferFullDocument ? 'html' : defaultedSettings.root_name);
 // Parse and sanitize the content
 const element = parseAndSanitizeWithContext(html, rootName, args.format, preferFullDocument);
 updateChildren(schema, element);
 // Create the AST representation
 const rootNode = new AstNode(rootName, 11);
 transferChildren(rootNode, element, schema.getSpecialElements(), sanitizer.sanitizeNamespaceElement, defaultedSettings.sanitize && defaultedSettings.allow_html_in_comments);
 // This next line is needed to fix a memory leak in chrome and firefox.
 // For more information see TINY-9186
 element.innerHTML = '';
 // Set up whitespace fixes
 const [whitespacePre, whitespacePost] = whitespaceCleaner(rootNode, schema, defaultedSettings, args);
 // Find the invalid children in the tree
 const invalidChildren = [];
 const invalidFinder = validate ? (node) => findInvalidChildren(node, invalidChildren) : noop;
 // Set up attribute and node matching
 const matches = { nodes: {}, attributes: {} };
 const matchFinder = (node) => matchNode(getNodeFilters(), getAttributeFilters(), node, matches);
 // Walk the dom, apply all of the above things
 walkTree(rootNode, [whitespacePre, matchFinder], [whitespacePost, invalidFinder]);
 // Because we collected invalid children while walking backwards, we need to reverse the list before operating on them
 invalidChildren.reverse();
 // Fix invalid children or report invalid children in a contextual parsing
 if (validate && invalidChildren.length > 0) {
 if (args.context) {
 args.invalid = true;
 }
 else {
 cleanInvalidNodes(invalidChildren, schema, rootNode, matchFinder);
 }
 }
 // Wrap nodes in the root into block elements if the root is body
 const rootBlockName = getRootBlockName(defaultedSettings, args);
 if (rootBlockName && (rootNode.name === 'body' || args.isRootContent)) {
 addRootBlocks(rootNode, rootBlockName);
 }
 // Run filters only when the contents is valid
 if (!args.invalid) {
 runFilters(matches, args);
 }
 return rootNode;
 };
 const exports = {
 schema,
 addAttributeFilter,
 getAttributeFilters,
 removeAttributeFilter,
 addNodeFilter,
 getNodeFilters,
 removeNodeFilter,
 parse
 };
 register$4(exports, defaultedSettings);
 register$5(exports, defaultedSettings, schema);
 return exports;
 };

const isTreeNode = (content) => content instanceof AstNode;

/**
 * Handles inserts of lists into the editor instance.
 *
 * @class tinymce.InsertList
 * @private
 */
 const hasOnlyOneChild$1 = (node) => {
 return isNonNullable(node.firstChild) && node.firstChild === node.lastChild;
 };
 const isPaddingNode = (node) => {
 return node.name === 'br' || node.value === nbsp;
 };
 const isPaddedEmptyBlock = (schema, node) => {
 const blockElements = schema.getBlockElements();
 return blockElements[node.name] && hasOnlyOneChild$1(node) && isPaddingNode(node.firstChild);
 };
 const isEmptyFragmentElement = (schema, node) => {
 const nonEmptyElements = schema.getNonEmptyElements();
 return isNonNullable(node) && (node.isEmpty(nonEmptyElements) || isPaddedEmptyBlock(schema, node));
 };
 const isListFragment = (schema, fragment) => {
 let firstChild = fragment.firstChild;
 let lastChild = fragment.lastChild;
 // Skip meta since it's likely <meta><ul>..</ul>
 if (firstChild && firstChild.name === 'meta') {
 firstChild = firstChild.next;
 }
 // Skip mce_marker since it's likely <ul>..</ul>
 if (lastChild && lastChild.attr('id') === 'mce_marker') {
 lastChild = lastChild.prev;
 }
 // Skip last child if it's an empty block
 if (isEmptyFragmentElement(schema, lastChild)) {
 lastChild = lastChild?.prev;
 }
 if (!firstChild || firstChild !== lastChild) {
 return false;
 }
 return firstChild.name === 'ul' || firstChild.name === 'ol';
 };
 const cleanupDomFragment = (domFragment) => {
 const firstChild = domFragment.firstChild;
 const lastChild = domFragment.lastChild;
 // TODO: remove the meta tag from paste logic
 if (firstChild && firstChild.nodeName === 'META') {
 firstChild.parentNode?.removeChild(firstChild);
 }
 if (lastChild && lastChild.id === 'mce_marker') {
 lastChild.parentNode?.removeChild(lastChild);
 }
 return domFragment;
 };
 const toDomFragment = (dom, serializer, fragment) => {
 const html = serializer.serialize(fragment);
 const domFragment = dom.createFragment(html);
 return cleanupDomFragment(domFragment);
 };
 const listItems = (elm) => {
 return filter$5(elm?.childNodes ?? [], (child) => {
 return child.nodeName === 'LI';
 });
 };
 const isPadding = (node) => {
 return node.data === nbsp || isBr$7(node);
 };
 const isListItemPadded = (node) => {
 return isNonNullable(node?.firstChild) && node.firstChild === node.lastChild && isPadding(node.firstChild);
 };
 const isEmptyOrPadded = (elm) => {
 return !elm.firstChild || isListItemPadded(elm);
 };
 const trimListItems = (elms) => {
 return elms.length > 0 && isEmptyOrPadded(elms[elms.length - 1]) ? elms.slice(0, -1) : elms;
 };
 const getParentLi = (dom, node) => {
 const parentBlock = dom.getParent(node, dom.isBlock);
 return parentBlock && parentBlock.nodeName === 'LI' ? parentBlock : null;
 };
 const isParentBlockLi = (dom, node) => {
 return !!getParentLi(dom, node);
 };
 const getSplit = (parentNode, rng) => {
 const beforeRng = rng.cloneRange();
 const afterRng = rng.cloneRange();
 beforeRng.setStartBefore(parentNode);
 afterRng.setEndAfter(parentNode);
 return [
 beforeRng.cloneContents(),
 afterRng.cloneContents()
 ];
 };
 const findFirstIn = (node, rootNode) => {
 const caretPos = CaretPosition.before(node);
 const caretWalker = CaretWalker(rootNode);
 const newCaretPos = caretWalker.next(caretPos);
 return newCaretPos ? newCaretPos.toRange() : null;
 };
 const findLastOf = (node, rootNode) => {
 const caretPos = CaretPosition.after(node);
 const caretWalker = CaretWalker(rootNode);
 const newCaretPos = caretWalker.prev(caretPos);
 return newCaretPos ? newCaretPos.toRange() : null;
 };
 const insertMiddle = (target, elms, rootNode, rng) => {
 const parts = getSplit(target, rng);
 const parentElm = target.parentNode;
 if (parentElm) {
 parentElm.insertBefore(parts[0], target);
 Tools.each(elms, (li) => {
 parentElm.insertBefore(li, target);
 });
 parentElm.insertBefore(parts[1], target);
 parentElm.removeChild(target);
 }
 return findLastOf(elms[elms.length - 1], rootNode);
 };
 const insertBefore$2 = (target, elms, rootNode) => {
 const parentElm = target.parentNode;
 if (parentElm) {
 Tools.each(elms, (elm) => {
 parentElm.insertBefore(elm, target);
 });
 }
 return findFirstIn(target, rootNode);
 };
 const insertAfter$2 = (target, elms, rootNode, dom) => {
 dom.insertAfter(elms.reverse(), target);
 return findLastOf(elms[0], rootNode);
 };
 const insertAtCaret$1 = (serializer, dom, rng, fragment) => {
 const domFragment = toDomFragment(dom, serializer, fragment);
 const liTarget = getParentLi(dom, rng.startContainer);
 const liElms = trimListItems(listItems(domFragment.firstChild));
 const BEGINNING = 1, END = 2;
 const rootNode = dom.getRoot();
 const isAt = (location) => {
 const caretPos = CaretPosition.fromRangeStart(rng);
 const caretWalker = CaretWalker(dom.getRoot());
 const newPos = location === BEGINNING ? caretWalker.prev(caretPos) : caretWalker.next(caretPos);
 const newPosNode = newPos?.getNode();
 return newPosNode ? getParentLi(dom, newPosNode) !== liTarget : true;
 };
 if (!liTarget) {
 return null;
 }
 else if (isAt(BEGINNING)) {
 return insertBefore$2(liTarget, liElms, rootNode);
 }
 else if (isAt(END)) {
 return insertAfter$2(liTarget, liElms, rootNode, dom);
 }
 else {
 return insertMiddle(liTarget, liElms, rootNode, rng);
 }
 };

/**
 * JS Implementation of the O(ND) Difference Algorithm by Eugene W. Myers.
 *
 * @class tinymce.undo.Diff
 * @private
 */
 const KEEP = 0, INSERT = 1, DELETE = 2;
 const diff = (left, right) => {
 const size = left.length + right.length + 2;
 const vDown = new Array(size);
 const vUp = new Array(size);
 const snake = (start, end, diag) => {
 return {
 start,
 end,
 diag
 };
 };
 const buildScript = (start1, end1, start2, end2, script) => {
 const middle = getMiddleSnake(start1, end1, start2, end2);
 if (middle === null || middle.start === end1 && middle.diag === end1 - end2 ||
 middle.end === start1 && middle.diag === start1 - start2) {
 let i = start1;
 let j = start2;
 while (i < end1 || j < end2) {
 if (i < end1 && j < end2 && left[i] === right[j]) {
 script.push([KEEP, left[i]]);
 ++i;
 ++j;
 }
 else {
 if (end1 - start1 > end2 - start2) {
 script.push([DELETE, left[i]]);
 ++i;
 }
 else {
 script.push([INSERT, right[j]]);
 ++j;
 }
 }
 }
 }
 else {
 buildScript(start1, middle.start, start2, middle.start - middle.diag, script);
 for (let i2 = middle.start; i2 < middle.end; ++i2) {
 script.push([KEEP, left[i2]]);
 }
 buildScript(middle.end, end1, middle.end - middle.diag, end2, script);
 }
 };
 const buildSnake = (start, diag, end1, end2) => {
 let end = start;
 while (end - diag < end2 && end < end1 && left[end] === right[end - diag]) {
 ++end;
 }
 return snake(start, end, diag);
 };
 const getMiddleSnake = (start1, end1, start2, end2) => {
 // Myers Algorithm
 // Initialisations
 const m = end1 - start1;
 const n = end2 - start2;
 if (m === 0 || n === 0) {
 return null;
 }
 const delta = m - n;
 const sum = n + m;
 const offset = (sum % 2 === 0 ? sum : sum + 1) / 2;
 vDown[1 + offset] = start1;
 vUp[1 + offset] = end1 + 1;
 let d, k, i, x, y;
 for (d = 0; d <= offset; ++d) {
 // Down
 for (k = -d; k <= d; k += 2) {
 // First step
 i = k + offset;
 if (k === -d || k !== d && vDown[i - 1] < vDown[i + 1]) {
 vDown[i] = vDown[i + 1];
 }
 else {
 vDown[i] = vDown[i - 1] + 1;
 }
 x = vDown[i];
 y = x - start1 + start2 - k;
 while (x < end1 && y < end2 && left[x] === right[y]) {
 vDown[i] = ++x;
 ++y;
 }
 // Second step
 if (delta % 2 !== 0 && delta - d <= k && k <= delta + d) {
 if (vUp[i - delta] <= vDown[i]) {
 return buildSnake(vUp[i - delta], k + start1 - start2, end1, end2);
 }
 }
 }
 // Up
 for (k = delta - d; k <= delta + d; k += 2) {
 // First step
 i = k + offset - delta;
 if (k === delta - d || k !== delta + d && vUp[i + 1] <= vUp[i - 1]) {
 vUp[i] = vUp[i + 1] - 1;
 }
 else {
 vUp[i] = vUp[i - 1];
 }
 x = vUp[i] - 1;
 y = x - start1 + start2 - k;
 while (x >= start1 && y >= start2 && left[x] === right[y]) {
 vUp[i] = x--;
 y--;
 }
 // Second step
 if (delta % 2 === 0 && -d <= k && k <= d) {
 if (vUp[i] <= vDown[i + delta]) {
 return buildSnake(vUp[i], k + start1 - start2, end1, end2);
 }
 }
 }
 }
 return null;
 };
 const script = [];
 buildScript(0, left.length, 0, right.length, script);
 return script;
 };

/**
 * This module reads and applies html fragments from/to dom nodes.
 *
 * @class tinymce.undo.Fragments
 * @private
 */
 const getOuterHtml = (elm) => {
 if (isElement$7(elm)) {
 return elm.outerHTML;
 }
 else if (isText$b(elm)) {
 return Entities.encodeRaw(elm.data, false);
 }
 else if (isComment(elm)) {
 return '';
 }
 return '';
 };
 const createFragment = (html) => {
 let node;
 const container = document.createElement('div');
 const frag = document.createDocumentFragment();
 if (html) {
 container.innerHTML = html;
 }
 while ((node = container.firstChild)) {
 frag.appendChild(node);
 }
 return frag;
 };
 const insertAt = (elm, html, index) => {
 const fragment = createFragment(html);
 if (elm.hasChildNodes() && index < elm.childNodes.length) {
 const target = elm.childNodes[index];
 elm.insertBefore(fragment, target);
 }
 else {
 elm.appendChild(fragment);
 }
 };
 const removeAt = (elm, index) => {
 if (elm.hasChildNodes() && index < elm.childNodes.length) {
 const target = elm.childNodes[index];
 elm.removeChild(target);
 }
 };
 const applyDiff = (diff, elm) => {
 let index = 0;
 each$e(diff, (action) => {
 if (action[0] === KEEP) {
 index++;
 }
 else if (action[0] === INSERT) {
 insertAt(elm, action[1], index);
 index++;
 }
 else if (action[0] === DELETE) {
 removeAt(elm, index);
 }
 });
 };
 const read$2 = (elm, trimZwsp) => filter$5(map$3(from(elm.childNodes), trimZwsp ? compose(trim$2, getOuterHtml) : getOuterHtml), (item) => {
 return item.length > 0;
 });
 const write = (fragments, elm) => {
 const currentFragments = map$3(from(elm.childNodes), getOuterHtml);
 applyDiff(diff(currentFragments, fragments), elm);
 return elm;
 };

// We need to create a temporary document instead of using the global document since
    // innerHTML on a detached element will still make http requests to the images
    const lazyTempDocument = cached(() => document.implementation.createHTMLDocument('undo'));
    const shouldBeFragmented = (body) => body.querySelector(`iframe, ${ucVideoNodeName}`) !== null;
    const createFragmentedLevel = (fragments) => {
        return {
            type: 'fragmented',
            fragments,
            content: '',
            bookmark: null,
            beforeBookmark: null
        };
    };
    const createCompleteLevel = (content) => {
        return {
            type: 'complete',
            fragments: null,
            content,
            bookmark: null,
            beforeBookmark: null
        };
    };
    const createFromEditor = (editor) => {
        const tempAttrs = editor.serializer.getTempAttrs();
        const body = trim$1(editor.getBody(), tempAttrs);
        return shouldBeFragmented(body) ? createFragmentedLevel(read$2(body, true)) : createCompleteLevel(trim$2(body.innerHTML));
    };
    const applyToEditor = (editor, level, before) => {
        const bookmark = before ? level.beforeBookmark : level.bookmark;
        if (level.type === 'fragmented') {
            write(level.fragments, editor.getBody());
        }
        else {
            editor.setContent(level.content, {
                format: 'raw',
                // If we have a path bookmark, we need to check if the bookmark location was a fake caret.
                // If the bookmark was not a fake caret, then we need to ensure that setContent does not move the selection
                // as this can create a new fake caret - particularly if the first element in the body is contenteditable=false.
                // The creation of this new fake caret will cause our path offset to be off by one when restoring the original selection.
                no_selection: isNonNullable(bookmark) && isPathBookmark(bookmark) ? !bookmark.isFakeCaret : true
            });
        }
        if (bookmark) {
            editor.selection.moveToBookmark(bookmark);
            editor.selection.scrollIntoView();
        }
    };
    const getLevelContent = (level) => {
        return level.type === 'fragmented' ? level.fragments.join('') : level.content;
    };
    const getCleanLevelContent = (isReadonly, level) => {
        const elm = SugarElement.fromTag('body', lazyTempDocument());
        set$3(elm, getLevelContent(level));
        each$e(descendants(elm, '*[data-mce-bogus]'), unwrap);
        if (isReadonly) {
            each$e(descendants(elm, 'details[open]'), (element) => remove$9(element, 'open'));
        }
        return get$8(elm);
    };
    const hasEqualContent = (level1, level2) => getLevelContent(level1) === getLevelContent(level2);
    const hasEqualCleanedContent = (isReadonly, level1, level2) => getCleanLevelContent(isReadonly, level1) === getCleanLevelContent(isReadonly, level2);
    // Most of the time the contents is equal so it's faster to first check that using strings then fallback to a cleaned dom comparison
    const isEq$1 = (isReadonly, level1, level2) => {
        if (!level1 || !level2) {
            return false;
        }
        else if (hasEqualContent(level1, level2)) {
            return true;
        }
        else {
            return hasEqualCleanedContent(isReadonly, level1, level2);
        }
    };

const isUnlocked = (locks) => locks.get() === 0;

const getContent$1 = (editor, args = {}) => {
        const format = args.format ? args.format : 'html';
        return getSelectedContent(editor, format, args);
    };

/**
 * This class handles text and control selection it's an crossbrowser utility class.
 * Consult the TinyMCE API Documentation for more details and examples on how to use this class.
 *
 * @class tinymce.dom.Selection
 * @example
 * // Getting the currently selected node for the active editor
 * alert(tinymce.activeEditor.selection.getNode().nodeName);
 */
 const isAttachedToDom = (node) => {
 return !!(node && node.ownerDocument) && contains(SugarElement.fromDom(node.ownerDocument), SugarElement.fromDom(node));
 };
 const isValidRange = (rng) => {
 if (!rng) {
 return false;
 }
 else {
 return isAttachedToDom(rng.startContainer) && isAttachedToDom(rng.endContainer);
 }
 };
 /**
 * Constructs a new selection instance.
 *
 * @constructor
 * @method Selection
 * @param {tinymce.dom.DOMUtils} dom DOMUtils object reference.
 * @param {Window} win Window to bind the selection object to.
 * @param {tinymce.dom.Serializer} serializer DOM serialization class to use for getContent.
 * @param {tinymce.Editor} editor Editor instance of the selection.
 */
 const EditorSelection = (dom, win, serializer, editor) => {
 let selectedRange;
 let explicitRange;
 const { selectorChangedWithUnbind } = SelectorChanged(dom, editor);
 /**
 * Move the selection cursor range to the specified node and offset.
 * If there is no node specified it will move it to the first suitable location within the body.
 *
 * @method setCursorLocation
 * @param {Node} node Optional node to put the cursor in.
 * @param {Number} offset Optional offset from the start of the node to put the cursor at.
 */
 const setCursorLocation = (node, offset) => {
 const rng = dom.createRng();
 if (isNonNullable(node) && isNonNullable(offset)) {
 rng.setStart(node, offset);
 rng.setEnd(node, offset);
 setRng(rng);
 collapse(false);
 }
 else {
 moveEndPoint(dom, rng, editor.getBody(), true);
 setRng(rng);
 }
 };
 /**
 * Returns the selected contents using the DOM serializer passed in to this class.
 *
 * @method getContent
 * @param {Object} args Optional settings class with for example output format text or html.
 * @return {String} Selected contents in for example HTML format.
 * @example
 * // Alerts the currently selected contents
 * alert(tinymce.activeEditor.selection.getContent());
 *
 * // Alerts the currently selected contents as plain text
 * alert(tinymce.activeEditor.selection.getContent({ format: 'text' }));
 */
 const getContent = (args) => getContent$1(editor, args);
 /**
 * This method has been deprecated. Use "editor.insertContent" instead.
 *
 * Sets the current selection to the specified content. If any contents is selected it will be replaced
 * with the contents passed in to this function. If there is no selection the contents will be inserted
 * where the caret is placed in the editor/page.
 *
 * @method setContent
 * @param {String} content HTML contents to set could also be other formats depending on settings.
 * @param {Object} args Optional settings object with for example data format.
 * @example
 * // Inserts some HTML contents at the current selection
 * tinymce.activeEditor.selection.setContent('Some contents');
 */
 const setContent = (content, args) => setContentExternal(editor, content, args);
 /**
 * Returns the start element of a selection range. If the start is in a text
 * node the parent element will be returned.
 *
 * @method getStart
 * @param {Boolean} real Optional state to get the real parent when the selection is collapsed not the closest element.
 * @return {Element} Start element of selection range.
 */
 const getStart$1 = (real) => getStart(editor.getBody(), getRng$1(), real);
 /**
 * Returns the end element of a selection range. If the end is in a text
 * node the parent element will be returned.
 *
 * @method getEnd
 * @param {Boolean} real Optional state to get the real parent when the selection is collapsed not the closest element.
 * @return {Element} End element of selection range.
 */
 const getEnd$1 = (real) => getEnd(editor.getBody(), getRng$1(), real);
 /**
 * Returns a bookmark location for the current selection. This bookmark object
 * can then be used to restore the selection after some content modification to the document.
 *
 * @method getBookmark
 * @param {Number} type Optional state if the bookmark should be simple or not. Default is complex.
 * @param {Boolean} normalized Optional state that enables you to get a position that it would be after normalization.
 * @return {Object} Bookmark object, use moveToBookmark with this object to restore the selection.
 * @example
 * // Stores a bookmark of the current selection
 * const bm = tinymce.activeEditor.selection.getBookmark();
 *
 * tinymce.activeEditor.setContent(tinymce.activeEditor.getContent() + 'Some new content');
 *
 * // Restore the selection bookmark
 * tinymce.activeEditor.selection.moveToBookmark(bm);
 */
 const getBookmark = (type, normalized) => bookmarkManager.getBookmark(type, normalized);
 /**
 * Restores the selection to the specified bookmark.
 *
 * @method moveToBookmark
 * @param {Object} bookmark Bookmark to restore selection from.
 * @example
 * // Stores a bookmark of the current selection
 * const bm = tinymce.activeEditor.selection.getBookmark();
 *
 * tinymce.activeEditor.setContent(tinymce.activeEditor.getContent() + 'Some new content');
 *
 * // Restore the selection bookmark
 * tinymce.activeEditor.selection.moveToBookmark(bm);
 */
 const moveToBookmark = (bookmark) => bookmarkManager.moveToBookmark(bookmark);
 /**
 * Selects the specified element. This will place the start and end of the selection range around the element.
 *
 * @method select
 * @param {Element} node HTML DOM element to select.
 * @param {Boolean} content Optional bool state if the contents should be selected or not on non IE browser.
 * @return {Element} Selected element the same element as the one that got passed in.
 * @example
 * // Select the first paragraph in the active editor
 * tinymce.activeEditor.selection.select(tinymce.activeEditor.dom.select('p')[0]);
 */
 const select$1 = (node, content) => {
 select(dom, node, content).each(setRng);
 return node;
 };
 /**
 * Returns true/false if the selection range is collapsed or not. Collapsed means if it's a caret or a larger selection.
 *
 * @method isCollapsed
 * @return {Boolean} true/false state if the selection range is collapsed or not.
 * Collapsed means if it's a caret or a larger selection.
 */
 const isCollapsed = () => {
 const rng = getRng$1(), sel = getSel();
 if (!rng || rng.item) {
 return false;
 }
 if (rng.compareEndPoints) {
 return rng.compareEndPoints('StartToEnd', rng) === 0;
 }
 return !sel || rng.collapsed;
 };
 /**
 * Checks if the current selection’s start and end containers are editable within their parent’s contexts.
 *
 * @method isEditable
 * @return {Boolean} Will be true if the selection is editable and false if it's not editable.
 */
 const isEditable = () => {
 if (editor.mode.isReadOnly()) {
 return false;
 }
 const rng = getRng$1();
 const fakeSelectedElements = editor.getBody().querySelectorAll('[data-mce-selected="1"]');
 if (fakeSelectedElements.length > 0) {
 return forall(fakeSelectedElements, (el) => dom.isEditable(el.parentElement));
 }
 else {
 return isEditableRange(dom, rng);
 }
 };
 /**
 * Collapse the selection to start or end of range.
 *
 * @method collapse
 * @param {Boolean} toStart Optional boolean state if to collapse to end or not. Defaults to false.
 */
 const collapse = (toStart) => {
 const rng = getRng$1();
 rng.collapse(!!toStart);
 setRng(rng);
 };
 /**
 * Returns the browsers internal selection object.
 *
 * @method getSel
 * @return {Selection} Internal browser selection object.
 */
 const getSel = () => win.getSelection ? win.getSelection() : win.document.selection;
 /**
 * Returns the browsers internal range object.
 *
 * @method getRng
 * @return {Range} Internal browser range object.
 * @see http://www.quirksmode.org/dom/range_intro.html
 * @see http://www.dotvoid.com/2001/03/using-the-range-object-in-mozilla/
 */
 const getRng$1 = () => {
 let rng;
 const tryCompareBoundaryPoints = (how, sourceRange, destinationRange) => {
 try {
 return sourceRange.compareBoundaryPoints(how, destinationRange);
 }
 catch {
 // Gecko throws wrong document exception if the range points
 // to nodes that where removed from the dom #6690
 // Browsers should mutate existing DOMRange instances so that they always point
 // to something in the document this is not the case in Gecko works fine in IE/WebKit/Blink
 // For performance reasons just return -1
 return -1;
 }
 };
 const doc = win.document;
 if (isNonNullable(editor.bookmark) && !hasFocus(editor)) {
 const bookmark = getRng(editor);
 if (bookmark.isSome()) {
 return bookmark.map((r) => processRanges(editor, [r])[0]).getOr(doc.createRange());
 }
 }
 try {
 const selection = getSel();
 if (selection && !isRestrictedNode(selection.anchorNode)) {
 if (selection.rangeCount > 0) {
 rng = selection.getRangeAt(0);
 }
 else {
 rng = doc.createRange();
 }
 rng = processRanges(editor, [rng])[0];
 }
 }
 catch {
 // IE throws unspecified error here if TinyMCE is placed in a frame/iframe
 }
 // No range found then create an empty one
 // This can occur when the editor is placed in a hidden container element on Gecko
 if (!rng) {
 rng = doc.createRange();
 }
 // If range is at start of document then move it to start of body
 if (isDocument$1(rng.startContainer) && rng.collapsed) {
 const elm = dom.getRoot();
 rng.setStart(elm, 0);
 rng.setEnd(elm, 0);
 }
 if (selectedRange && explicitRange) {
 if (tryCompareBoundaryPoints(rng.START_TO_START, rng, selectedRange) === 0 &&
 tryCompareBoundaryPoints(rng.END_TO_END, rng, selectedRange) === 0) {
 // Safari, Opera and Chrome only ever select text which causes the range to change.
 // This lets us use the originally set range if the selection hasn't been changed by the user.
 rng = explicitRange;
 }
 else {
 selectedRange = null;
 explicitRange = null;
 }
 }
 return rng;
 };
 /**
 * Changes the selection to the specified DOM range.
 *
 * @method setRng
 * @param {Range} rng Range to select.
 * @param {Boolean} forward Optional boolean if the selection is forwards or backwards.
 */
 const setRng = (rng, forward) => {
 if (!isValidRange(rng)) {
 return;
 }
 const sel = getSel();
 const evt = editor.dispatch('SetSelectionRange', { range: rng, forward });
 rng = evt.range;
 if (sel) {
 explicitRange = rng;
 try {
 sel.removeAllRanges();
 sel.addRange(rng);
 }
 catch {
 // IE might throw errors here if the editor is within a hidden container and selection is changed
 }
 // Forward is set to false and we have an extend function
 if (forward === false && sel.extend) {
 sel.collapse(rng.endContainer, rng.endOffset);
 sel.extend(rng.startContainer, rng.startOffset);
 }
 // adding range isn't always successful so we need to check range count otherwise an exception can occur
 selectedRange = sel.rangeCount > 0 ? sel.getRangeAt(0) : null;
 }
 // WebKit edge case selecting images works better using setBaseAndExtent when the image is floated
 if (!rng.collapsed && rng.startContainer === rng.endContainer && sel?.setBaseAndExtent) {
 if (rng.endOffset - rng.startOffset < 2) {
 if (rng.startContainer.hasChildNodes()) {
 const node = rng.startContainer.childNodes[rng.startOffset];
 if (node && node.nodeName === 'IMG') {
 sel.setBaseAndExtent(rng.startContainer, rng.startOffset, rng.endContainer, rng.endOffset);
 // Since the setBaseAndExtent is fixed in more recent Blink versions we
 // need to detect if it's doing the wrong thing and falling back to the
 // crazy incorrect behavior api call since that seems to be the only way
 // to get it to work on Safari WebKit as of 2017-02-23
 if (sel.anchorNode !== rng.startContainer || sel.focusNode !== rng.endContainer) {
 sel.setBaseAndExtent(node, 0, node, 1);
 }
 }
 }
 }
 }
 editor.dispatch('AfterSetSelectionRange', { range: rng, forward });
 };
 /**
 * Sets the current selection to the specified DOM element.
 *
 * @method setNode
 * @param {Element} elm Element to set as the contents of the selection.
 * @return {Element} Returns the element that got passed in.
 * @example
 * // Inserts a DOM node at current selection/caret location
 * tinymce.activeEditor.selection.setNode(tinymce.activeEditor.dom.create('img', { src: 'some.gif', title: 'some title' }));
 */
 const setNode = (elm) => {
 setContentInternal$1(editor, dom.getOuterHTML(elm));
 return elm;
 };
 /**
 * Returns the currently selected element or the common ancestor element for both start and end of the selection.
 *
 * @method getNode
 * @return {Element} Currently selected element or common ancestor element.
 * @example
 * // Alerts the currently selected elements node name
 * alert(tinymce.activeEditor.selection.getNode().nodeName);
 */
 const getNode$1 = () => getNode(editor.getBody(), getRng$1());
 const getSelectedBlocks$1 = (startElm, endElm) => getSelectedBlocks(dom, getRng$1(), startElm, endElm);
 const isForward = () => {
 const sel = getSel();
 const anchorNode = sel?.anchorNode;
 const focusNode = sel?.focusNode;
 // No support for selection direction then always return true
 if (!sel || !anchorNode || !focusNode || isRestrictedNode(anchorNode) || isRestrictedNode(focusNode)) {
 return true;
 }
 const anchorRange = dom.createRng();
 const focusRange = dom.createRng();
 try {
 anchorRange.setStart(anchorNode, sel.anchorOffset);
 anchorRange.collapse(true);
 focusRange.setStart(focusNode, sel.focusOffset);
 focusRange.collapse(true);
 }
 catch {
 // Safari can generate an invalid selection and error. Silently handle it and default to forward.
 // See https://bugs.webkit.org/show_bug.cgi?id=230594.
 return true;
 }
 return anchorRange.compareBoundaryPoints(anchorRange.START_TO_START, focusRange) <= 0;
 };
 const normalize = () => {
 const rng = getRng$1();
 const sel = getSel();
 if (!hasMultipleRanges(sel) && hasAnyRanges(editor)) {
 const normRng = normalize$2(dom, rng);
 normRng.each((normRng) => {
 setRng(normRng, isForward());
 });
 return normRng.getOr(rng);
 }
 return rng;
 };
 /**
 * Executes callback when the current selection starts/stops matching the specified selector. The current
 * state will be passed to the callback as it's first argument.
 *
 * @method selectorChanged
 * @param {String} selector CSS selector to check for.
 * @param {Function} callback Callback with state and args when the selector is matches or not.
 */
 // eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
 const selectorChanged = (selector, callback) => {
 selectorChangedWithUnbind(selector, callback);
 return exports;
 };
 const getScrollContainer = () => {
 let scrollContainer;
 let node = dom.getRoot();
 while (node && node.nodeName !== 'BODY') {
 if (node.scrollHeight > node.clientHeight) {
 scrollContainer = node;
 break;
 }
 node = node.parentNode;
 }
 return scrollContainer;
 };
 const scrollIntoView = (elm, alignToTop) => {
 if (isNonNullable(elm)) {
 scrollElementIntoView(editor, elm, alignToTop);
 }
 else {
 scrollRangeIntoView(editor, getRng$1(), alignToTop);
 }
 };
 const placeCaretAt = (clientX, clientY) => setRng(fromPoint(clientX, clientY, editor.getDoc()));
 const getBoundingClientRect = () => {
 const rng = getRng$1();
 return rng.collapsed ? CaretPosition.fromRangeStart(rng).getClientRects()[0] : rng.getBoundingClientRect();
 };
 const destroy = () => {
 win = selectedRange = explicitRange = null;
 controlSelection.destroy();
 };
 /**
 * Expands the selection range to contain the entire word when the selection is collapsed within the word.
 *
 * @method expand
 * @param {Object} options Optional options provided to the expansion. Defaults to { type: 'word' }
 */
 const expand = (options = { type: 'word' }) => setRng(RangeUtils(dom).expand(getRng$1(), options));
 const exports = {
 dom,
 win,
 serializer,
 editor,
 expand,
 collapse,
 setCursorLocation,
 getContent,
 setContent,
 getBookmark,
 moveToBookmark,
 select: select$1,
 isCollapsed,
 isEditable,
 isForward,
 setNode,
 getNode: getNode$1,
 getSel,
 setRng,
 getRng: getRng$1,
 getStart: getStart$1,
 getEnd: getEnd$1,
 getSelectedBlocks: getSelectedBlocks$1,
 normalize,
 selectorChanged,
 selectorChangedWithUnbind,
 getScrollContainer,
 scrollIntoView,
 placeCaretAt,
 getBoundingClientRect,
 destroy
 };
 const bookmarkManager = BookmarkManager(exports);
 const controlSelection = ControlSelection(exports, editor);
 exports.bookmarkManager = bookmarkManager;
 exports.controlSelection = controlSelection;
 return exports;
 };

/**
 * This class is used to serialize DOM trees into a string. Consult the TinyMCE API Documentation for
 * more details and examples on how to use this class.
 *
 * @class tinymce.dom.Serializer
 */
 const DomSerializer = (settings, editor) => {
 const domSerializer = DomSerializerImpl(settings, editor);
 // Return public methods
 return {
 /**
 * Schema instance that was used to when the Serializer was constructed.
 *
 * @field {tinymce.html.Schema} schema
 */
 schema: domSerializer.schema,
 /**
 * Adds a node filter function to the parser used by the serializer, the parser will collect the specified nodes by name
 * and then execute the callback once it has finished parsing the document.
 *
 * @method addNodeFilter
 * @param {String} name Comma separated list of nodes to collect.
 * @param {Function} callback Callback function to execute once it has collected nodes.
 * @example
 * serializer.addNodeFilter('p,h1', (nodes, name) => {
 * for (let i = 0; i < nodes.length; i++) {
 * console.log(nodes[i].name);
 * }
 * });
 */
 addNodeFilter: domSerializer.addNodeFilter,
 /**
 * Adds an attribute filter function to the parser used by the serializer, the parser will
 * collect nodes that has the specified attributes
 * and then execute the callback once it has finished parsing the document.
 *
 * @method addAttributeFilter
 * @param {String} name Comma separated list of attributes to collect.
 * @param {Function} callback Callback function to execute once it has collected nodes.
 * @example
 * serializer.addAttributeFilter('src,href', (nodes, name) => {
 * for (let i = 0; i < nodes.length; i++) {
 * console.log(nodes[i].name);
 * }
 * });
 */
 addAttributeFilter: domSerializer.addAttributeFilter,
 /**
 * Serializes the specified browser DOM node into a HTML string.
 *
 * @method serialize
 * @param {DOMNode} node DOM node to serialize.
 * @param {Object} args Arguments option that gets passed to event handlers.
 */
 serialize: domSerializer.serialize,
 /**
 * Adds valid elements rules to the serializers schema instance this enables you to specify things
 * like what elements should be outputted and what attributes specific elements might have.
 * Consult the TinyMCE Documentation for more details on this format.
 *
 * @method addRules
 * @param {String} rules Valid elements rules string to add to schema.
 */
 addRules: domSerializer.addRules,
 /**
 * Sets the valid elements rules to the serializers schema instance this enables you to specify things
 * like what elements should be outputted and what attributes specific elements might have.
 * Consult the TinyMCE Documentation for more details on this format.
 *
 * @method setRules
 * @param {String} rules Valid elements rules string.
 */
 setRules: domSerializer.setRules,
 /**
 * Adds a temporary internal attribute these attributes will get removed on undo and
 * when getting contents out of the editor.
 *
 * @method addTempAttr
 * @param {String} name string
 */
 addTempAttr: domSerializer.addTempAttr,
 /**
 * Returns an array of all added temp attrs names.
 *
 * @method getTempAttrs
 * @return {String[]} Array with attribute names.
 */
 getTempAttrs: domSerializer.getTempAttrs,
 getNodeFilters: domSerializer.getNodeFilters,
 getAttributeFilters: domSerializer.getAttributeFilters,
 /**
 * Removes a node filter function or removes all filter functions from the parser used by the serializer for the node names provided.
 *
 * @method removeNodeFilter
 * @param {String} name Comma separated list of node names to remove filters for.
 * @param {Function} callback Optional callback function to only remove a specific callback.
 * @example
 * // Remove a single filter
 * serializer.removeNodeFilter('p,h1', someCallback);
 *
 * // Remove all filters
 * serializer.removeNodeFilter('p,h1');
 */
 removeNodeFilter: domSerializer.removeNodeFilter,
 /**
 * Removes an attribute filter function or removes all filter functions from the parser used by the serializer for the attribute names provided.
 *
 * @method removeAttributeFilter
 * @param {String} name Comma separated list of attribute names to remove filters for.
 * @param {Function} callback Optional callback function to only remove a specific callback.
 * @example
 * // Remove a single filter
 * serializer.removeAttributeFilter('src,href', someCallback);
 *
 * // Remove all filters
 * serializer.removeAttributeFilter('src,href');
 */
 removeAttributeFilter: domSerializer.removeAttributeFilter
 };
 };

const ModelManager = AddOnManager.ModelManager;

/**
 * This class handles the creation of TinyMCE's notifications.
 *
 * @class tinymce.NotificationManager
 * @example
 * // Opens a new notification of type "error" with text "An error occurred."
 * tinymce.activeEditor.notificationManager.open({
 * text: 'An error occurred.',
 * type: 'error'
 * });
 */
 const NotificationManager = (editor) => {
 const notifications = [];
 const getImplementation = () => {
 const theme = editor.theme;
 return theme && theme.getNotificationManagerImpl ? theme.getNotificationManagerImpl() : NotificationManagerImpl();
 };
 const getTopNotification = () => {
 return Optional.from(notifications[0]);
 };
 const isEqual = (a, b) => {
 return a.type === b.type && a.text === b.text && !a.progressBar && !a.timeout && !b.progressBar && !b.timeout;
 };
 const reposition = () => {
 getTopNotification().each((notification) => {
 notification.reposition();
 });
 };
 const addNotification = (notification) => {
 notifications.push(notification);
 };
 const closeNotification = (notification) => {
 findIndex$2(notifications, (otherNotification) => {
 return otherNotification === notification;
 }).each((index) => {
 // Mutate here since third party might have stored away the window array
 // TODO: Consider breaking this api
 notifications.splice(index, 1);
 });
 };
 const open = (spec, fireEvent = true) => {
 // Never open notification if editor has been removed.
 if (editor.removed || !isEditorAttachedToDom(editor)) {
 return {};
 }
 // fire event to allow notification spec to be mutated before display
 if (fireEvent) {
 editor.dispatch('BeforeOpenNotification', { notification: spec });
 }
 return find$2(notifications, (notification) => {
 return isEqual(getImplementation().getArgs(notification), spec);
 }).getOrThunk(() => {
 editor.editorManager.setActive(editor);
 const notification = getImplementation().open(spec, () => {
 closeNotification(notification);
 }, () => hasEditorOrUiFocus(editor));
 addNotification(notification);
 reposition();
 // Ensure notification is not passed by reference to prevent mutation
 editor.dispatch('OpenNotification', { notification: { ...notification } });
 return notification;
 });
 };
 const close = () => {
 getTopNotification().each((notification) => {
 getImplementation().close(notification);
 closeNotification(notification);
 reposition();
 });
 };
 const getNotifications = constant(notifications);
 const registerEvents = (editor) => {
 editor.on('SkinLoaded', () => {
 const serviceMessage = getServiceMessage(editor);
 if (serviceMessage) {
 // Ensure we pass false for fireEvent so that service message cannot be altered.
 open({
 text: serviceMessage,
 type: 'warning',
 timeout: 0
 }, false);
 }
 // Ensure the notifications are repositioned once the skin has loaded, as otherwise
 // any notifications rendered before then may have wrapped and been in the wrong place
 reposition();
 });
 // NodeChange is needed for inline mode and autoresize as the positioning is done
 // from the bottom up, which changes when the content in the editor changes.
 editor.on('show ResizeEditor ResizeWindow NodeChange ToggleView FullscreenStateChanged', () => {
 requestAnimationFrame(reposition);
 });
 editor.on('remove', () => {
 each$e(notifications.slice(), (notification) => {
 getImplementation().close(notification);
 });
 });
 editor.on('keydown', (e) => {
 // TODO: TINY-11429 Remove this once we remove the use of keycodes
 const isF12 = e.key?.toLowerCase() === 'f12' || e.keyCode === 123;
 if (e.altKey && isF12) {
 e.preventDefault();
 getTopNotification()
 .map((notificationApi) => SugarElement.fromDom(notificationApi.getEl()))
 .each((elm) => focus$1(elm));
 }
 });
 };
 registerEvents(editor);
 return {
 /**
 * Opens a new notification.
 *
 * @method open
 * @param {Object} args A <code>name: value</code> collection containing settings such as: <code>timeout</code>, <code>type</code>, and message (<code>text</code>).
 * 
 * For information on the available settings, see: <a href="https://www.tiny.cloud/docs/tinymce/8/creating-custom-notifications/">Create custom notifications</a>.
 */
 open,
 /**
 * Closes the top most notification.
 *
 * @method close
 */
 close,
 /**
 * Returns the currently opened notification objects.
 *
 * @method getNotifications
 * @return {Array} Array of the currently opened notifications.
 */
 getNotifications
 };
 };

const PluginManager = AddOnManager.PluginManager;

const ThemeManager = AddOnManager.ThemeManager;

// Map to track which editors have already been processed and disabled
    const processedEditors = new WeakMap();
    const forceDisable = (editor) => {
        // Check if we've already disabled the editor
        if (processedEditors.has(editor)) {
            return;
        }
        // Mark this editor as processed
        processedEditors.set(editor, true);
        const switchModeListener = () => {
            editor.on('SwitchMode', (e) => {
                const { mode } = e;
                if (mode !== 'readonly') {
                    editor.mode.set('readonly');
                }
            });
        };
        const disabledStateChangeListener = () => {
            editor.on('DisabledStateChange', (e) => {
                const { state } = e;
                if (!state) {
                    e.preventDefault();
                }
            }, true);
        };
        if (editor.initialized) {
            // Set readonly before setting disabled as disabling editor prevents mode from being changed
            if (!editor.removed) {
                editor.mode.set('readonly');
            }
            editor.options.set('disabled', true);
        }
        else {
            editor.on('init', () => {
                // Set readonly before setting disabled as disabling editor prevents mode from being changed
                if (!editor.removed) {
                    editor.mode.set('readonly');
                }
                editor.options.set('disabled', true);
            });
        }
        disabledStateChangeListener();
        switchModeListener();
    };

/* eslint-disable no-console */
    const displayNotification = (editor, messageData) => {
        const { type, message } = messageData;
        editor.notificationManager.open({
            type,
            text: message
        });
    };
    const getConsoleFn = (type) => {
        switch (type) {
            case 'error':
                return console.error;
            case 'info':
                return console.info;
            case 'warn':
                return console.warn;
            case 'log':
            default:
                return console.log;
        }
    };
    const displayConsoleMessage = (messageData) => {
        const consoleFn = getConsoleFn(messageData.type);
        consoleFn(messageData.message);
    };
    const reportMessage = (editor, message) => {
        const { console, editor: editorUi } = message;
        if (isNonNullable(editorUi)) {
            if (editor._skinLoaded) {
                displayNotification(editor, editorUi);
            }
            else {
                editor.on('SkinLoaded', () => {
                    displayNotification(editor, editorUi);
                });
            }
        }
        if (isNonNullable(console)) {
            displayConsoleMessage(console);
        }
    };

/**
     * Finds images with data uris or blob uris. If data uris are found it will convert them into blob uris.
     *
     * @private
     * @class tinymce.file.ImageScanner
     */
    const getAllImages = (elm) => {
        return elm ? from(elm.getElementsByTagName('img')) : [];
    };
    const ImageScanner = (uploadStatus, blobCache) => {
        const cachedPromises = {};
        const findAll = (elm, predicate = always) => {
            const images = filter$5(getAllImages(elm), (img) => {
                const src = img.src;
                if (img.hasAttribute('data-mce-bogus')) {
                    return false;
                }
                if (img.hasAttribute('data-mce-placeholder')) {
                    return false;
                }
                if (!src || src === Env.transparentSrc) {
                    return false;
                }
                if (startsWith(src, 'blob:')) {
                    return !uploadStatus.isUploaded(src) && predicate(img);
                }
                if (startsWith(src, 'data:')) {
                    return predicate(img);
                }
                return false;
            });
            const promises = map$3(images, (img) => {
                const imageSrc = img.src;
                if (has$2(cachedPromises, imageSrc)) {
                    // Since the cached promise will return the cached image
                    // We need to wrap it and resolve with the actual image
                    return cachedPromises[imageSrc].then((imageInfo) => {
                        if (isString(imageInfo)) { // error apparently
                            return imageInfo;
                        }
                        else {
                            return {
                                image: img,
                                blobInfo: imageInfo.blobInfo
                            };
                        }
                    });
                }
                else {
                    const newPromise = imageToBlobInfo(blobCache, imageSrc)
                        .then((blobInfo) => {
                        delete cachedPromises[imageSrc];
                        return { image: img, blobInfo };
                    }).catch((error) => {
                        delete cachedPromises[imageSrc];
                        return error;
                    });
                    cachedPromises[imageSrc] = newPromise;
                    return newPromise;
                }
            });
            return Promise.all(promises);
        };
        return {
            findAll
        };
    };

/**
     * Holds the current status of a blob uri, if it's pending or uploaded and what the result urls was.
     *
     * @private
     * @class tinymce.file.UploadStatus
     */
    const UploadStatus = () => {
        const PENDING = 1, UPLOADED = 2;
        let blobUriStatuses = {};
        const createStatus = (status, resultUri) => {
            return {
                status,
                resultUri
            };
        };
        const hasBlobUri = (blobUri) => {
            return blobUri in blobUriStatuses;
        };
        const getResultUri = (blobUri) => {
            const result = blobUriStatuses[blobUri];
            return result ? result.resultUri : null;
        };
        const isPending = (blobUri) => {
            return hasBlobUri(blobUri) ? blobUriStatuses[blobUri].status === PENDING : false;
        };
        const isUploaded = (blobUri) => {
            return hasBlobUri(blobUri) ? blobUriStatuses[blobUri].status === UPLOADED : false;
        };
        const markPending = (blobUri) => {
            blobUriStatuses[blobUri] = createStatus(PENDING, null);
        };
        const markUploaded = (blobUri, resultUri) => {
            blobUriStatuses[blobUri] = createStatus(UPLOADED, resultUri);
        };
        const removeFailed = (blobUri) => {
            delete blobUriStatuses[blobUri];
        };
        const destroy = () => {
            blobUriStatuses = {};
        };
        return {
            hasBlobUri,
            getResultUri,
            isPending,
            isUploaded,
            markPending,
            markUploaded,
            removeFailed,
            destroy
        };
    };

/**
     * Generates unique ids.
     *
     * @class tinymce.util.Uuid
     * @private
     */
    let count = 0;
    const seed = () => {
        const rnd = () => {
            return Math.round(random() * 0xFFFFFFFF).toString(36);
        };
        const now = new Date().getTime();
        return 's' + now.toString(36) + rnd() + rnd() + rnd();
    };
    const uuid = (prefix) => {
        return prefix + (count++) + seed();
    };

const setup$x = (editor) => {
 // Add some inline shortcuts
 editor.addShortcut('meta+b', '', 'Bold');
 editor.addShortcut('meta+i', '', 'Italic');
 editor.addShortcut('meta+u', '', 'Underline');
 // BlockFormat shortcuts keys
 for (let i = 1; i <= 6; i++) {
 editor.addShortcut('access+' + i, '', ['FormatBlock', false, 'h' + i]);
 }
 editor.addShortcut('access+7', '', ['FormatBlock', false, 'p']);
 editor.addShortcut('access+8', '', ['FormatBlock', false, 'div']);
 editor.addShortcut('access+9', '', ['FormatBlock', false, 'address']);
 };

// Avoid adding non-typing undo levels for commands that could cause duplicate undo levels to be created
 // or do not alter the editor content or selection in any way
 const shouldIgnoreCommand = (cmd) => {
 switch (cmd.toLowerCase()) {
 case 'undo':
 case 'redo':
 case 'mcefocus':
 return true;
 default:
 return false;
 }
 };
 const registerEvents = (editor, undoManager, locks) => {
 const isFirstTypedCharacter = Cell(false);
 const addNonTypingUndoLevel = (e) => {
 setTyping(undoManager, false, locks);
 undoManager.add({}, e);
 };
 // Add initial undo level when the editor is initialized
 editor.on('init', () => {
 undoManager.add();
 });
 // Get position before an execCommand is processed
 editor.on('BeforeExecCommand', (e) => {
 const cmd = e.command;
 if (!shouldIgnoreCommand(cmd)) {
 endTyping(undoManager, locks);
 undoManager.beforeChange();
 }
 });
 // Add undo level after an execCommand call was made
 editor.on('ExecCommand', (e) => {
 const cmd = e.command;
 if (!shouldIgnoreCommand(cmd)) {
 addNonTypingUndoLevel(e);
 }
 });
 editor.on('ObjectResizeStart cut', () => {
 undoManager.beforeChange();
 });
 editor.on('SaveContent ObjectResized blur', addNonTypingUndoLevel);
 editor.on('dragend', addNonTypingUndoLevel);
 editor.on('keyup', (e) => {
 const keyCode = e.keyCode;
 // If key is prevented then don't add undo level
 // This would happen on keyboard shortcuts for example
 if (e.isDefaultPrevented()) {
 return;
 }
 const isMeta = Env.os.isMacOS() && e.key === 'Meta';
 if ((keyCode >= 33 && keyCode <= 36) || (keyCode >= 37 && keyCode <= 40) || keyCode === 45 || e.ctrlKey || isMeta) {
 addNonTypingUndoLevel();
 editor.nodeChanged();
 }
 if (keyCode === 46 || keyCode === 8) {
 editor.nodeChanged();
 }
 // Fire a TypingUndo event on the first character entered
 if (isFirstTypedCharacter.get() && undoManager.typing && !isEq$1(editor.readonly, createFromEditor(editor), undoManager.data[0])) {
 if (!editor.isDirty()) {
 editor.setDirty(true);
 }
 editor.dispatch('TypingUndo');
 isFirstTypedCharacter.set(false);
 editor.nodeChanged();
 }
 });
 editor.on('keydown', (e) => {
 const keyCode = e.keyCode;
 // If key is prevented then don't add undo level
 // This would happen on keyboard shortcuts for example
 if (e.isDefaultPrevented()) {
 return;
 }
 // Is character position keys left,right,up,down,home,end,pgdown,pgup,enter
 if ((keyCode >= 33 && keyCode <= 36) || (keyCode >= 37 && keyCode <= 40) || keyCode === 45) {
 if (undoManager.typing) {
 addNonTypingUndoLevel(e);
 }
 return;
 }
 // If key isn't Ctrl+Alt/AltGr
 const modKey = (e.ctrlKey && !e.altKey) || e.metaKey;
 if ((keyCode < 16 || keyCode > 20) && keyCode !== 224 && keyCode !== 91 && !undoManager.typing && !modKey) {
 undoManager.beforeChange();
 setTyping(undoManager, true, locks);
 undoManager.add({}, e);
 isFirstTypedCharacter.set(true);
 return;
 }
 const hasOnlyMetaOrCtrlModifier = Env.os.isMacOS() ? e.metaKey : e.ctrlKey && !e.altKey;
 if (hasOnlyMetaOrCtrlModifier) {
 undoManager.beforeChange();
 }
 });
 editor.on('mousedown', (e) => {
 if (undoManager.typing) {
 addNonTypingUndoLevel(e);
 }
 });
 // Special inputType, currently only Chrome implements this: https://www.w3.org/TR/input-events-2/#x5.1.2-attributes
 const isInsertReplacementText = (event) => event.inputType === 'insertReplacementText';
 // Safari just shows inputType `insertText` but with data set to null so we can use that
 const isInsertTextDataNull = (event) => event.inputType === 'insertText' && event.data === null;
 const isInsertFromPasteOrDrop = (event) => event.inputType === 'insertFromPaste' || event.inputType === 'insertFromDrop';
 // For detecting when user has replaced text using the browser built-in spell checker or paste/drop events
 editor.on('input', (e) => {
 if (e.inputType && (isInsertReplacementText(e) || isInsertTextDataNull(e) || isInsertFromPasteOrDrop(e))) {
 addNonTypingUndoLevel(e);
 }
 });
 editor.on('AddUndo Undo Redo ClearUndos', (e) => {
 if (!e.isDefaultPrevented()) {
 editor.nodeChanged();
 }
 });
 };
 const addKeyboardShortcuts = (editor) => {
 editor.addShortcut('meta+z', '', 'Undo');
 editor.addShortcut('meta+y,meta+shift+z', '', 'Redo');
 };

/**
     * This class handles the undo/redo history levels for the editor. Since the built-in undo/redo has major drawbacks a custom one was needed.
     *
     * @class tinymce.UndoManager
     */
    const UndoManager = (editor) => {
        const beforeBookmark = value$1();
        const locks = Cell(0);
        const index = Cell(0);
        /* eslint consistent-this:0 */
        const undoManager = {
            data: [], // Gets mutated both internally and externally by plugins like remark, not documented
            /**
             * State if the user is currently typing or not. This will add a typing operation into one undo
             * level instead of one new level for each keystroke.
             *
             * @field {Boolean} typing
             */
            typing: false,
            /**
             * Stores away a bookmark to be used when performing an undo action so that the selection is before
             * the change has been made.
             *
             * @method beforeChange
             */
            beforeChange: () => {
                beforeChange(editor, locks, beforeBookmark);
            },
            /**
             * Adds a new undo level/snapshot to the undo list.
             *
             * @method add
             * @param {Object} level Optional undo level object to add.
             * @param {EditorEvent} event Optional event responsible for the creation of the undo level.
             * @return {Object} Undo level that got added or null if a level wasn't needed.
             */
            add: (level, event) => {
                return addUndoLevel(editor, undoManager, index, locks, beforeBookmark, level, event);
            },
            /**
             * Dispatch a change event with current editor status as level and current undoManager layer as lastLevel
             *
             * @method dispatchChange
             */
            dispatchChange: () => {
                editor.setDirty(true);
                const level = createFromEditor(editor);
                level.bookmark = getUndoBookmark(editor.selection);
                editor.dispatch('change', {
                    level,
                    lastLevel: get$b(undoManager.data, index.get()).getOrUndefined()
                });
            },
            /**
             * Undoes the last action.
             *
             * @method undo
             * @return {Object} Undo level or null if no undo was performed.
             */
            undo: () => {
                return undo(editor, undoManager, locks, index);
            },
            /**
             * Redoes the last action.
             *
             * @method redo
             * @return {Object} Redo level or null if no redo was performed.
             */
            redo: () => {
                return redo(editor, index, undoManager.data);
            },
            /**
             * Removes all undo levels.
             *
             * @method clear
             */
            clear: () => {
                clear(editor, undoManager, index);
            },
            /**
             * Resets the undo manager levels by clearing all levels and then adding an initial level.
             *
             * @method reset
             */
            reset: () => {
                reset(editor, undoManager);
            },
            /**
             * Returns true/false if the undo manager has any undo levels.
             *
             * @method hasUndo
             * @return {Boolean} true/false if the undo manager has any undo levels.
             */
            hasUndo: () => {
                return hasUndo(editor, undoManager, index);
            },
            /**
             * Returns true/false if the undo manager has any redo levels.
             *
             * @method hasRedo
             * @return {Boolean} true/false if the undo manager has any redo levels.
             */
            hasRedo: () => {
                return hasRedo(editor, undoManager, index);
            },
            /**
             * Executes the specified mutator function as an undo transaction. The selection
             * before the modification will be stored to the undo stack and if the DOM changes
             * it will add a new undo level. Any logic within the translation that adds undo levels will
             * be ignored. So a translation can include calls to execCommand or editor.insertContent.
             *
             * @method transact
             * @param {Function} callback Function that gets executed and has dom manipulation logic in it.
             * @return {Object} Undo level that got added or null it a level wasn't needed.
             */
            transact: (callback) => {
                return transact(editor, undoManager, locks, callback);
            },
            /**
             * Executes the specified mutator function as an undo transaction. But without adding an undo level.
             * Any logic within the translation that adds undo levels will be ignored. So a translation can
             * include calls to execCommand or editor.insertContent.
             *
             * @method ignore
             * @param {Function} callback Function that gets executed and has dom manipulation logic in it.
             */
            ignore: (callback) => {
                ignore(editor, locks, callback);
            },
            /**
             * Adds an extra "hidden" undo level by first applying the first mutation and store that to the undo stack
             * then roll back that change and do the second mutation on top of the stack. This will produce an extra
             * undo level that the user doesn't see until they undo.
             *
             * @method extra
             * @param {Function} callback1 Function that does mutation but gets stored as a "hidden" extra undo level.
             * @param {Function} callback2 Function that does mutation but gets displayed to the user.
             */
            extra: (callback1, callback2) => {
                extra(editor, undoManager, index, callback1, callback2);
            }
        };
        if (!isRtc(editor)) {
            registerEvents(editor, undoManager, locks);
        }
        addKeyboardShortcuts(editor);
        return undoManager;
    };

const isCustomList = (list) => /\btox\-/.test(list.className);
    // Advlist/core/ListUtils.ts - Duplicated in Advlist plugin
    const isWithinNonEditable = (editor, element) => element !== null && !editor.dom.isEditable(element);
    const selectionIsWithinNonEditableList = (editor) => {
        const parentList = getParentList(editor);
        return isWithinNonEditable(editor, parentList) || !editor.selection.isEditable();
    };
    const isWithinNonEditableList$1 = (editor, element) => {
        const parentList = editor.dom.getParent(element, 'ol,ul,dl');
        return isWithinNonEditable(editor, parentList) || !editor.selection.isEditable();
    };

const fireListEvent = (editor, action, element) => editor.dispatch('ListMutation', { action, element });

const isList = (el) => is$1(el, 'OL,UL');
    const isListItem$1 = (el) => is$1(el, 'LI');
    const hasFirstChildList = (el) => firstChild(el).exists(isList);
    const hasLastChildList = (el) => lastChild(el).exists(isList);
    const canIncreaseDepthOfList = (editor, amount) => {
        return getListMaxDepth(editor).map((max) => max >= amount).getOr(true);
    };

const isEntryList = (entry) => 'listAttributes' in entry;
    const isEntryComment = (entry) => 'isComment' in entry;
    const isEntryFragment = (entry) => 'isFragment' in entry;
    const isIndented = (entry) => entry.depth > 0;
    const isSelected = (entry) => entry.isSelected;
    const cloneItemContent = (li) => {
        const children = children$1(li);
        const content = hasLastChildList(li) ? children.slice(0, -1) : children;
        return map$3(content, deep);
    };
    const createEntry = (li, depth, isSelected) => parent(li).filter(isElement$8).map((list) => ({
        depth,
        dirty: false,
        isSelected,
        content: cloneItemContent(li),
        itemAttributes: clone$4(li),
        listAttributes: clone$4(list),
        listType: name(list),
        isInPreviousLi: false
    }));

const selectionIndentation = (editor, indentation) => {
        const lists = fromDom$1(getSelectedListRoots(editor));
        const dlItems = fromDom$1(getSelectedDlItems(editor));
        let isHandled = false;
        if (lists.length || dlItems.length) {
            const bookmark = editor.selection.getBookmark();
            listIndentation(editor, lists, indentation);
            dlIndentation(editor, indentation, dlItems);
            editor.selection.moveToBookmark(bookmark);
            editor.selection.setRng(normalizeRange(editor.selection.getRng()));
            editor.nodeChanged();
            isHandled = true;
        }
        return isHandled;
    };
    const handleIndentation = (editor, indentation) => !selectionIsWithinNonEditableList(editor) && selectionIndentation(editor, indentation);
    const indentListSelection = (editor) => handleIndentation(editor, "Indent" /* Indentation.Indent */);
    const outdentListSelection = (editor) => handleIndentation(editor, "Outdent" /* Indentation.Outdent */);
    const flattenListSelection = (editor) => handleIndentation(editor, "Flatten" /* Indentation.Flatten */);

const listToggleActionFromListName = (listName) => {
        switch (listName) {
            case 'UL': return "ToggleUlList" /* ListAction.ToggleUlList */;
            case 'OL': return "ToggleOlList" /* ListAction.ToggleOlList */;
            case 'DL': return "ToggleDLList" /* ListAction.ToggleDLList */;
        }
    };

const getEdgeCefPosition = (editor, atStart) => {
        const root = editor.getBody();
        return atStart ? firstPositionIn(root).filter(isBeforeContentEditableFalse) :
            lastPositionIn(root).filter(isAfterContentEditableFalse);
    };
    const isCefAtEdgeSelected = (editor) => {
        const rng = editor.selection.getRng();
        return !rng.collapsed
            && (getEdgeCefPosition(editor, true).exists((pos) => pos.isEqual(CaretPosition.fromRangeStart(rng)))
                || getEdgeCefPosition(editor, false).exists((pos) => pos.isEqual(CaretPosition.fromRangeEnd(rng))));
    };

const deleteCaret$2 = (editor, forward) => {
        const fromPos = CaretPosition.fromRangeStart(editor.selection.getRng());
        return fromPosition(forward, editor.getBody(), fromPos)
            .filter((pos) => forward ? isBeforeImageBlock(pos) : isAfterImageBlock(pos))
            .bind((pos) => getChildNodeAtRelativeOffset(forward ? 0 : -1, pos))
            .map((elm) => () => editor.selection.select(elm));
    };
    const backspaceDelete$6 = (editor, forward) => editor.selection.isCollapsed() ? deleteCaret$2(editor, forward) : Optional.none();

const evaluateUntil = (fns, args) => {
 for (let i = 0; i < fns.length; i++) {
 const result = fns[i].apply(null, args);
 if (result.isSome()) {
 return result;
 }
 }
 return Optional.none();
 };

var BreakType;
 (function (BreakType) {
 BreakType[BreakType["Br"] = 0] = "Br";
 BreakType[BreakType["Block"] = 1] = "Block";
 BreakType[BreakType["Wrap"] = 2] = "Wrap";
 BreakType[BreakType["Eol"] = 3] = "Eol";
 })(BreakType || (BreakType = {}));
 const flip = (direction, positions) => direction === -1 /* HDirection.Backwards */ ? reverse(positions) : positions;
 const walk$1 = (direction, caretWalker, pos) => direction === 1 /* HDirection.Forwards */ ? caretWalker.next(pos) : caretWalker.prev(pos);
 const getBreakType = (scope, direction, currentPos, nextPos) => {
 if (isBr$7(nextPos.getNode(direction === 1 /* HDirection.Forwards */))) {
 return BreakType.Br;
 }
 else if (isInSameBlock(currentPos, nextPos) === false) {
 return BreakType.Block;
 }
 else {
 return BreakType.Wrap;
 }
 };
 const getPositionsUntil = (predicate, direction, scope, start) => {
 const caretWalker = CaretWalker(scope);
 let currentPos = start;
 const positions = [];
 while (currentPos) {
 const nextPos = walk$1(direction, caretWalker, currentPos);
 if (!nextPos) {
 break;
 }
 if (isBr$7(nextPos.getNode(false))) {
 if (direction === 1 /* HDirection.Forwards */) {
 return { positions: flip(direction, positions).concat([nextPos]), breakType: BreakType.Br, breakAt: Optional.some(nextPos) };
 }
 else {
 return { positions: flip(direction, positions), breakType: BreakType.Br, breakAt: Optional.some(nextPos) };
 }
 }
 if (!nextPos.isVisible()) {
 currentPos = nextPos;
 continue;
 }
 if (predicate(currentPos, nextPos)) {
 const breakType = getBreakType(scope, direction, currentPos, nextPos);
 return { positions: flip(direction, positions), breakType, breakAt: Optional.some(nextPos) };
 }
 positions.push(nextPos);
 currentPos = nextPos;
 }
 return { positions: flip(direction, positions), breakType: BreakType.Eol, breakAt: Optional.none() };
 };
 const getAdjacentLinePositions = (direction, getPositionsUntilBreak, scope, start) => getPositionsUntilBreak(scope, start).breakAt.map((pos) => {
 const positions = getPositionsUntilBreak(scope, pos).positions;
 return direction === -1 /* HDirection.Backwards */ ? positions.concat(pos) : [pos].concat(positions);
 }).getOr([]);
 const findClosestHorizontalPositionFromPoint = (positions, x) => foldl(positions, (acc, newPos) => acc.fold(() => Optional.some(newPos), (lastPos) => lift2(head(lastPos.getClientRects()), head(newPos.getClientRects()), (lastRect, newRect) => {
 const lastDist = Math.abs(x - lastRect.left);
 const newDist = Math.abs(x - newRect.left);
 return newDist <= lastDist ? newPos : lastPos;
 }).or(acc)), Optional.none());
 const findClosestHorizontalPosition = (positions, pos) => head(pos.getClientRects()).bind((targetRect) => findClosestHorizontalPositionFromPoint(positions, targetRect.left));
 const getPositionsUntilPreviousLine = curry(getPositionsUntil, CaretPosition.isAbove, -1);
 const getPositionsUntilNextLine = curry(getPositionsUntil, CaretPosition.isBelow, 1);
 const getPositionsAbove = curry(getAdjacentLinePositions, -1, getPositionsUntilPreviousLine);
 const getPositionsBelow = curry(getAdjacentLinePositions, 1, getPositionsUntilNextLine);
 const isAtFirstLine = (scope, pos) => getPositionsUntilPreviousLine(scope, pos).breakAt.isNone();
 const isAtLastLine = (scope, pos) => getPositionsUntilNextLine(scope, pos).breakAt.isNone();
 const getFirstLinePositions = (scope) => firstPositionIn(scope).map((pos) => [pos].concat(getPositionsUntilNextLine(scope, pos).positions)).getOr([]);
 const getLastLinePositions = (scope) => lastPositionIn(scope).map((pos) => getPositionsUntilPreviousLine(scope, pos).positions.concat(pos)).getOr([]);
 const getClosestPositionAbove = (scope, pos) => findClosestHorizontalPosition(getPositionsAbove(scope, pos), pos);
 const getClosestPositionBelow = (scope, pos) => findClosestHorizontalPosition(getPositionsBelow(scope, pos), pos);

var VDirection;
 (function (VDirection) {
 VDirection[VDirection["Up"] = -1] = "Up";
 VDirection[VDirection["Down"] = 1] = "Down";
 })(VDirection || (VDirection = {}));
 const findUntil = (direction, root, predicateFn, node) => {
 let currentNode = node;
 while ((currentNode = findNode(currentNode, direction, isEditableCaretCandidate$1, root))) {
 if (predicateFn(currentNode)) {
 return;
 }
 }
 };
 const walkUntil = (direction, isAboveFn, isBeflowFn, root, predicateFn, caretPosition) => {
 let line = 0;
 const result = [];
 const add = (node) => {
 let clientRects = getClientRects([node]);
 if (direction === VDirection.Up) {
 clientRects = clientRects.reverse();
 }
 for (let i = 0; i < clientRects.length; i++) {
 const clientRect = clientRects[i];
 if (isBeflowFn(clientRect, targetClientRect)) {
 continue;
 }
 if (result.length > 0 && isAboveFn(clientRect, last(result))) {
 line++;
 }
 clientRect.line = line;
 if (predicateFn(clientRect)) {
 return true;
 }
 result.push(clientRect);
 }
 return false;
 };
 const targetClientRect = last(caretPosition.getClientRects());
 if (!targetClientRect) {
 return result;
 }
 const node = caretPosition.getNode();
 if (node) {
 add(node);
 findUntil(direction, root, add, node);
 }
 return result;
 };
 const aboveLineNumber = (lineNumber, clientRect) => clientRect.line > lineNumber;
 const isLineNumber = (lineNumber, clientRect) => clientRect.line === lineNumber;
 const upUntil = curry(walkUntil, VDirection.Up, isAbove$1, isBelow$1);
 const downUntil = curry(walkUntil, VDirection.Down, isBelow$1, isAbove$1);
 const getLastClientRect = (caretPosition) => {
 // ASSUMPTION: There should always be at least one client rect here
 return last(caretPosition.getClientRects());
 };
 const positionsUntil = (direction, root, predicateFn, node) => {
 const caretWalker = CaretWalker(root);
 let walkFn;
 let isBelowFn;
 let isAboveFn;
 let caretPosition;
 const result = [];
 let line = 0;
 if (direction === VDirection.Down) {
 walkFn = caretWalker.next;
 isBelowFn = isBelow$1;
 isAboveFn = isAbove$1;
 caretPosition = CaretPosition.after(node);
 }
 else {
 walkFn = caretWalker.prev;
 isBelowFn = isAbove$1;
 isAboveFn = isBelow$1;
 caretPosition = CaretPosition.before(node);
 }
 const targetClientRect = getLastClientRect(caretPosition);
 do {
 if (!caretPosition.isVisible()) {
 continue;
 }
 const rect = getLastClientRect(caretPosition);
 if (isAboveFn(rect, targetClientRect)) {
 continue;
 }
 if (result.length > 0 && isBelowFn(rect, last(result))) {
 line++;
 }
 const clientRect = clone$1(rect);
 clientRect.position = caretPosition;
 clientRect.line = line;
 if (predicateFn(clientRect)) {
 return result;
 }
 result.push(clientRect);
 } while ((caretPosition = walkFn(caretPosition)));
 return result;
 };
 const isAboveLine = (lineNumber) => (clientRect) => aboveLineNumber(lineNumber, clientRect);
 const isLine = (lineNumber) => (clientRect) => isLineNumber(lineNumber, clientRect);

const deleteRange = (editor, forward) => {
        const rng = normalize(editor.selection.getRng());
        return isSelectionOverWholeHTMLElement(rng)
            ? Optional.some(() => deleteElement$2(editor, forward, SugarElement.fromDom(editor.selection.getNode())))
            : Optional.none();
    };
    const backspaceDelete$1 = (editor, forward) => editor.selection.isCollapsed() ? Optional.none() : deleteRange(editor, forward);

// This is based heavily on Alloy's TapEvent.ts, just modified to use TinyMCE's event system.
    const SIGNIFICANT_MOVE = 5;
    const LONGPRESS_DELAY = 400;
    const getTouch = (event) => {
        if (event.touches === undefined || event.touches.length !== 1) {
            return Optional.none();
        }
        return Optional.some(event.touches[0]);
    };
    const isFarEnough = (touch, data) => {
        const distX = Math.abs(touch.clientX - data.x);
        const distY = Math.abs(touch.clientY - data.y);
        return distX > SIGNIFICANT_MOVE || distY > SIGNIFICANT_MOVE;
    };
    const setup$u = (editor) => {
        const startData = value$1();
        const longpressFired = Cell(false);
        const debounceLongpress = last$1((e) => {
            editor.dispatch('longpress', { ...e, type: 'longpress' });
            longpressFired.set(true);
        }, LONGPRESS_DELAY);
        editor.on('touchstart', (e) => {
            getTouch(e).each((touch) => {
                debounceLongpress.cancel();
                const data = {
                    x: touch.clientX,
                    y: touch.clientY,
                    target: e.target
                };
                debounceLongpress.throttle(e);
                longpressFired.set(false);
                startData.set(data);
            });
        }, true);
        editor.on('touchmove', (e) => {
            debounceLongpress.cancel();
            getTouch(e).each((touch) => {
                startData.on((data) => {
                    if (isFarEnough(touch, data)) {
                        startData.clear();
                        longpressFired.set(false);
                        editor.dispatch('longpresscancel');
                    }
                });
            });
        }, true);
        editor.on('touchend touchcancel', (e) => {
            debounceLongpress.cancel();
            if (e.type === 'touchcancel') {
                return;
            }
            // Cancel the touchend event if a longpress was fired, otherwise fire the tap event
            startData.get()
                .filter((data) => data.target.isEqualNode(e.target))
                .each(() => {
                if (longpressFired.get()) {
                    e.preventDefault();
                }
                else {
                    editor.dispatch('tap', { ...e, type: 'tap' });
                }
            });
        }, true);
    };

/**
     * Makes sure that everything gets wrapped in paragraphs.
     *
     * @private
     * @class tinymce.ForceBlocks
     */
    const isBlockElement = (blockElements, node) => has$2(blockElements, node.nodeName);
    const isValidTarget = (schema, node) => {
        if (isText$b(node)) {
            return true;
        }
        else if (isElement$7(node)) {
            return !isBlockElement(schema.getBlockElements(), node) && !isBookmarkNode$1(node) &&
                !isTransparentBlock(schema, node) && !isNonHtmlElementRoot(node) && !isTemplate(node);
        }
        else {
            return false;
        }
    };
    const hasBlockParent = (blockElements, root, node) => {
        return exists(parents(SugarElement.fromDom(node), SugarElement.fromDom(root)), (elm) => {
            return isBlockElement(blockElements, elm.dom);
        });
    };
    const shouldRemoveTextNode = (blockElements, node) => {
        if (isText$b(node)) {
            if (node.data.length === 0) {
                return true;
            }
            else if (/^\s+$/.test(node.data)) {
                return !node.nextSibling || isBlockElement(blockElements, node.nextSibling) || isNonHtmlElementRoot(node.nextSibling);
            }
        }
        return false;
    };
    const createRootBlock = (editor) => editor.dom.create(getForcedRootBlock(editor), getForcedRootBlockAttrs(editor));
    const addRootBlocks = (editor) => {
        const dom = editor.dom, selection = editor.selection;
        const schema = editor.schema;
        const blockElements = schema.getBlockElements();
        const startNode = selection.getStart();
        const rootNode = editor.getBody();
        let rootBlockNode;
        let tempNode;
        let bm = null;
        const forcedRootBlock = getForcedRootBlock(editor);
        if (!startNode || !isElement$7(startNode)) {
            return;
        }
        const rootNodeName = rootNode.nodeName.toLowerCase();
        if (!schema.isValidChild(rootNodeName, forcedRootBlock.toLowerCase()) || hasBlockParent(blockElements, rootNode, startNode)) {
            return;
        }
        // Firefox will automatically remove the last BR if you insert nodes next to it and add a BR back if you remove those siblings
        // and since the bookmark code inserts temporary nodes an new BR will be constantly removed and added and triggering a selection
        // change causing an infinite recursion. So we treat this special case on it's own.
        if (rootNode.firstChild === rootNode.lastChild && isBr$7(rootNode.firstChild)) {
            rootBlockNode = createRootBlock(editor);
            rootBlockNode.appendChild(createPaddingBr().dom);
            rootNode.replaceChild(rootBlockNode, rootNode.firstChild);
            editor.selection.setCursorLocation(rootBlockNode, 0);
            editor.nodeChanged();
            return;
        }
        // Wrap non block elements and text nodes
        let node = rootNode.firstChild;
        while (node) {
            if (isElement$7(node)) {
                updateElement(schema, node);
            }
            if (isValidTarget(schema, node)) {
                // Remove empty text nodes and nodes containing only whitespace
                if (shouldRemoveTextNode(blockElements, node)) {
                    tempNode = node;
                    node = node.nextSibling;
                    dom.remove(tempNode);
                    continue;
                }
                if (!rootBlockNode) {
                    if (!bm && editor.hasFocus()) {
                        bm = createBookmark(editor.selection.getRng(), () => document.createElement('span'));
                    }
                    // Firefox will remove the last BR element if you insert nodes next to it using DOM APIs like insertBefore
                    // so for that weird edge case we stop processing.
                    if (!node.parentNode) {
                        node = null;
                        break;
                    }
                    rootBlockNode = createRootBlock(editor);
                    rootNode.insertBefore(rootBlockNode, node);
                }
                tempNode = node;
                node = node.nextSibling;
                rootBlockNode.appendChild(tempNode);
            }
            else {
                rootBlockNode = null;
                node = node.nextSibling;
            }
        }
        if (bm) {
            editor.selection.setRng(resolveBookmark(bm));
            editor.nodeChanged();
        }
    };
    const insertEmptyLine = (editor, root, insertBlock) => {
        const block = SugarElement.fromDom(createRootBlock(editor));
        const br = createPaddingBr();
        append$1(block, br);
        insertBlock(root, block);
        const rng = document.createRange();
        rng.setStartBefore(br.dom);
        rng.setEndBefore(br.dom);
        return rng;
    };
    const setup$t = (editor) => {
        editor.on('NodeChange', () => addRootBlocks(editor));
    };

/**
     * This module shows the invisible block that the caret is currently in when contents is added to that block.
     */
    const findBlockCaretContainer = (editor) => descendant$1(SugarElement.fromDom(editor.getBody()), '*[data-mce-caret]')
        .map((elm) => elm.dom)
        .getOrNull();
    const showBlockCaretContainer = (editor, blockCaretContainer) => {
        if (blockCaretContainer.hasAttribute('data-mce-caret')) {
            showCaretContainerBlock(blockCaretContainer);
            editor.selection.setRng(editor.selection.getRng()); // Clears the fake caret state
            editor.selection.scrollIntoView(blockCaretContainer);
        }
    };
    const handleBlockContainer = (editor, e) => {
        const blockCaretContainer = findBlockCaretContainer(editor);
        if (!blockCaretContainer) {
            return;
        }
        if (e.type === 'compositionstart') {
            e.preventDefault();
            e.stopPropagation();
            showBlockCaretContainer(editor, blockCaretContainer);
            return;
        }
        if (hasContent(blockCaretContainer)) {
            showBlockCaretContainer(editor, blockCaretContainer);
            editor.undoManager.add();
        }
    };
    const setup$r = (editor) => {
        editor.on('keyup compositionstart', curry(handleBlockContainer, editor));
    };

// lookup inside this table
    const lookup$1 = (tags, element, isRoot = never) => {
        // If the element we're inspecting is the root, we definitely don't want it.
        if (isRoot(element)) {
            return Optional.none();
        }
        // This looks a lot like SelectorFind.closest, with one big exception - the isRoot check.
        // The code here will look for parents if passed a table, SelectorFind.closest with that specific isRoot check won't.
        if (contains$2(tags, name(element))) {
            return Optional.some(element);
        }
        const isRootOrUpperTable = (elm) => is$2(elm, 'table') || isRoot(elm);
        return ancestor$4(element, tags.join(','), isRootOrUpperTable);
    };
    /*
     * Identify the optional cell that element represents.
     */
    const cell = (element, isRoot) => lookup$1(['td', 'th'], element, isRoot);
    const cells = (ancestor) => firstLayer(ancestor, 'th,td');
    const table = (element, isRoot) => closest$4(element, 'table', isRoot);

/*
 * Walk until the next eligible cell location is found, or the start/end of the table is found.
 */
 const walk = (all, current, index, direction, isEligible = always) => {
 const forwards = direction === 1 /* Direction.Forwards */;
 if (!forwards && index <= 0) {
 return CellLocation.first(all[0]);
 }
 else if (forwards && index >= all.length - 1) {
 return CellLocation.last(all[all.length - 1]);
 }
 else {
 const newIndex = index + direction;
 const elem = all[newIndex];
 return isEligible(elem) ? CellLocation.middle(current, elem) : walk(all, current, newIndex, direction, isEligible);
 }
 };
 /*
 * Identify the index of the current cell within all the cells, and
 * a list of the cells within its table.
 */
 const detect = (current, isRoot) => {
 return table(current, isRoot).bind((table) => {
 const all = cells(table);
 const index = findIndex$2(all, (x) => eq(current, x));
 return index.map((index) => ({ index, all }));
 });
 };
 /*
 * Identify the CellLocation of the cell when navigating forward from current
 */
 const next = (current, isEligible, isRoot) => {
 const detection = detect(current, isRoot);
 return detection.fold(() => {
 return CellLocation.none(current);
 }, (info) => {
 return walk(info.all, current, info.index, 1 /* Direction.Forwards */, isEligible);
 });
 };
 /*
 * Identify the CellLocation of the cell when navigating back from current
 */
 const prev = (current, isEligible, isRoot) => {
 const detection = detect(current, isRoot);
 return detection.fold(() => {
 return CellLocation.none();
 }, (info) => {
 return walk(info.all, current, info.index, -1 /* Direction.Backwards */, isEligible);
 });
 };

var TagBoundaries = [
        'body',
        'p',
        'div',
        'article',
        'aside',
        'figcaption',
        'figure',
        'footer',
        'header',
        'nav',
        'section',
        'ol',
        'ul',
        'li',
        'table',
        'thead',
        'tbody',
        'tfoot',
        'caption',
        'tr',
        'td',
        'th',
        'h1',
        'h2',
        'h3',
        'h4',
        'h5',
        'h6',
        'blockquote',
        'pre',
        'address'
    ];

const point$1 = (element, offset) => ({
        element,
        offset
    });

/**
 * Return the last available cursor position in the node.
 */
 const toLast$1 = (universe, node) => {
 if (universe.property().isText(node)) {
 return point$1(node, universe.property().getText(node).length);
 }
 else {
 const children = universe.property().children(node);
 // keep descending if there are children.
 return children.length > 0 ? toLast$1(universe, children[children.length - 1]) : point$1(node, children.length);
 }
 };
 /**
 * Descend down to a leaf node at the given offset.
 */
 const toLeaf$3 = (universe, element, offset) => {
 const children = universe.property().children(element);
 if (children.length > 0 && offset < children.length) {
 return toLeaf$3(universe, children[offset], 0);
 }
 else if (children.length > 0 && universe.property().isElement(element) && children.length === offset) {
 return toLast$1(universe, children[children.length - 1]);
 }
 else {
 return point$1(element, offset);
 }
 };

const toLeaf$2 = toLeaf$3;

const universe = DomUniverse();
    const toLeaf$1 = (element, offset) => {
        return toLeaf$2(universe, element, offset);
    };

const imageId = generate('image');
    const getDragImage = (transfer) => {
        const dt = transfer;
        return Optional.from(dt[imageId]);
    };
    const setDragImage = (transfer, imageData) => {
        const dt = transfer;
        dt[imageId] = imageData;
    };

const createEmptyFileList = () => Object.freeze({
        length: 0,
        item: (_) => null
    });

const getHtmlData = (dataTransfer) => {
        const html = dataTransfer.getData('text/html');
        return html === '' ? Optional.none() : Optional.some(html);
    };
    const setHtmlData = (dataTransfer, html) => dataTransfer.setData('text/html', html);

const point = (container, offset) => ({
        container,
        offset
    });

const isValidTextRange = (rng) => rng.collapsed && isText$b(rng.startContainer);
    // Normalize the text by replacing non-breaking spaces with regular spaces and stripping zero-width spaces (fake carets).
    const getText = (rng) => trim$2(rng.toString().replace(/\u00A0/g, ' '));
    const isWhitespace = (chr) => chr !== '' && ' \u00a0\ufeff\f\n\r\t\v'.indexOf(chr) !== -1;

const type = requiredString('type');
    const fetch$1 = requiredFunction('fetch');
    const onAction = requiredFunction('onAction');
    optionString('name');
    optionString('text');
    optionString('role');
    optionString('icon');
    optionString('url');
    optionString('tooltip');
    optionString('chevronTooltip');
    optionString('label');
    optionString('shortcut');
    const defaultedColumns = (num) => defaulted('columns', num);

const autocompleterSchema = objOf([
        type,
        requiredString('trigger'),
        defaultedNumber('minChars', 1),
        defaultedColumns(1),
        defaultedNumber('maxResults', 10),
        optionFunction('matches'),
        fetch$1,
        onAction,
        defaultedArrayOf('highlightOn', [], string)
    ]);
    const createAutocompleter = (spec) => asRaw('Autocompleter', autocompleterSchema, spec);

// Walks the parent block to the right and look for BR elements
 const hasRightSideContent = (schema, container, parentBlock) => {
 const walker = new DomTreeWalker(container, parentBlock);
 let node;
 const nonEmptyElementsMap = schema.getNonEmptyElements();
 while ((node = walker.next())) {
 if (nonEmptyElementsMap[node.nodeName.toLowerCase()] || isText$b(node) && node.length > 0) {
 return true;
 }
 }
 return false;
 };
 const moveSelectionToBr = (editor, brElm, extraBr) => {
 const rng = editor.dom.createRng();
 if (!extraBr) {
 rng.setStartAfter(brElm);
 rng.setEndAfter(brElm);
 }
 else {
 rng.setStartBefore(brElm);
 rng.setEndBefore(brElm);
 }
 editor.selection.setRng(rng);
 scrollRangeIntoView(editor, rng);
 };
 const insertBrAtCaret = (editor, evt) => {
 // We load the current event in from EnterKey.js when appropriate to heed
 // certain event-specific variations such as ctrl-enter in a list
 const selection = editor.selection;
 const dom = editor.dom;
 const rng = selection.getRng();
 let brElm;
 let extraBr = false;
 normalize$2(dom, rng).each((normRng) => {
 rng.setStart(normRng.startContainer, normRng.startOffset);
 rng.setEnd(normRng.endContainer, normRng.endOffset);
 });
 let offset = rng.startOffset;
 let container = rng.startContainer;
 // Resolve node index
 if (isElement$7(container) && container.hasChildNodes()) {
 const isAfterLastNodeInContainer = offset > container.childNodes.length - 1;
 container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;
 if (isAfterLastNodeInContainer && isText$b(container)) {
 offset = container.data.length;
 }
 else {
 offset = 0;
 }
 }
 let parentBlock = dom.getParent(container, dom.isBlock);
 const containerBlock = parentBlock && parentBlock.parentNode ? dom.getParent(parentBlock.parentNode, dom.isBlock) : null;
 const containerBlockName = containerBlock ? containerBlock.nodeName.toUpperCase() : ''; // IE < 9 & HTML5
 // Enter inside block contained within a LI then split or insert before/after LI
 const isControlKey = !!(evt && evt.ctrlKey);
 if (containerBlockName === 'LI' && !isControlKey) {
 parentBlock = containerBlock;
 }
 if (isText$b(container) && offset >= container.data.length) {
 // Insert extra BR element at the end block elements
 if (!hasRightSideContent(editor.schema, container, parentBlock || dom.getRoot())) {
 brElm = dom.create('br');
 rng.insertNode(brElm);
 rng.setStartAfter(brElm);
 rng.setEndAfter(brElm);
 extraBr = true;
 }
 }
 brElm = dom.create('br');
 rangeInsertNode(dom, rng, brElm);
 moveSelectionToBr(editor, brElm, extraBr);
 editor.undoManager.add();
 };
 const insertBrBefore = (editor, inline) => {
 const br = SugarElement.fromTag('br');
 before$4(SugarElement.fromDom(inline), br);
 editor.undoManager.add();
 };
 const insertBrAfter = (editor, inline) => {
 if (!hasBrAfter(editor.getBody(), inline)) {
 after$4(SugarElement.fromDom(inline), SugarElement.fromTag('br'));
 }
 const br = SugarElement.fromTag('br');
 after$4(SugarElement.fromDom(inline), br);
 moveSelectionToBr(editor, br.dom, false);
 editor.undoManager.add();
 };
 const isBeforeBr = (pos) => {
 return isBr$7(pos.getNode());
 };
 const hasBrAfter = (rootNode, startNode) => {
 if (isBeforeBr(CaretPosition.after(startNode))) {
 return true;
 }
 else {
 return nextPosition(rootNode, CaretPosition.after(startNode)).map((pos) => {
 return isBr$7(pos.getNode());
 }).getOr(false);
 }
 };
 const isAnchorLink = (elm) => {
 return elm && elm.nodeName === 'A' && 'href' in elm;
 };
 const isInsideAnchor = (location) => {
 return location.fold(never, isAnchorLink, isAnchorLink, never);
 };
 const readInlineAnchorLocation = (editor) => {
 const isInlineTarget$1 = curry(isInlineTarget, editor);
 const position = CaretPosition.fromRangeStart(editor.selection.getRng());
 return readLocation(isInlineTarget$1, editor.getBody(), position).filter(isInsideAnchor);
 };
 const insertBrOutsideAnchor = (editor, location) => {
 location.fold(noop, curry(insertBrBefore, editor), curry(insertBrAfter, editor), noop);
 };
 const insert$2 = (editor, evt) => {
 const anchorLocation = readInlineAnchorLocation(editor);
 if (anchorLocation.isSome()) {
 anchorLocation.each(curry(insertBrOutsideAnchor, editor));
 }
 else {
 insertBrAtCaret(editor, evt);
 }
 };
 const fakeEventName = 'insertLineBreak';
 const linebreak = {
 insert: insert$2,
 fakeEventName
 };

const setup$b = (editor) => {
        setup$e(editor);
        setup$f(editor);
        setup$d(editor);
        setup$c(editor);
    };

/**
     * This class handles the nodechange event dispatching both manual and through selection change events.
     *
     * @class tinymce.NodeChange
     * @private
     */
    class NodeChange {
        editor;
        lastPath = [];
        constructor(editor) {
            this.editor = editor;
            let lastRng;
            const self = this;
            // Gecko doesn't support the "selectionchange" event
            if (!('onselectionchange' in editor.getDoc())) {
                editor.on('NodeChange click mouseup keyup focus', (e) => {
                    // Since DOM Ranges mutate on modification
                    // of the DOM we need to clone it's contents
                    const nativeRng = editor.selection.getRng();
                    const fakeRng = {
                        startContainer: nativeRng.startContainer,
                        startOffset: nativeRng.startOffset,
                        endContainer: nativeRng.endContainer,
                        endOffset: nativeRng.endOffset
                    };
                    // Always treat nodechange as a selectionchange since applying
                    // formatting to the current range wouldn't update the range but it's parent
                    if (e.type === 'nodechange' || !isEq$4(fakeRng, lastRng)) {
                        editor.dispatch('SelectionChange');
                    }
                    lastRng = fakeRng;
                });
            }
            // IE has a bug where it fires a selectionchange on right click that has a range at the start of the body
            // When the contextmenu event fires the selection is located at the right location
            editor.on('contextmenu', () => {
                store(editor);
                editor.dispatch('SelectionChange');
            });
            // Selection change is delayed ~200ms on IE when you click inside the current range
            editor.on('SelectionChange', () => {
                const startElm = editor.selection.getStart(true);
                // When focusout from after cef element to other input element the startelm can be undefined
                if (!startElm) {
                    return;
                }
                if (hasAnyRanges(editor) && !self.isSameElementPath(startElm) && editor.dom.isChildOf(startElm, editor.getBody())) {
                    editor.nodeChanged({ selectionChange: true });
                }
            });
            // Fire an extra nodeChange on mouseup for compatibility reasons
            editor.on('mouseup', (e) => {
                if (!e.isDefaultPrevented() && hasAnyRanges(editor)) {
                    // Delay nodeChanged call for WebKit edge case issue where the range
                    // isn't updated until after you click outside a selected image
                    if (editor.selection.getNode().nodeName === 'IMG') {
                        Delay.setEditorTimeout(editor, () => {
                            editor.nodeChanged();
                        });
                    }
                    else {
                        editor.nodeChanged();
                    }
                }
            });
        }
        /**
         * Dispatches out a onNodeChange event to all observers. This method should be called when you
         * need to update the UI states or element path etc.
         *
         * @method nodeChanged
         * @param {Object} args Optional args to pass to NodeChange event handlers.
         */
        nodeChanged(args = {}) {
            const editor = this.editor;
            const selection = editor.selection;
            let node;
            // Fix for bug #1896577 it seems that this can not be fired while the editor is loading
            if (editor.initialized && selection && !shouldDisableNodeChange(editor) && !isDisabled$1(editor)) {
                // Get start node
                const root = editor.getBody();
                node = selection.getStart(true) || root;
                // Make sure the node is within the editor root or is the editor root
                if (node.ownerDocument !== editor.getDoc() || !editor.dom.isChildOf(node, root)) {
                    node = root;
                }
                // Get parents and add them to object
                const parents = [];
                editor.dom.getParent(node, (node) => {
                    if (node === root) {
                        return true;
                    }
                    else {
                        parents.push(node);
                        return false;
                    }
                });
                editor.dispatch('NodeChange', {
                    ...args,
                    element: node,
                    parents
                });
            }
        }
        /**
         * Returns true/false if the current element path has been changed or not.
         *
         * @private
         * @return {Boolean} True if the element path is the same false if it's not.
         */
        isSameElementPath(startElm) {
            let i;
            const editor = this.editor;
            const currentPath = reverse(editor.dom.getParents(startElm, always, editor.getBody()));
            if (currentPath.length === this.lastPath.length) {
                for (i = currentPath.length; i >= 0; i--) {
                    if (currentPath[i] !== this.lastPath[i]) {
                        break;
                    }
                }
                if (i === -1) {
                    this.lastPath = currentPath;
                    return true;
                }
            }
            this.lastPath = currentPath;
            return false;
        }
    }

const internalMimeType = 'x-tinymce/html';
 const internalHtmlMime = constant(internalMimeType);
 const internalMark = '';
 const mark = (html) => internalMark + html;
 const unmark = (html) => html.replace(internalMark, '');
 const isMarked = (html) => html.indexOf(internalMark) !== -1;

/*
 * This module contains utilities to convert newlines (\n or \r\n) to BRs or to a combination of the specified block element and BRs
 */
 const isPlainText = (text) => {
 // so basically any tag that is not one of the "p, div, span, br", or is one of them, but is followed
 // by some additional characters qualifies the text as not a plain text (having some HTML tags)
 // and are added as separate exceptions to the rule
 return !/<(?:\/?(?!(?:div|p|br|span)>)\w+|(?:(?!(?:span style="white-space:\s?pre;?">)|br\s?\/>))\w+\s[^>]+)>/i.test(text);
 };
 const openContainer = (rootTag, rootAttrs) => {
 let tag = '<' + rootTag;
 const attrs = mapToArray(rootAttrs, (value, key) => key + '="' + Entities.encodeAllRaw(value) + '"');
 if (attrs.length) {
 tag += ' ' + attrs.join(' ');
 }
 return tag + '>';
 };
 const toBlockElements = (text, rootTag, rootAttrs) => {
 const blocks = text.split(/\n\n/);
 const tagOpen = openContainer(rootTag, rootAttrs);
 const tagClose = '</' + rootTag + '>';
 const paragraphs = map$3(blocks, (p) => {
 return p.split(/\n/).join(' ');
 });
 const stitch = (p) => {
 return tagOpen + p + tagClose;
 };
 return paragraphs.length === 1 ? paragraphs[0] : map$3(paragraphs, stitch).join('');
 };

/*
 * This module contains various utility functions for the paste logic.
 */
 const filter = (content, items) => {
 Tools.each(items, (v) => {
 if (is$5(v, RegExp)) {
 content = content.replace(v, '');
 }
 else {
 content = content.replace(v[0], v[1]);
 }
 });
 return content;
 };
 /*
 * Gets the innerText of the specified element. It will handle edge cases
 * and works better than textContent on Gecko.
 */
 const innerText = (html) => {
 const schema = Schema();
 const domParser = DomParser({}, schema);
 let text = '';
 const voidElements = schema.getVoidElements();
 const ignoreElements = Tools.makeMap('script noscript style textarea video audio iframe object', ' ');
 const blockElements = schema.getBlockElements();
 const walk = (node) => {
 const name = node.name, currentNode = node;
 if (name === 'br') {
 text += '\n';
 return;
 }
 // Ignore wbr, to replicate innerText on Chrome/Firefox
 if (name === 'wbr') {
 return;
 }
 // img/input/hr but ignore wbr as it's just a potential word break
 if (voidElements[name]) {
 text += ' ';
 }
 // Ignore script, video contents
 if (ignoreElements[name]) {
 text += ' ';
 return;
 }
 if (node.type === 3) {
 text += node.value;
 }
 // Walk all children
 if (!(node.name in schema.getVoidElements())) {
 let currentNode = node.firstChild;
 if (currentNode) {
 do {
 walk(currentNode);
 } while ((currentNode = currentNode.next));
 }
 }
 // Add \n or \n\n for blocks or P
 if (blockElements[name] && currentNode.next) {
 text += '\n';
 if (name === 'p') {
 text += '\n';
 }
 }
 };
 html = filter(html, [
 /<!\[[^\]]+\]>/g // Conditional comments
 ]);
 walk(domParser.parse(html));
 return text;
 };
 /*
 * Trims the specified HTML by removing all WebKit fragments, all elements wrapping the body trailing BR elements etc.
 */
 const trimHtml = (html) => {
 const trimSpaces = (all, s1, s2) => {
 // WebKit &nbsp; meant to preserve multiple spaces but instead inserted around all inline tags,
 // including the spans with inline styles created on paste
 if (!s1 && !s2) {
 return ' ';
 }
 return nbsp;
 };
 html = filter(html, [
 /^[\s\S]*<body[^>]*>\s*|\s*<\/body[^>]*>[\s\S]*$/ig, // Remove anything but the contents within the BODY element
 /|/g, // Inner fragments (tables from excel on mac)
 [/( ?)\u00a0<\/span>( ?)/g, trimSpaces],
 / /g,
 / $/i // Trailing BR elements
 ]);
 return html;
 };
 // TODO: Should be in some global class
 const createIdGenerator = (prefix) => {
 let count = 0;
 return () => {
 return prefix + (count++);
 };
 };
 const getImageMimeType = (ext) => {
 const lowerExt = ext.toLowerCase();
 const mimeOverrides = {
 jpg: 'jpeg',
 jpe: 'jpeg',
 jfi: 'jpeg',
 jif: 'jpeg',
 jfif: 'jpeg',
 pjpeg: 'jpeg',
 pjp: 'jpeg',
 svg: 'svg+xml'
 };
 return Tools.hasOwn(mimeOverrides, lowerExt) ? 'image/' + mimeOverrides[lowerExt] : 'image/' + lowerExt;
 };

/*
 * This module contains various fixes for browsers. These issues can not be feature
 * detected since we have no direct control over the clipboard. However we might be able
 * to remove some of these fixes once the browsers gets updated/fixed.
 */
 const addPreProcessFilter = (editor, filterFunc) => {
 editor.on('PastePreProcess', (e) => {
 e.content = filterFunc(editor, e.content, e.internal);
 });
 };
 const rgbRegExp = /rgb\s*$\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*$/gi;
 const rgbToHex = (value) => Tools.trim(value).replace(rgbRegExp, rgbaToHexString).toLowerCase();
 /*
 * WebKit has a nasty quirk where the all computed styles gets added to style attributes when copy/pasting contents.
 * This fix solves that by simply removing the whole style attribute.
 *
 * The paste_webkit_styles option can be set to specify what to keep:
 * paste_webkit_styles: "none" // Keep no styles
 * paste_webkit_styles: "all", // Keep all of them
 * paste_webkit_styles: "font-weight color" // Keep specific ones
 */
 const removeWebKitStyles = (editor, content, internal) => {
 const webKitStylesOption = getPasteWebkitStyles(editor);
 // If the content is internal or if we're keeping all styles then we don't need any processing
 if (internal || webKitStylesOption === 'all' || !shouldPasteRemoveWebKitStyles(editor)) {
 return content;
 }
 const webKitStyles = webKitStylesOption ? webKitStylesOption.split(/[, ]/) : [];
 // Keep specific styles that don't match the current node computed style
 if (webKitStyles && webKitStylesOption !== 'none') {
 const dom = editor.dom, node = editor.selection.getNode();
 content = content.replace(/(<[^>]+) style="([^"]*)"([^>]*>)/gi, (all, before, value, after) => {
 const inputStyles = dom.parseStyle(dom.decode(value));
 const outputStyles = {};
 for (let i = 0; i < webKitStyles.length; i++) {
 const inputValue = inputStyles[webKitStyles[i]];
 let compareInput = inputValue;
 let currentValue = dom.getStyle(node, webKitStyles[i], true);
 if (/color/.test(webKitStyles[i])) {
 compareInput = rgbToHex(compareInput);
 currentValue = rgbToHex(currentValue);
 }
 if (currentValue !== compareInput) {
 outputStyles[webKitStyles[i]] = inputValue;
 }
 }
 const outputStyle = dom.serializeStyle(outputStyles, 'span');
 if (outputStyle) {
 return before + ' style="' + outputStyle + '"' + after;
 }
 return before + after;
 });
 }
 else {
 // Remove all external styles
 content = content.replace(/(<[^>]+) style="([^"]*)"([^>]*>)/gi, '$1$3');
 }
 // Keep internal styles
 content = content.replace(/(<[^>]+) data-mce-style="([^"]+)"([^>]*>)/gi, (all, before, value, after) => {
 return before + ' style="' + value + '"' + after;
 });
 return content;
 };
 const setup$8 = (editor) => {
 if (Env.browser.isChromium() || Env.browser.isSafari()) {
 addPreProcessFilter(editor, removeWebKitStyles);
 }
 };

const setup$7 = (editor, caret) => {
        const draggingInternallyState = Cell(false);
        const pasteFormat = Cell(isPasteAsTextEnabled(editor) ? 'text' : 'html');
        const pasteBin = PasteBin(editor);
        setup$8(editor);
        register$1(editor, pasteFormat);
        setup$9(editor);
        editor.addQueryStateHandler('mceTogglePlainTextPaste', () => pasteFormat.get() === 'text');
        // IMPORTANT: The following event hooks need to be setup later so that other things
        // can hook in and prevent the event so core paste doesn't handle them.
        editor.on('PreInit', () => {
            register(editor, caret);
            setup$a(editor, draggingInternallyState);
            registerEventsAndFilters(editor, pasteBin, pasteFormat);
        });
    };

var FakeCaretPosition;
 (function (FakeCaretPosition) {
 FakeCaretPosition["Before"] = "before";
 FakeCaretPosition["After"] = "after";
 })(FakeCaretPosition || (FakeCaretPosition = {}));
 const distanceToRectLeft = (clientRect, clientX) => Math.abs(clientRect.left - clientX);
 const distanceToRectRight = (clientRect, clientX) => Math.abs(clientRect.right - clientX);
 const isInsideY = (clientY, clientRect) => clientY >= clientRect.top && clientY <= clientRect.bottom;
 const collidesY = (r1, r2) => r1.top < r2.bottom && r1.bottom > r2.top;
 const isOverlapping = (r1, r2) => {
 // Rectangles might overlap a bit so this checks if the overlap is more than 50% then we count that as on the same line
 const overlap = overlapY(r1, r2) / Math.min(r1.height, r2.height);
 return collidesY(r1, r2) && overlap > 0.5;
 };
 const splitRectsPerAxis = (rects, y) => {
 const intersectingRects = filter$5(rects, (rect) => isInsideY(y, rect));
 return boundingClientRectFromRects(intersectingRects).fold(() => ([[], rects]), (boundingRect) => {
 const { pass: horizontal, fail: vertical } = partition$2(rects, (rect) => isOverlapping(rect, boundingRect));
 return [horizontal, vertical];
 });
 };
 const clientInfo = (rect, clientX) => {
 return {
 node: rect.node,
 position: distanceToRectLeft(rect, clientX) < distanceToRectRight(rect, clientX) ? FakeCaretPosition.Before : FakeCaretPosition.After
 };
 };
 // Measure the distance between the x and the closest edge of the rect.
 // If the x is inside the rect then always return 0.
 const horizontalDistance = (rect, x, _y) => x > rect.left && x < rect.right ? 0 : Math.min(Math.abs(rect.left - x), Math.abs(rect.right - x));
 const closestChildCaretCandidateNodeRect = (children, clientX, clientY, findCloserTextNode) => {
 const caretCandidateRect = (rect) => {
 if (isCaretCandidate$3(rect.node)) {
 return Optional.some(rect);
 }
 else if (isElement$7(rect.node)) {
 return closestChildCaretCandidateNodeRect(from(rect.node.childNodes), clientX, clientY, false);
 }
 else {
 return Optional.none();
 }
 };
 // If an element and a text node has nearly equal distance then favor the text node over the element to make it easier to select text
 // since setting the selection range will cancel any text select operation.
 const tryFindSecondBestTextNode = (closest, sndClosest, distance) => {
 return caretCandidateRect(sndClosest).filter((rect) => {
 const deltaDistance = Math.abs(distance(closest, clientX, clientY) - distance(rect, clientX, clientY));
 return deltaDistance < 2 && isText$b(rect.node);
 });
 };
 const findClosestCaretCandidateNodeRect = (rects, distance) => {
 const sortedRects = sort(rects, (r1, r2) => distance(r1, clientX, clientY) - distance(r2, clientX, clientY));
 return findMap(sortedRects, caretCandidateRect).map((closest) => {
 // If the closest rect is not a text node then lets try to see if the second rect has a text node that is close enough
 if (findCloserTextNode && !isText$b(closest.node) && sortedRects.length > 1) {
 return tryFindSecondBestTextNode(closest, sortedRects[1], distance).getOr(closest);
 }
 else {
 return closest;
 }
 });
 };
 const [horizontalRects, verticalRects] = splitRectsPerAxis(getClientRects(children), clientY);
 const { pass: above, fail: below } = partition$2(verticalRects, (rect) => rect.top < clientY);
 return findClosestCaretCandidateNodeRect(horizontalRects, horizontalDistance)
 .orThunk(() => findClosestCaretCandidateNodeRect(below, distanceToRectEdgeFromXY))
 .orThunk(() => findClosestCaretCandidateNodeRect(above, distanceToRectEdgeFromXY));
 };
 const traverseUp = (rootElm, scope, clientX, clientY) => {
 const helper = (scope, prevScope) => {
 const isDragGhostContainer = (node) => isElement$7(node) && node.classList.contains('mce-drag-container');
 const childNodesWithoutGhost = filter$5(scope.dom.childNodes, not(isDragGhostContainer));
 return prevScope.fold(() => closestChildCaretCandidateNodeRect(childNodesWithoutGhost, clientX, clientY, true), (prevScope) => {
 const uncheckedChildren = filter$5(childNodesWithoutGhost, (node) => node !== prevScope.dom);
 return closestChildCaretCandidateNodeRect(uncheckedChildren, clientX, clientY, true);
 }).orThunk(() => {
 const parent = eq(scope, rootElm) ? Optional.none() : parentElement(scope);
 return parent.bind((newScope) => helper(newScope, Optional.some(scope)));
 });
 };
 return helper(scope, Optional.none());
 };
 // Rough description of how this algorithm works:
 // 1. It starts by finding the element at the specified X, Y coordinate.
 // 2. Then it checks its children for the closest one and traverses down into those repeating step 2, 3 until it finds a caret candidate.
 // 3. If no caret candidate is found in the closest child node then it checks the second closest and so on until all decendants have been checked.
 // 4. If no caret candidate is found, it traverses up skips the element it already checked and checks its siblings using steps 2, 3.
 // 5. If no caret candidate is found, it continues step 4 until it finds the root. Then we have checked all the nodes in the document.
 //
 // This is less accurate but more performant, since for the common case you are likely to find a caret candidate close to where you are clicking.
 // The more accurate algorithm would be to read all caret candidates rects in the whole document in and in one big step to find the closest one, but that is just too slow for bigger documents.
 const closestCaretCandidateNodeRect = (root, clientX, clientY) => {
 const rootElm = SugarElement.fromDom(root);
 const ownerDoc = documentOrOwner(rootElm);
 const elementAtPoint = SugarElement.fromPoint(ownerDoc, clientX, clientY).filter((elm) => contains(rootElm, elm));
 const element = elementAtPoint.getOr(rootElm);
 return traverseUp(rootElm, element, clientX, clientY);
 };
 const closestFakeCaretCandidate = (root, clientX, clientY) => closestCaretCandidateNodeRect(root, clientX, clientY)
 .filter((rect) => isFakeCaretTarget(rect.node))
 .map((rect) => clientInfo(rect, clientX));

/**
 * This module contains logic overriding the drag/drop logic of the editor.
 *
 * @private
 * @class tinymce.DragDropOverrides
 */
 // Arbitrary values needed when scrolling CEF elements
 const scrollPixelsPerInterval = 32;
 const scrollIntervalValue = 100;
 const mouseRangeToTriggerScrollInsideEditor = 8;
 const mouseRangeToTriggerScrollOutsideEditor = 16;
 const isContentEditableFalse$1 = isContentEditableFalse$a;
 const isContentEditable = or(isContentEditableFalse$1, isContentEditableTrue$3);
 const isDraggable = (dom, rootElm, elm) => isContentEditableFalse$1(elm) && elm !== rootElm && dom.isEditable(elm.parentElement);
 const isValidDropTarget = (editor, targetElement, dragElement) => {
 if (isNullable(targetElement)) {
 return false;
 }
 else if (targetElement === dragElement || editor.dom.isChildOf(targetElement, dragElement)) {
 return false;
 }
 else {
 return editor.dom.isEditable(targetElement);
 }
 };
 const createGhost = (editor, elm, width, height) => {
 const dom = editor.dom;
 const clonedElm = elm.cloneNode(true);
 dom.setStyles(clonedElm, { width, height });
 dom.setAttrib(clonedElm, 'data-mce-selected', null);
 const ghostElm = dom.create('div', {
 'class': 'mce-drag-container',
 'data-mce-bogus': 'all',
 'unselectable': 'on',
 'contenteditable': 'false'
 });
 dom.setStyles(ghostElm, {
 position: 'absolute',
 opacity: 0.5,
 overflow: 'hidden',
 border: 0,
 padding: 0,
 margin: 0,
 width,
 height
 });
 dom.setStyles(clonedElm, {
 margin: 0,
 boxSizing: 'border-box'
 });
 ghostElm.appendChild(clonedElm);
 return ghostElm;
 };
 const appendGhostToBody = (ghostElm, bodyElm) => {
 if (ghostElm.parentNode !== bodyElm) {
 bodyElm.appendChild(ghostElm);
 }
 };
 // Helper function needed for scrolling the editor inside moveGhost function
 const scrollEditor = (direction, amount) => (win) => () => {
 const current = direction === 'left' ? win.scrollX : win.scrollY;
 win.scroll({
 [direction]: current + amount,
 behavior: 'smooth',
 });
 };
 const scrollLeft = scrollEditor('left', -scrollPixelsPerInterval);
 const scrollRight = scrollEditor('left', scrollPixelsPerInterval);
 const scrollUp = scrollEditor('top', -scrollPixelsPerInterval);
 const scrollDown = scrollEditor('top', scrollPixelsPerInterval);
 const moveGhost = (ghostElm, position, width, height, maxX, maxY, mouseY, mouseX, contentAreaContainer, win, state, mouseEventOriginatedFromWithinTheEditor) => {
 let overflowX = 0, overflowY = 0;
 ghostElm.style.left = position.pageX + 'px';
 ghostElm.style.top = position.pageY + 'px';
 if (position.pageX + width > maxX) {
 overflowX = (position.pageX + width) - maxX;
 }
 if (position.pageY + height > maxY) {
 overflowY = (position.pageY + height) - maxY;
 }
 ghostElm.style.width = (width - overflowX) + 'px';
 ghostElm.style.height = (height - overflowY) + 'px';
 // Code needed for dragging CEF elements (specifically fixing TINY-8874)
 // The idea behind the algorithm is that the user will start dragging the
 // CEF element to the edge of the editor and that would cause scrolling.
 // The way that happens is that the user will trigger a mousedown event,
 // then a mousemove event until they reach the edge of the editor. Then
 // no event triggers. That's when I set an interval to keep scrolling the editor.
 // Once a new event triggers I clear the existing interval and set it back to none.
 const clientHeight = contentAreaContainer.clientHeight;
 const clientWidth = contentAreaContainer.clientWidth;
 const outerMouseY = mouseY + contentAreaContainer.getBoundingClientRect().top;
 const outerMouseX = mouseX + contentAreaContainer.getBoundingClientRect().left;
 state.on((state) => {
 state.intervalId.clear();
 if (state.dragging && mouseEventOriginatedFromWithinTheEditor) {
 // This basically means that the mouse is close to the bottom edge
 // (within MouseRange pixels of the bottom edge)
 if (mouseY + mouseRangeToTriggerScrollInsideEditor >= clientHeight) {
 state.intervalId.set(scrollDown(win));
 // This basically means that the mouse is close to the top edge
 // (within MouseRange pixels)
 }
 else if (mouseY - mouseRangeToTriggerScrollInsideEditor <= 0) {
 state.intervalId.set(scrollUp(win));
 // This basically means that the mouse is close to the right edge
 // (within MouseRange pixels of the right edge)
 }
 else if (mouseX + mouseRangeToTriggerScrollInsideEditor >= clientWidth) {
 state.intervalId.set(scrollRight(win));
 // This basically means that the mouse is close to the left edge
 // (within MouseRange pixels of the left edge)
 }
 else if (mouseX - mouseRangeToTriggerScrollInsideEditor <= 0) {
 state.intervalId.set(scrollLeft(win));
 // This basically means that the mouse is close to the bottom edge
 // of the page (within MouseRange pixels) when the bottom of
 // the editor is offscreen
 }
 else if (outerMouseY + mouseRangeToTriggerScrollOutsideEditor >= window.innerHeight) {
 state.intervalId.set(scrollDown(window));
 // This basically means that the mouse is close to the upper edge
 // of the page (within MouseRange pixels) when the top of
 // the editor is offscreen
 }
 else if (outerMouseY - mouseRangeToTriggerScrollOutsideEditor <= 0) {
 state.intervalId.set(scrollUp(window));
 // This basically means that the mouse is close to the right edge
 // of the page (within MouseRange pixels) when the right edge of
 // the editor is offscreen
 }
 else if (outerMouseX + mouseRangeToTriggerScrollOutsideEditor >= window.innerWidth) {
 state.intervalId.set(scrollRight(window));
 // This basically means that the mouse is close to the left edge
 // of the page (within MouseRange pixels) when the left edge of
 // the editor is offscreen
 }
 else if (outerMouseX - mouseRangeToTriggerScrollOutsideEditor <= 0) {
 state.intervalId.set(scrollLeft(window));
 }
 }
 });
 };
 const removeElement = (elm) => {
 if (elm && elm.parentNode) {
 elm.parentNode.removeChild(elm);
 }
 };
 const removeElementWithPadding = (dom, elm) => {
 const parentBlock = dom.getParent(elm.parentNode, dom.isBlock);
 removeElement(elm);
 if (parentBlock && parentBlock !== dom.getRoot() && dom.isEmpty(parentBlock)) {
 fillWithPaddingBr(SugarElement.fromDom(parentBlock));
 }
 };
 const isLeftMouseButtonPressed = (e) => e.button === 0;
 const applyRelPos = (state, position) => ({
 pageX: position.pageX - state.relX,
 pageY: position.pageY + 5
 });
 const start = (state, editor) => (e) => {
 if (isLeftMouseButtonPressed(e)) {
 const ceElm = find$2(editor.dom.getParents(e.target), isContentEditable).getOr(null);
 if (isNonNullable(ceElm) && isDraggable(editor.dom, editor.getBody(), ceElm)) {
 const elmPos = editor.dom.getPos(ceElm);
 const bodyElm = editor.getBody();
 const docElm = editor.getDoc().documentElement;
 state.set({
 element: ceElm,
 dataTransfer: createDataTransfer(),
 dragging: false,
 screenX: e.screenX,
 screenY: e.screenY,
 maxX: (editor.inline ? bodyElm.scrollWidth : docElm.offsetWidth) - 2,
 maxY: (editor.inline ? bodyElm.scrollHeight : docElm.offsetHeight) - 2,
 relX: e.pageX - elmPos.x,
 relY: e.pageY - elmPos.y,
 width: ceElm.offsetWidth,
 height: ceElm.offsetHeight,
 ghost: createGhost(editor, ceElm, ceElm.offsetWidth, ceElm.offsetHeight),
 intervalId: repeatable(scrollIntervalValue)
 });
 }
 }
 };
 const placeCaretAt = (editor, clientX, clientY) => {
 editor._selectionOverrides.hideFakeCaret();
 closestFakeCaretCandidate(editor.getBody(), clientX, clientY).fold(() => editor.selection.placeCaretAt(clientX, clientY), (caretInfo) => {
 const range = editor._selectionOverrides.showCaret(1, caretInfo.node, caretInfo.position === FakeCaretPosition.Before, false);
 if (range) {
 editor.selection.setRng(range);
 }
 else {
 editor.selection.placeCaretAt(clientX, clientY);
 }
 });
 };
 const dispatchDragEvent = (editor, type, target, dataTransfer, mouseEvent) => {
 if (type === 'dragstart') {
 setHtmlData(dataTransfer, editor.dom.getOuterHTML(target));
 }
 const event = makeDragEvent(type, target, dataTransfer, mouseEvent);
 const args = editor.dispatch(type, event);
 return args;
 };
 const move = (state, editor) => {
 // Reduces laggy drag behavior on Gecko
 const throttledPlaceCaretAt = first$1((clientX, clientY) => placeCaretAt(editor, clientX, clientY), 0);
 editor.on('remove', throttledPlaceCaretAt.cancel);
 const state_ = state;
 return (e) => state.on((state) => {
 const movement = Math.max(Math.abs(e.screenX - state.screenX), Math.abs(e.screenY - state.screenY));
 if (!state.dragging && movement > 10) {
 const args = dispatchDragEvent(editor, 'dragstart', state.element, state.dataTransfer, e);
 // TINY-9601: dataTransfer is writable in dragstart, so keep it up-to-date
 if (isNonNullable(args.dataTransfer)) {
 state.dataTransfer = args.dataTransfer;
 }
 if (args.isDefaultPrevented()) {
 return;
 }
 state.dragging = true;
 editor.focus();
 }
 if (state.dragging) {
 const mouseEventOriginatedFromWithinTheEditor = e.currentTarget === editor.getDoc().documentElement;
 const targetPos = applyRelPos(state, calc(editor, e));
 appendGhostToBody(state.ghost, editor.getBody());
 moveGhost(state.ghost, targetPos, state.width, state.height, state.maxX, state.maxY, e.clientY, e.clientX, editor.getContentAreaContainer(), editor.getWin(), state_, mouseEventOriginatedFromWithinTheEditor);
 throttledPlaceCaretAt.throttle(e.clientX, e.clientY);
 }
 });
 };
 // Returns the raw element instead of the fake cE=false element
 const getRawTarget = (selection) => {
 const sel = selection.getSel();
 if (isNonNullable(sel)) {
 const rng = sel.getRangeAt(0);
 const startContainer = rng.startContainer;
 return isText$b(startContainer) ? startContainer.parentNode : startContainer;
 }
 else {
 return null;
 }
 };
 const drop = (state, editor) => (e) => {
 state.on((state) => {
 state.intervalId.clear();
 if (state.dragging) {
 if (isValidDropTarget(editor, getRawTarget(editor.selection), state.element)) {
 const dropTarget = editor.getDoc().elementFromPoint(e.clientX, e.clientY) ?? editor.getBody();
 const args = dispatchDragEvent(editor, 'drop', dropTarget, state.dataTransfer, e);
 if (!args.isDefaultPrevented()) {
 editor.undoManager.transact(() => {
 removeElementWithPadding(editor.dom, state.element);
 // TINY-9601: Use dataTransfer property to determine inserted content on drop. This allows users to
 // manipulate drop content by modifying dataTransfer in the dragstart event.
 getHtmlData(state.dataTransfer).each((content) => editor.insertContent(content));
 editor._selectionOverrides.hideFakeCaret();
 });
 }
 }
 // Use body as the target since the element we are dragging no longer exists. Native drag/drop works in a similar way.
 dispatchDragEvent(editor, 'dragend', editor.getBody(), state.dataTransfer, e);
 }
 });
 removeDragState(state);
 };
 const stopDragging = (state, editor, e) => {
 state.on((state) => {
 state.intervalId.clear();
 if (state.dragging) {
 e.fold(() => dispatchDragEvent(editor, 'dragend', state.element, state.dataTransfer), (mouseEvent) => dispatchDragEvent(editor, 'dragend', state.element, state.dataTransfer, mouseEvent));
 }
 });
 removeDragState(state);
 };
 const stop = (state, editor) => (e) => stopDragging(state, editor, Optional.some(e));
 const removeDragState = (state) => {
 state.on((state) => {
 state.intervalId.clear();
 removeElement(state.ghost);
 });
 state.clear();
 };
 const bindFakeDragEvents = (editor) => {
 const state = value$1();
 const pageDom = DOMUtils.DOM;
 const rootDocument = document;
 const dragStartHandler = start(state, editor);
 const dragHandler = move(state, editor);
 const dropHandler = drop(state, editor);
 const dragEndHandler = stop(state, editor);
 editor.on('mousedown', dragStartHandler);
 editor.on('mousemove', dragHandler);
 editor.on('mouseup', dropHandler);
 pageDom.bind(rootDocument, 'mousemove', dragHandler);
 pageDom.bind(rootDocument, 'mouseup', dragEndHandler);
 editor.on('remove', () => {
 pageDom.unbind(rootDocument, 'mousemove', dragHandler);
 pageDom.unbind(rootDocument, 'mouseup', dragEndHandler);
 });
 editor.on('keydown', (e) => {
 // Fire 'dragend' when the escape key is pressed
 if (e.keyCode === VK.ESC) {
 stopDragging(state, editor, Optional.none());
 }
 });
 };
 // Block files being dropped within the editor to prevent accidentally navigating away
 // while editing. Note that we can't use the `editor.on` API here, as we want these
 // to run after the editor event handlers have run. We also bind to the document
 // so that it'll try to ensure it's the last thing that runs, as it bubbles up the dom.
 const blockUnsupportedFileDrop = (editor) => {
 const preventFileDrop = (e) => {
 if (!e.isDefaultPrevented()) {
 // Prevent file drop events within the editor, as they'll cause the browser to navigate away
 const dataTransfer = e.dataTransfer;
 if (dataTransfer && (contains$2(dataTransfer.types, 'Files') || dataTransfer.files.length > 0)) {
 e.preventDefault();
 if (e.type === 'drop') {
 displayError(editor, 'Dropped file type is not supported');
 }
 }
 }
 };
 const preventFileDropIfUIElement = (e) => {
 if (isUIElement(editor, e.target)) {
 preventFileDrop(e);
 }
 };
 const setup = () => {
 const pageDom = DOMUtils.DOM;
 const dom = editor.dom;
 const doc = document;
 const editorRoot = editor.inline ? editor.getBody() : editor.getDoc();
 const eventNames = ['drop', 'dragover'];
 each$e(eventNames, (name) => {
 pageDom.bind(doc, name, preventFileDropIfUIElement);
 dom.bind(editorRoot, name, preventFileDrop);
 });
 editor.on('remove', () => {
 each$e(eventNames, (name) => {
 pageDom.unbind(doc, name, preventFileDropIfUIElement);
 dom.unbind(editorRoot, name, preventFileDrop);
 });
 });
 };
 editor.on('init', () => {
 // Use a timeout to ensure this fires after all other init callbacks
 Delay.setEditorTimeout(editor, setup, 0);
 });
 };
 const init$2 = (editor) => {
 bindFakeDragEvents(editor);
 if (shouldBlockUnsupportedDrop(editor)) {
 blockUnsupportedFileDrop(editor);
 }
 };

const setup$1 = (editor) => {
        setup$2(editor);
    };

class ComponentLoadError extends Error {
        url;
        constructor(message, url) {
            super(message);
            this.url = url;
        }
    }
    const hostWindowComponentScripts = {};
    const loadScript = (url, doc, extraAtts) => {
        return new Promise((resolve, reject) => {
            const script = SugarElement.fromTag('script');
            setAll$1(script, {
                type: 'text/javascript',
                src: url,
                ...extraAtts
            });
            const clean = () => {
                remove$8(script);
            };
            bind$1(script, 'load', () => {
                clean();
                resolve();
            });
            bind$1(script, 'error', () => {
                clean();
                reject(new Error(`Failed to load script url: ${url}`));
            });
            append$1(getHead(doc), script);
        });
    };
    const loadComponent = async (url, doc) => {
        const extraAtts = ScriptLoader.ScriptLoader.getScriptAttributes(url);
        await loadScript(url, doc, extraAtts).catch(() => Promise.reject(new ComponentLoadError(`Failed to load component url: ${url}`, url)));
        return url;
    };
    const loadComponentsForInlineEditor = (componentUrls) => {
        return mapToArray(componentUrls, (url, elementName) => {
            return get$a(hostWindowComponentScripts, url).getOrThunk(() => {
                // Only load the component if it hasn't already been loaded in inline mode the page might have already loaded it
                if (isNullable(window.customElements.get(elementName))) {
                    const loadPromise = loadComponent(url, getDocument());
                    hostWindowComponentScripts[url] = loadPromise;
                    return loadPromise;
                }
                else {
                    return Promise.resolve(url);
                }
            }).catch((err) => {
                // Remove from cache if the component failed to load so we can try again later
                delete hostWindowComponentScripts[url];
                return Promise.reject(err);
            });
        });
    };
    const loadComponentsForIframeEditor = (componentUrls, doc) => {
        const urls = unique$1(values(componentUrls));
        return map$3(urls, (url) => loadComponent(url, SugarElement.fromDom(doc)));
    };
    const loadComponentsForEditor = (editor) => {
        const componentUrls = editor.schema.getComponentUrls();
        if (editor.inline) {
            return loadComponentsForInlineEditor(componentUrls);
        }
        else {
            return loadComponentsForIframeEditor(componentUrls, editor.getDoc());
        }
    };
    const loadComponentsAsync = async (editor) => {
        const loadPromises = loadComponentsForEditor(editor);
        const rejected = filter$5(await Promise.allSettled(loadPromises), (r) => r.status === 'rejected');
        if (rejected.length > 0) {
            each$e(rejected, (rejection) => {
                if (rejection.reason instanceof ComponentLoadError) {
                    const { url } = rejection.reason;
                    componentLoadError(editor, url);
                }
            });
        }
    };
    const loadComponents = (editor) => {
        // Since we are handling the errors in the promise rejections inside the loadComponentsAsync we can ignore the errors here
        // eslint-disable-next-line @typescript-eslint/no-floating-promises
        loadComponentsAsync(editor);
    };

const addVisual = (editor, elm) => addVisual$1(editor, elm);

const findFirstCaretElement = (editor) => firstPositionIn(editor.getBody())
        .bind((caret) => {
        const container = caret.container();
        return Optional.from(isText$b(container) ? container.parentNode : container);
    });
    const getCaretElement = (editor) => Optional.from(editor.selection.getRng())
        .bind((rng) => {
        const root = editor.getBody();
        const atStartOfNode = rng.startContainer === root && rng.startOffset === 0;
        return atStartOfNode ? Optional.none() : Optional.from(editor.selection.getStart(true));
    });
    const bindRange = (editor, binder) => getCaretElement(editor)
        .orThunk(curry(findFirstCaretElement, editor))
        .map(SugarElement.fromDom)
        .filter(isElement$8)
        .bind(binder);
    const mapRange = (editor, mapper) => bindRange(editor, compose1(Optional.some, mapper));

// List of commands that are considered safe even if the editor has no selection when the iframe is hidden in Firefox. See TINY-9210 for details.
    const selectionSafeCommands = ['toggleview'];
    const isSelectionSafeCommand = (command) => contains$2(selectionSafeCommands, command.toLowerCase());
    class EditorCommands {
        editor;
        commands = { state: {}, exec: {}, value: {} };
        constructor(editor) {
            this.editor = editor;
        }
        /**
         * Executes a registered command on the current instance. A list of available commands can be found in
         * the tinymce command identifiers documentation.
         *
         * @method execCommand
         * @param {String} command Command name to execute, for example mceLink or Bold.
         * @param {Boolean} ui Specifies if a UI (dialog) should be presented or not.
         * @param {Object/Array/String/Number/Boolean} value Optional command value, this can be anything.
         * @param {Object} args Optional arguments object.
         * @return {Boolean} true or false if the command was supported or not.
         */
        execCommand(command, ui = false, value, args) {
            const editor = this.editor;
            const lowerCaseCommand = command.toLowerCase();
            const skipFocus = args?.skip_focus;
            if (editor.removed) {
                return false;
            }
            if (lowerCaseCommand !== 'mcefocus') {
                if (!/^(mceAddUndoLevel|mceEndUndoLevel)$/i.test(lowerCaseCommand) && !skipFocus) {
                    editor.focus();
                }
                else {
                    restore(editor);
                }
            }
            const eventArgs = editor.dispatch('BeforeExecCommand', { command, ui, value });
            if (eventArgs.isDefaultPrevented()) {
                return false;
            }
            const func = this.commands.exec[lowerCaseCommand];
            if (isFunction(func)) {
                func(lowerCaseCommand, ui, value, args);
                editor.dispatch('ExecCommand', { command, ui, value, args });
                return true;
            }
            return false;
        }
        /**
         * Queries the current state for a command. For example: If the current selection is "bold".
         *
         * @method queryCommandState
         * @param {String} command Command to check the state of.
         * @return {Boolean} true/false - For example: If the selected contents is bold or not.
         */
        queryCommandState(command) {
            if ((!isSelectionSafeCommand(command) && this.editor.quirks.isHidden()) || this.editor.removed) {
                return false;
            }
            const lowerCaseCommand = command.toLowerCase();
            const func = this.commands.state[lowerCaseCommand];
            if (isFunction(func)) {
                return func(lowerCaseCommand);
            }
            return false;
        }
        /**
         * Returns a command specific value, for example the current font size.
         *
         * @method queryCommandValue
         * @param {String} command Command to query value from.
         * @return {String} Command value, for example the current font size or an empty string (`""`) if the query command is not found.
         */
        queryCommandValue(command) {
            if ((!isSelectionSafeCommand(command) && this.editor.quirks.isHidden()) || this.editor.removed) {
                return '';
            }
            const lowerCaseCommand = command.toLowerCase();
            const func = this.commands.value[lowerCaseCommand];
            if (isFunction(func)) {
                return func(lowerCaseCommand);
            }
            return '';
        }
        addCommands(commandList, type = 'exec') {
            const commands = this.commands;
            each$d(commandList, (callback, command) => {
                each$e(command.toLowerCase().split(','), (command) => {
                    commands[type][command] = callback;
                });
            });
        }
        addCommand(command, callback, scope) {
            const lowerCaseCommand = command.toLowerCase();
            this.commands.exec[lowerCaseCommand] = (_command, ui, value, args) => callback.call(scope ?? this.editor, ui, value, args);
        }
        /**
         * Removes a command from the command collection.
         *
         * @method removeCommand
         * @param {String} command Command name to remove.
         * @param {String} type Optional type to remove, defaults to removing all types. Can be 'exec', 'state', 'value', or omitted for all.
         */
        removeCommand(command, type) {
            const lowerCaseCommand = command.toLowerCase();
            if (type) {
                delete this.commands[type][lowerCaseCommand];
            }
            else {
                delete this.commands.exec[lowerCaseCommand];
                delete this.commands.state[lowerCaseCommand];
                delete this.commands.value[lowerCaseCommand];
            }
        }
        /**
         * Returns true/false if the command is supported or not.
         *
         * @method queryCommandSupported
         * @param {String} command Command that we check support for.
         * @return {Boolean} true/false if the command is supported or not.
         */
        queryCommandSupported(command) {
            const lowerCaseCommand = command.toLowerCase();
            if (this.commands.exec[lowerCaseCommand]) {
                return true;
            }
            else {
                return false;
            }
        }
        addQueryStateHandler(command, callback, scope) {
            this.commands.state[command.toLowerCase()] = () => callback.call(scope ?? this.editor);
        }
        addQueryValueHandler(command, callback, scope) {
            this.commands.value[command.toLowerCase()] = () => callback.call(scope ?? this.editor);
        }
    }

/**
 * This class lets you add/remove and dispatch events by name on the specified scope. This makes
 * it easy to add event listener logic to any class.
 *
 * @class tinymce.util.EventDispatcher
 * @example
 * const eventDispatcher = new EventDispatcher();
 *
 * eventDispatcher.on('click', () => console.log('data'));
 * eventDispatcher.dispatch('click', { data: 123 });
 */
 const nativeEvents = Tools.makeMap('focus blur focusin focusout click dblclick mousedown mouseup mousemove mouseover beforepaste paste cut copy selectionchange ' +
 'mouseout mouseenter mouseleave wheel keydown keypress keyup input beforeinput contextmenu dragstart dragend dragover ' +
 'draggesture dragdrop drop drag submit ' +
 'compositionstart compositionend compositionupdate touchstart touchmove touchend touchcancel', ' ');
 class EventDispatcher {
 /**
 * Returns true/false if the specified event name is a native browser event or not.
 *
 * @method isNative
 * @param {String} name Name to check if it's native.
 * @return {Boolean} true/false if the event is native or not.
 * @static
 */
 static isNative(name) {
 return !!nativeEvents[name.toLowerCase()];
 }
 settings;
 scope;
 toggleEvent;
 bindings = {};
 constructor(settings) {
 this.settings = settings || {};
 this.scope = this.settings.scope || this;
 this.toggleEvent = this.settings.toggleEvent || never;
 }
 /**
 * Fires the specified event by name.
 * 
 * Marked for removal in TinyMCE 8.0. Use <code>dispatch</code> instead.
 *
 * @method fire
 * @param {String} name Name of the event to fire.
 * @param {Object?} args Event arguments.
 * @return {Object} Event args instance passed in.
 * @deprecated Use dispatch() instead
 * @example
 * instance.fire('event', {...});
 */
 fire(name, args) {
 return this.dispatch(name, args);
 }
 /**
 * Dispatches the specified event by name.
 *
 * @method dispatch
 * @param {String} name Name of the event to dispatch
 * @param {Object?} args Event arguments.
 * @return {Object} Event args instance passed in.
 * @example
 * instance.dispatch('event', {...});
 */
 dispatch(name, args) {
 const lcName = name.toLowerCase();
 const event = normalize$3(lcName, args ?? {}, this.scope);
 if (this.settings.beforeFire) {
 this.settings.beforeFire(event);
 }
 // Don't clone the array here as this is a hot code path, so instead the handlers
 // array is recreated and the this.bindings[name] reference is updated in the `on`
 // and `off` functions. This is done to avoid the handlers array being mutated while
 // we're iterating over it below.
 const handlers = this.bindings[lcName];
 if (handlers) {
 for (let i = 0, l = handlers.length; i < l; i++) {
 const callback = handlers[i];
 // The handler was removed by an earlier handler in this loop so skip it.
 if (callback.removed) {
 continue;
 }
 // Unbind handlers marked with "once"
 if (callback.once) {
 this.off(lcName, callback.func);
 }
 // Stop immediate propagation if needed
 if (event.isImmediatePropagationStopped()) {
 return event;
 }
 // If callback returns false then prevent default and stop all propagation
 if (callback.func.call(this.scope, event) === false) {
 event.preventDefault();
 return event;
 }
 }
 }
 return event;
 }
 /**
 * Binds an event listener to a specific event by name.
 *
 * @method on
 * @param {String} name Event name or space separated list of events to bind.
 * @param {Function} callback Callback to be executed when the event occurs.
 * @param {Boolean} prepend Optional flag if the event should be prepended. Use this with care.
 * @return {Object} Current class instance.
 * @example
 * instance.on('event', (e) => {
 * // Callback logic
 * });
 */
 on(name, callback, prepend, extra) {
 if (callback === false) {
 callback = never;
 }
 if (callback) {
 const wrappedCallback = {
 func: callback,
 removed: false
 };
 if (extra) {
 Tools.extend(wrappedCallback, extra);
 }
 const names = name.toLowerCase().split(' ');
 let i = names.length;
 while (i--) {
 const currentName = names[i];
 let handlers = this.bindings[currentName];
 if (!handlers) {
 handlers = [];
 this.toggleEvent(currentName, true);
 }
 if (prepend) {
 handlers = [wrappedCallback, ...handlers];
 }
 else {
 handlers = [...handlers, wrappedCallback];
 }
 this.bindings[currentName] = handlers;
 }
 }
 return this;
 }
 /**
 * Unbinds an event listener to a specific event by name.
 *
 * @method off
 * @param {String?} name Name of the event to unbind.
 * @param {Function?} callback Callback to unbind.
 * @return {Object} Current class instance.
 * @example
 * // Unbind specific callback
 * instance.off('event', handler);
 *
 * // Unbind all listeners by name
 * instance.off('event');
 *
 * // Unbind all events
 * instance.off();
 */
 off(name, callback) {
 if (name) {
 const names = name.toLowerCase().split(' ');
 let i = names.length;
 while (i--) {
 const currentName = names[i];
 let handlers = this.bindings[currentName];
 // Unbind all handlers
 if (!currentName) {
 each$d(this.bindings, (_value, bindingName) => {
 this.toggleEvent(bindingName, false);
 delete this.bindings[bindingName];
 });
 return this;
 }
 if (handlers) {
 // Unbind all by name
 if (!callback) {
 handlers.length = 0;
 }
 else {
 // Unbind specific handlers
 const filteredHandlers = partition$2(handlers, (handler) => handler.func === callback);
 handlers = filteredHandlers.fail;
 this.bindings[currentName] = handlers;
 // Mark the removed handlers in case this event is already being processed in `fire`
 each$e(filteredHandlers.pass, (handler) => {
 handler.removed = true;
 });
 }
 if (!handlers.length) {
 this.toggleEvent(name, false);
 delete this.bindings[currentName];
 }
 }
 }
 }
 else {
 each$d(this.bindings, (_value, name) => {
 this.toggleEvent(name, false);
 });
 this.bindings = {};
 }
 return this;
 }
 /**
 * Binds an event listener to a specific event by name
 * and automatically unbind the event once the callback fires.
 *
 * @method once
 * @param {String} name Event name or space separated list of events to bind.
 * @param {Function} callback Callback to be executed when the event occurs.
 * @param {Boolean} prepend Optional flag if the event should be prepended. Use this with care.
 * @return {Object} Current class instance.
 * @example
 * instance.once('event', (e) => {
 * // Callback logic
 * });
 */
 once(name, callback, prepend) {
 return this.on(name, callback, prepend, { once: true });
 }
 /**
 * Returns true/false if the dispatcher has a event of the specified name.
 *
 * @method has
 * @param {String} name Name of the event to check for.
 * @return {Boolean} true/false if the event exists or not.
 */
 has(name) {
 name = name.toLowerCase();
 const binding = this.bindings[name];
 return !(!binding || binding.length === 0);
 }
 }

/**
 * This mixin adds event binding logic to classes. Adapts the EventDispatcher class.
 *
 * @mixin tinymce.util.Observable
 */
 const getEventDispatcher = (obj) => {
 if (!obj._eventDispatcher) {
 obj._eventDispatcher = new EventDispatcher({
 scope: obj,
 toggleEvent: (name, state) => {
 if (EventDispatcher.isNative(name) && obj.toggleNativeEvent) {
 obj.toggleNativeEvent(name, state);
 }
 }
 });
 }
 return obj._eventDispatcher;
 };
 const Observable = {
 /**
 * Fires the specified event by name. Consult the
 * <a href="https://www.tiny.cloud/docs/tinymce/8/events/">event reference</a> for more details on each event.
 * 
 * Deprecated in TinyMCE 6.0 and has been marked for removal in TinyMCE 9.0. Use <code>dispatch</code> instead.
 *
 * @method fire
 * @param {String} name Name of the event to fire.
 * @param {Object?} args Event arguments.
 * @param {Boolean?} bubble True/false if the event is to be bubbled.
 * @return {Object} Event args instance passed in.
 * @deprecated Use dispatch() instead
 * @example
 * instance.fire('event', {...});
 */
 fire(name, args, bubble) {
 logFeatureDeprecationWarning('fire');
 return this.dispatch(name, args, bubble);
 },
 /**
 * Dispatches the specified event by name. Consult the
 * <a href="https://www.tiny.cloud/docs/tinymce/8/events/">event reference</a> for more details on each event.
 *
 * @method dispatch
 * @param {String} name Name of the event to dispatch.
 * @param {Object?} args Event arguments.
 * @param {Boolean?} bubble True/false if the event is to be bubbled.
 * @return {Object} Event args instance passed in.
 * @example
 * instance.dispatch('event', {...});
 */
 dispatch(name, args, bubble) {
 const self = this;
 // Prevent all events except the remove/detach event after the instance has been removed
 if (self.removed && name !== 'remove' && name !== 'detach') {
 return normalize$3(name.toLowerCase(), args ?? {}, self);
 }
 const dispatcherArgs = getEventDispatcher(self).dispatch(name, args);
 // Bubble event up to parents
 if (bubble !== false && self.parent) {
 let parent = self.parent();
 while (parent && !dispatcherArgs.isPropagationStopped()) {
 parent.dispatch(name, dispatcherArgs, false);
 parent = parent.parent ? parent.parent() : undefined;
 }
 }
 return dispatcherArgs;
 },
 /**
 * Binds an event listener to a specific event by name. Consult the
 * <a href="https://www.tiny.cloud/docs/tinymce/8/events/">event reference</a> for more details on each event.
 *
 * @method on
 * @param {String} name Event name or space separated list of events to bind.
 * @param {Function} callback Callback to be executed when the event occurs.
 * @param {Boolean} prepend Optional flag if the event should be prepended. Use this with care.
 * @return {Object} Current class instance.
 * @example
 * instance.on('event', (e) => {
 * // Callback logic
 * });
 */
 on(name, callback, prepend) {
 return getEventDispatcher(this).on(name, callback, prepend);
 },
 /**
 * Unbinds an event listener to a specific event by name. Consult the
 * <a href="https://www.tiny.cloud/docs/tinymce/8/events/">event reference</a> for more details on each event.
 *
 * @method off
 * @param {String?} name Name of the event to unbind.
 * @param {Function?} callback Callback to unbind.
 * @return {Object} Current class instance.
 * @example
 * // Unbind specific callback
 * instance.off('event', handler);
 *
 * // Unbind all listeners by name
 * instance.off('event');
 *
 * // Unbind all events
 * instance.off();
 */
 off(name, callback) {
 return getEventDispatcher(this).off(name, callback);
 },
 /**
 * Bind the event callback and once it fires the callback is removed. Consult the
 * <a href="https://www.tiny.cloud/docs/tinymce/8/events/">event reference</a> for more details on each event.
 *
 * @method once
 * @param {String} name Name of the event to bind.
 * @param {Function} callback Callback to bind only once.
 * @return {Object} Current class instance.
 */
 once(name, callback) {
 return getEventDispatcher(this).once(name, callback);
 },
 /**
 * Returns true/false if the object has a event of the specified name.
 *
 * @method hasEventListeners
 * @param {String} name Name of the event to check for.
 * @return {Boolean} true/false if the event exists or not.
 */
 hasEventListeners(name) {
 return getEventDispatcher(this).has(name);
 }
 };

/**
     * This mixin contains the event logic for the tinymce.Editor class.
     *
     * @mixin tinymce.EditorObservable
     * @extends tinymce.util.Observable
     * @private
     */
    const DOM$2 = DOMUtils.DOM;
    let customEventRootDelegates;
    /**
     * Returns the event target for the specified event. Some events fire
     * only on document, some fire on documentElement etc. This also handles the
     * custom event root setting where it returns that element instead of the body.
     *
     * @private
     * @param {tinymce.Editor} editor Editor instance to get event target from.
     * @param {String} eventName Name of the event for example "click".
     * @return {Element/Document} HTML Element or document target to bind on.
     */
    const getEventTarget = (editor, eventName) => {
        if (eventName === 'selectionchange') {
            return editor.getDoc();
        }
        // Need to bind mousedown/mouseup etc to document not body in iframe mode
        // Since the user might click on the HTML element not the BODY
        if (!editor.inline && /^(?:mouse|touch|click|contextmenu|drop|dragover|dragend)/.test(eventName)) {
            return editor.getDoc().documentElement;
        }
        // Bind to event root instead of body if it's defined
        const eventRoot = getEventRoot(editor);
        if (eventRoot) {
            if (!editor.eventRoot) {
                editor.eventRoot = DOM$2.select(eventRoot)[0];
            }
            return editor.eventRoot;
        }
        return editor.getBody();
    };
    const isListening = (editor) => !editor.hidden && !isDisabled(editor);
    const fireEvent = (editor, eventName, e) => {
        if (isListening(editor)) {
            editor.dispatch(eventName, e);
        }
        else if (isDisabled(editor)) {
            processDisabledEvents(editor, e);
        }
    };
    /**
     * Binds a event delegate for the specified name this delegate will fire
     * the event to the editor dispatcher.
     *
     * @private
     * @param {tinymce.Editor} editor Editor instance to get event target from.
     * @param {String} eventName Name of the event for example "click".
     */
    const bindEventDelegate = (editor, eventName) => {
        if (!editor.delegates) {
            editor.delegates = {};
        }
        if (editor.delegates[eventName] || editor.removed) {
            return;
        }
        const eventRootElm = getEventTarget(editor, eventName);
        if (getEventRoot(editor)) {
            if (!customEventRootDelegates) {
                customEventRootDelegates = {};
                editor.editorManager.on('removeEditor', () => {
                    if (!editor.editorManager.activeEditor) {
                        if (customEventRootDelegates) {
                            each$d(customEventRootDelegates, (_value, name) => {
                                editor.dom.unbind(getEventTarget(editor, name));
                            });
                            customEventRootDelegates = null;
                        }
                    }
                });
            }
            if (customEventRootDelegates[eventName]) {
                return;
            }
            const delegate = (e) => {
                const target = e.target;
                const editors = editor.editorManager.get();
                let i = editors.length;
                while (i--) {
                    const body = editors[i].getBody();
                    if (body === target || DOM$2.isChildOf(target, body)) {
                        fireEvent(editors[i], eventName, e);
                    }
                }
            };
            customEventRootDelegates[eventName] = delegate;
            DOM$2.bind(eventRootElm, eventName, delegate);
        }
        else {
            const delegate = (e) => {
                fireEvent(editor, eventName, e);
            };
            DOM$2.bind(eventRootElm, eventName, delegate);
            editor.delegates[eventName] = delegate;
        }
    };
    const EditorObservable = {
        ...Observable,
        /**
         * Bind any pending event delegates. This gets executed after the target body/document is created.
         *
         * @private
         */
        bindPendingEventDelegates() {
            const self = this;
            Tools.each(self._pendingNativeEvents, (name) => {
                bindEventDelegate(self, name);
            });
        },
        /**
         * Toggles a native event on/off this is called by the EventDispatcher when
         * the first native event handler is added and when the last native event handler is removed.
         *
         * @private
         */
        toggleNativeEvent(name, state) {
            const self = this;
            // Never bind focus/blur since the FocusManager fakes those
            if (name === 'focus' || name === 'blur') {
                return;
            }
            // If the editor has been removed, `unbindAllNativeEvents` has already deleted all native event delegates
            if (self.removed) {
                return;
            }
            if (state) {
                if (self.initialized) {
                    bindEventDelegate(self, name);
                }
                else {
                    if (!self._pendingNativeEvents) {
                        self._pendingNativeEvents = [name];
                    }
                    else {
                        self._pendingNativeEvents.push(name);
                    }
                }
            }
            else if (self.initialized && self.delegates) {
                self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
                delete self.delegates[name];
            }
        },
        /**
         * Unbinds all native event handlers that means delegates, custom events bound using the Events API etc.
         *
         * @private
         */
        unbindAllNativeEvents() {
            const self = this;
            const body = self.getBody();
            const dom = self.dom;
            if (self.delegates) {
                each$d(self.delegates, (value, name) => {
                    self.dom.unbind(getEventTarget(self, name), name, value);
                });
                delete self.delegates;
            }
            if (!self.inline && body && dom) {
                body.onload = null;
                dom.unbind(self.getWin());
                dom.unbind(self.getDoc());
            }
            if (dom) {
                dom.unbind(body);
                dom.unbind(self.getContainer());
            }
        }
    };

// A string array allows comma/space separated values as well for ease of use
    const stringListProcessor = (value) => {
        if (isString(value)) {
            return { value: value.split(/[ ,]/), valid: true };
        }
        else if (isArrayOf(value, isString)) {
            return { value, valid: true };
        }
        else {
            return { valid: false, message: `The value must be a string[] or a comma/space separated string.` };
        }
    };
    const getBuiltInProcessor = (type) => {
        const validator = (() => {
            switch (type) {
                case 'array':
                    return isArray$1;
                case 'boolean':
                    return isBoolean;
                case 'function':
                    return isFunction;
                case 'number':
                    return isNumber;
                case 'object':
                    return isObject;
                case 'string':
                    return isString;
                case 'string[]':
                    return stringListProcessor;
                case 'object[]':
                    return (val) => isArrayOf(val, isObject);
                case 'regexp':
                    return (val) => is$5(val, RegExp);
                default:
                    return always;
            }
        })();
        return (value) => processValue(value, validator, `The value must be a ${type}.`);
    };
    const isBuiltInSpec = (spec) => isString(spec.processor);
    const getErrorMessage = (message, result) => {
        const additionalText = isEmpty$5(result.message) ? '' : `. ${result.message}`;
        return message + additionalText;
    };
    const isValidResult = (result) => result.valid;
    const processValue = (value, processor, message = '') => {
        const result = processor(value);
        if (isBoolean(result)) {
            // Note: Need to cast here as if a boolean is returned then we're guaranteed to be returning the same value
            return result ? { value: value, valid: true } : { valid: false, message };
        }
        else {
            return result;
        }
    };
    const processDefaultValue = (name, defaultValue, processor) => {
        if (!isUndefined(defaultValue)) {
            const result = processValue(defaultValue, processor);
            if (isValidResult(result)) {
                return result.value;
            }
            else {
                // eslint-disable-next-line no-console
                console.error(getErrorMessage(`Invalid default value passed for the "${name}" option`, result));
            }
        }
        return undefined;
    };
    const create$4 = (editor, initialOptions, rawInitialOptions = initialOptions) => {
        const registry = {};
        const values = {};
        const setValue = (name, value, processor) => {
            const result = processValue(value, processor);
            if (isValidResult(result)) {
                values[name] = result.value;
                return true;
            }
            else {
                // eslint-disable-next-line no-console
                console.warn(getErrorMessage(`Invalid value passed for the ${name} option`, result));
                return false;
            }
        };
        const register = (name, spec) => {
            const processor = isBuiltInSpec(spec) ? getBuiltInProcessor(spec.processor) : spec.processor;
            // Process and validate the default value
            const defaultValue = processDefaultValue(name, spec.default, processor);
            // Register the spec with the validated default and normalized processor
            registry[name] = {
                ...spec,
                default: defaultValue,
                processor
            };
            // Setup the initial values
            const initValue = get$a(values, name).orThunk(() => get$a(initialOptions, name));
            initValue.each((value) => setValue(name, value, processor));
        };
        const isRegistered = (name) => has$2(registry, name);
        const get = (name) => get$a(values, name)
            .orThunk(() => get$a(registry, name).map((spec) => spec.default))
            .getOrUndefined();
        const set = (name, value) => {
            if (!isRegistered(name)) {
                // eslint-disable-next-line no-console
                console.warn(`"${name}" is not a registered option. Ensure the option has been registered before setting a value.`);
                return false;
            }
            else {
                const spec = registry[name];
                if (spec.immutable) {
                    // eslint-disable-next-line no-console
                    console.error(`"${name}" is an immutable option and cannot be updated`);
                    return false;
                }
                else {
                    return setValue(name, value, spec.processor);
                }
            }
        };
        const unset = (name) => {
            const registered = isRegistered(name);
            if (registered) {
                delete values[name];
            }
            return registered;
        };
        const isSet = (name) => has$2(values, name);
        const debug = () => {
            try {
                // eslint-disable-next-line no-console
                console.log(JSON.parse(JSON.stringify(rawInitialOptions, (_key, value) => {
                    if (isBoolean(value) ||
                        isNumber(value) ||
                        isString(value) ||
                        isNull(value) ||
                        isArray$1(value) ||
                        isPlainObject(value)) {
                        return value;
                    }
                    return Object.prototype.toString.call(value);
                })));
            }
            catch (error) {
                // eslint-disable-next-line no-console
                console.error(error);
            }
        };
        return {
            register,
            isRegistered,
            get,
            set,
            unset,
            isSet,
            debug,
        };
    };

/**
 * Contains logic for handling keyboard shortcuts.
 *
 * @class tinymce.Shortcuts
 * @example
 * editor.shortcuts.add('ctrl+a', 'description of the shortcut', () => {});
 * editor.shortcuts.add('ctrl+alt+a', 'description of the shortcut', () => {});
 * // "meta" maps to Command on Mac and Ctrl on PC
 * editor.shortcuts.add('meta+a', 'description of the shortcut', () => {});
 * // "access" maps to Control+Option on Mac and shift+alt on PC
 * editor.shortcuts.add('access+a', 'description of the shortcut', () => {});
 *
 * editor.shortcuts.add('meta+access+c', 'Opens the code editor dialog.', () => {
 * editor.execCommand('mceCodeEditor');
 * });
 *
 * editor.shortcuts.add('meta+shift+32', 'Inserts "Hello, World!" for meta+shift+space', () => {
 * editor.execCommand('mceInsertContent', false, 'Hello, World!');
 * });
 */
 const each$2 = Tools.each, explode = Tools.explode;
 const keyCodeLookup = {
 f1: 112,
 f2: 113,
 f3: 114,
 f4: 115,
 f5: 116,
 f6: 117,
 f7: 118,
 f8: 119,
 f9: 120,
 f10: 121,
 f11: 122,
 f12: 123
 };
 const modifierNames = Tools.makeMap('alt,ctrl,shift,meta,access');
 const isModifier = (key) => key in modifierNames;
 const parseShortcut = (pattern) => {
 const shortcut = {};
 const isMac = Env.os.isMacOS() || Env.os.isiOS();
 // Parse modifiers and keys ctrl+alt+b for example
 each$2(explode(pattern.toLowerCase(), '+'), (value) => {
 if (isModifier(value)) {
 shortcut[value] = true;
 }
 else {
 // Allow numeric keycodes like ctrl+219 for ctrl+[
 if (/^[0-9]{2,}$/.test(value)) {
 shortcut.keyCode = parseInt(value, 10);
 }
 else {
 shortcut.charCode = value.charCodeAt(0);
 shortcut.keyCode = keyCodeLookup[value] || value.toUpperCase().charCodeAt(0);
 }
 }
 });
 // Generate unique id for modifier combination and set default state for unused modifiers
 const id = [shortcut.keyCode];
 let key;
 for (key in modifierNames) {
 if (shortcut[key]) {
 id.push(key);
 }
 else {
 shortcut[key] = false;
 }
 }
 shortcut.id = id.join(',');
 // Handle special access modifier differently depending on Mac/Win
 if (shortcut.access) {
 shortcut.alt = true;
 if (isMac) {
 shortcut.ctrl = true;
 }
 else {
 shortcut.shift = true;
 }
 }
 // Handle special meta modifier differently depending on Mac/Win
 if (shortcut.meta) {
 if (isMac) {
 shortcut.meta = true;
 }
 else {
 shortcut.ctrl = true;
 shortcut.meta = false;
 }
 }
 return shortcut;
 };
 class Shortcuts {
 editor;
 shortcuts = {};
 pendingPatterns = [];
 constructor(editor) {
 this.editor = editor;
 const self = this;
 editor.on('keyup keypress keydown', (e) => {
 if ((self.hasModifier(e) || self.isFunctionKey(e)) && !e.isDefaultPrevented()) {
 each$2(self.shortcuts, (shortcut) => {
 if (self.matchShortcut(e, shortcut)) {
 self.pendingPatterns = shortcut.subpatterns.slice(0);
 if (e.type === 'keydown') {
 self.executeShortcutAction(shortcut);
 }
 }
 });
 if (self.matchShortcut(e, self.pendingPatterns[0])) {
 if (self.pendingPatterns.length === 1) {
 if (e.type === 'keydown') {
 self.executeShortcutAction(self.pendingPatterns[0]);
 }
 }
 self.pendingPatterns.shift();
 }
 }
 });
 }
 /**
 * Adds a keyboard shortcut for some command or function.
 *
 * @method add
 * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
 * @param {String} desc Text description for the command.
 * @param {String/Function} cmdFunc Command name string or function to execute when the key is pressed.
 * @param {Object} scope Optional scope to execute the function in.
 * @return {Boolean} true/false state if the shortcut was added or not.
 */
 add(pattern, desc, cmdFunc, scope) {
 const self = this;
 const func = self.normalizeCommandFunc(cmdFunc);
 each$2(explode(Tools.trim(pattern)), (pattern) => {
 const shortcut = self.createShortcut(pattern, desc, func, scope);
 self.shortcuts[shortcut.id] = shortcut;
 });
 return true;
 }
 /**
 * Remove a keyboard shortcut by pattern.
 *
 * @method remove
 * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
 * @return {Boolean} true/false state if the shortcut was removed or not.
 */
 remove(pattern) {
 const shortcut = this.createShortcut(pattern);
 if (this.shortcuts[shortcut.id]) {
 delete this.shortcuts[shortcut.id];
 return true;
 }
 return false;
 }
 normalizeCommandFunc(cmdFunc) {
 const self = this;
 const cmd = cmdFunc;
 if (typeof cmd === 'string') {
 return () => {
 self.editor.execCommand(cmd, false, null);
 };
 }
 else if (Tools.isArray(cmd)) {
 return () => {
 self.editor.execCommand(cmd[0], cmd[1], cmd[2]);
 };
 }
 else {
 return cmd;
 }
 }
 createShortcut(pattern, desc, cmdFunc, scope) {
 const shortcuts = Tools.map(explode(pattern, '>'), parseShortcut);
 shortcuts[shortcuts.length - 1] = Tools.extend(shortcuts[shortcuts.length - 1], {
 func: cmdFunc,
 scope: scope || this.editor
 });
 return Tools.extend(shortcuts[0], {
 desc: this.editor.translate(desc),
 subpatterns: shortcuts.slice(1)
 });
 }
 hasModifier(e) {
 return e.altKey || e.ctrlKey || e.metaKey;
 }
 isFunctionKey(e) {
 return e.type === 'keydown' && e.keyCode >= 112 && e.keyCode <= 123;
 }
 matchShortcut(e, shortcut) {
 if (!shortcut) {
 return false;
 }
 if (shortcut.ctrl !== e.ctrlKey || shortcut.meta !== e.metaKey) {
 return false;
 }
 if (shortcut.alt !== e.altKey || shortcut.shift !== e.shiftKey) {
 return false;
 }
 if (e.keyCode === shortcut.keyCode || (e.charCode && e.charCode === shortcut.charCode)) {
 e.preventDefault();
 return true;
 }
 return false;
 }
 executeShortcutAction(shortcut) {
 return shortcut.func ? shortcut.func.call(shortcut.scope) : null;
 }
 }

/**
 * TinyMCE UI registration API.
 *
 * @class tinymce.editor.ui.Registry
 */
 const registry = () => {
 const bridge = create$6();
 return {
 /**
 * Registers a new auto completer component. When a configured string pattern
 * is matched in the content while typing, the autocompleter will be triggered.
 * Emoticons and Charmap use an autocompleter.
 * 
 * For information on creating an autocompleter, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/autocompleter/">
 * UI Components - Autocompleter</a>.
 *
 * @method addAutocompleter
 * @param {String} name Unique name identifying this autocomplete configuration.
 * @param {InlineContent.AutocompleterSpec} obj The autocomplete configuration object.
 */
 addAutocompleter: bridge.addAutocompleter,
 /**
 * Registers a new toolbar button that executes a command when clicked or activated
 * via keyboard navigation controls.
 * 
 * For information on creating a basic toolbar button, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-basic-toolbar-button/">
 * UI Components - Types of toolbar buttons: Basic button</a>.
 *
 * @method addButton
 * @param {String} name Unique name identifying the button, this button name will be used in the toolbar configuration to reference the button.
 * @param {Toolbar.ToolbarButtonSpec} obj the button configuration object.
 */
 addButton: bridge.addButton,
 /**
 * Registers a new contextual form item.
 * Similar to a context menu item, a contextual form is an item with an input
 * form element appearing when a content predicate is matched. An example
 * of a contextual form is the link plugin when the configuration
 * { link_context_toolbar: true } is used. When the cursor is on a link, a
 * contextual input form appears allowing for quick changes to the url field.
 * 
 * For information on creating context forms, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/contextform/">
 * UI Components - Context forms</a>.
 *
 * @method addContextForm
 * @param {String} name Unique name identifying the new contextual form item.
 * @param {Toolbar.ContextFormSpec} obj the context form configuration object.
 */
 addContextForm: bridge.addContextForm,
 /**
 * Registers a new context menu section that only appears when a content predicate is matched,
 * for example, the cursor is inside a table.
 * 
 * For information on creating context menus, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/contextmenu/">
 * UI Components - Context Menu</a>.
 *
 * @method addContextMenu
 * @param {String} name Unique name identifying the new context menu.
 * @param {Menu.ContextMenuSpec} obj The context menu configuration object.
 */
 addContextMenu: bridge.addContextMenu,
 /**
 * Registers a new context toolbar that only appears when a content predicate is matched for example
 * the cursor is on an image element.
 * 
 * For information on creating context toolbars, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/contexttoolbar/">
 * UI Components - Context Toolbar</a>.
 *
 * @method addContextToolbar
 * @param {String} name Unique name identifying the new context toolbar.
 * @param {Toolbar.ContextToolbarSpec} obj The context menu configuration object.
 */
 addContextToolbar: bridge.addContextToolbar,
 /**
 * Registers a new SVG icon. The icon name reference can be configured by any
 * TinyMCE UI components that can display an icon. The icon is only available
 * to the editor instance it was configured for.
 *
 * @method addIcon
 * @param {String} name Unique name identifying the new icon.
 * @param {String} svgData The SVG data string the browser will use to render the SVG icon.
 * @example
 * //To add a simple triangle icon:
 * editor.ui.registry.addIcon('triangleUp', '<svg height="24" width="24"><path d="M12 0 L24 24 L0 24 Z" /></svg>');
 */
 addIcon: bridge.addIcon,
 /**
 * Registers a new menu button. Adds a toolbar button that opens a menu when
 * clicked. The menu can be populated by items created by addMenuItem,
 * addNestedMenuItem or addToggleMenuItem.
 * 
 * For information on creating a toolbar menu button, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-menu-toolbar-button/">
 * UI Components - Types of toolbar buttons: Menu button</a>.
 *
 * @method addMenuButton
 * @param {String} name Unique name identifying the new menu button.
 * @param {Toolbar.ToolbarMenuButtonSpec} obj The menu button configuration object.
 */
 addMenuButton: bridge.addMenuButton,
 /**
 * Registers a new menu item that executes a command when clicked or activated
 * via keyboard navigation controls.
 * 
 * For information on creating a basic menu item, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/creating-custom-menu-items/">
 * UI Components - Custom menu items: Basic menu items</a>.
 *
 * @method addMenuItem
 * @param {String} name Unique name identifying the new menu item.
 * @param {Menu.MenuItemSpec} obj The menu item configuration object.
 */
 addMenuItem: bridge.addMenuItem,
 /**
 * Registers a new menu item that reveals a submenu when clicked or activated
 * by keyboard navigation controls.The submenu can be populated by items
 * created by addMenuItem, addNestedMenuItem or addToggleMenuItem.
 * 
 * For information on creating a nested menu item, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-nested-menu-items/">
 * UI Components - Custom menu items: Nested menu items</a>.
 *
 * @method addNestedMenuItem
 * @param {String} name Unique name identifying the new nested menu item.
 * @param {Menu.NestedMenuItemSpec} obj The nested menu item configuration object.
 */
 addNestedMenuItem: bridge.addNestedMenuItem,
 /**
 * Registers a new sidebar container.
 * This sidebar container is attached to the right side of the editor and
 * can be toggled open or closed. When registered, a new toolbar toggle
 * button with the same sidebar name is created. Additionally there is a
 * ToggleSidebar command and a 'ToggleSidebar' event that can used to
 * manage the sidebar open/closed state. The tinycomments plugin uses a
 * sidebar for its Ui components.
 * 
 * For information on creating a custom sidebar, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/customsidebar/">
 * UI Components - Custom sidebar</a>.
 *
 * @method addSidebar
 * @param {String} name Unique name identifying the new sidebar.
 * @param {Sidebar.SidebarSpec} obj The sidebar configuration object.
 */
 addSidebar: bridge.addSidebar,
 /**
 * Registers a new split button for the toolbar. The list styles plugin uses
 * a split button to simplify its functionality.
 * 
 * For information on creating a split toolbar button, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-split-toolbar-button/">
 * UI Components - Types of toolbar buttons: Split button</a>.
 *
 * @method addSplitButton
 * @param {String} name Unique name identifying the new split button.
 * @param {Toolbar.ToolbarSplitButtonSpec} obj The split button configuration object.
 */
 addSplitButton: bridge.addSplitButton,
 /**
 * Registers a new toggle button for the toolbar. A toggle buttons state can
 * be set in the configuration.
 * 
 * For information on creating a toggle toolbar button, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-toggle-toolbar-button/">
 * UI Components - Types of toolbar buttons: Toggle button</a>.
 *
 * @method addToggleButton
 * @param {String} name Unique name identifying the new split button.
 * @param {Toolbar.ToolbarToggleButtonSpec} obj The toggle button configuration object.
 */
 addToggleButton: bridge.addToggleButton,
 /**
 * Registers a new group toolbar button for the toolbar. Renders a toolbar button that opens a floating toolbar when
 * clicked.
 * 
 * Note: Group toolbar buttons can only be used when using the floating toolbar mode.
 * 
 * For information on creating a group toolbar button, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-group-toolbar-button/">
 * UI Components - Types of toolbar buttons: Group toolbar button</a>.
 *
 * @method addGroupToolbarButton
 * @param {String} name Unique name identifying the new group toolbar button.
 * @param {Toolbar.GroupToolbarButtonSpec} obj The group toolbar button configuration object.
 */
 addGroupToolbarButton: bridge.addGroupToolbarButton,
 /**
 * Registers a new menu item that will act like a toggle button,
 * showing a tick in the menu item to represent state.
 * 
 * For information on creating a toggle menu item, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-toggle-menu-items/">
 * UI Components - Custom menu items: Toggle menu items</a>.
 *
 * @method addToggleMenuItem
 * @param {String} name Unique name identifying the new menu item.
 * @param {Menu.ToggleMenuItemSpec} obj The menu item configuration object.
 */
 addToggleMenuItem: bridge.addToggleMenuItem,
 /**
 * Registers a new view container.
 * This view container is hidden (off) by default and attached next to the main view.
 * It can be toggled on or off.
 * When it is on, the main editor view is hidden and the specific view is shown.
 * When it is off, the specific view is hidden and the main view is shown.
 * There is also a ToggleView command.
 * The ToggleView command can toggle the view visibility.
 * The ToggleView command can be queried for its current state.
 * 
 * For information on creating a custom view, see:
 * <a href="https://www.tiny.cloud/docs/tinymce/8/custom-view/">
 * UI Components - Custom view</a>.
 *
 * @method addView
 * @param {String} name Unique name identifying the new view.
 * @param {View.ViewSpec} obj The view configuration object.
 */
 addView: bridge.addView,
 /**
 * Registers a new context configuration in the registry.
 * The registry stores all context configurations.
 * The buttons in editor configuration object can contain a context property.
 * These button specifications can use the registered contexts to determine
 * whether to enable or disable the buttons based on the current context.
 *
 * @method addContext
 * @param {String} name Unique name identifying the new context configuration.
 * @param {Function} pred A predicate function that determines if the context is active
 */
 addContext: bridge.addContext,
 /* note getAll is an internal method and may not be supported in future revisions */
 getAll: bridge.getAll
 };
 };

// Shorten these names
    const DOM$1 = DOMUtils.DOM;
    const extend = Tools.extend, each$1 = Tools.each;
    /**
     * Include Editor API docs.
     *
     * @include ../../../../../tools/docs/tinymce.Editor.js
     */
    class Editor {
        baseUri;
        /**
         * Editor instance id, normally the same as the div/textarea that was replaced.
         *
         * @property id
         * @type String
         */
        id;
        /**
         * A uuid string to uniquely identify an editor across any page.
         *
         * @property editorUid
         * @type String
         */
        editorUid;
        /**
         * Name/Value object containing plugin instances.
         *
         * @property plugins
         * @type Object
         * @example
         * // Execute a method inside a plugin directly
         * tinymce.activeEditor.plugins.someplugin.someMethod();
         */
        plugins = {};
        /**
         * URI object to document configured for the TinyMCE instance.
         *
         * @property documentBaseURI
         * @type tinymce.util.URI
         * @example
         * // Get relative URL from the location of document_base_url
         * tinymce.activeEditor.documentBaseURI.toRelative('/somedir/somefile.htm');
         *
         * // Get absolute URL from the location of document_base_url
         * tinymce.activeEditor.documentBaseURI.toAbsolute('somefile.htm');
         */
        documentBaseURI;
        /**
         * URI object to current document that holds the TinyMCE editor instance.
         *
         * @property baseURI
         * @type tinymce.util.URI
         * @example
         * // Get relative URL from the location of the API
         * tinymce.activeEditor.baseURI.toRelative('/somedir/somefile.htm');
         *
         * // Get absolute URL from the location of the API
         * tinymce.activeEditor.baseURI.toAbsolute('somefile.htm');
         */
        baseURI;
        /**
         * Array with CSS files to load into the iframe.
         *
         * @property contentCSS
         * @type Array
         */
        contentCSS = [];
        /**
         * Array of CSS styles to add to head of document when the editor loads.
         *
         * @property contentStyles
         * @type Array
         */
        contentStyles = [];
        /**
         * Editor ui components
         *
         * @property ui
         * @type tinymce.editor.ui.Ui
         */
        ui;
        /**
         * Editor mode API
         *
         * @property mode
         * @type tinymce.EditorMode
         */
        mode;
        /**
         * Editor options API
         *
         * @property options
         * @type tinymce.EditorOptions
         */
        options;
        /**
         * Editor upload API
         *
         * @property editorUpload
         * @type tinymce.EditorUpload
         */
        editorUpload;
        /**
         * Editor user lookup API
         *
         * @property userLookup
         * @type tinymce.UserLookup
         */
        userLookup;
        shortcuts;
        loadedCSS = {};
        editorCommands;
        suffix;
        editorManager;
        hidden;
        inline;
        hasVisual;
        isNotDirty = false;
        // Arguments set later, for example by InitContentBody.ts
        // Note that these may technically be undefined up until PreInit (or similar) has fired,
        // however the types are aimed at an initialised editor for ease of use.
        annotator;
        bodyElement;
        bookmark; // Note: Intentionally any so as to not expose Optional
        composing = false;
        container;
        contentAreaContainer;
        contentDocument;
        contentWindow;
        delegates;
        destroyed = false;
        dom;
        editorContainer;
        eventRoot;
        formatter;
        formElement;
        formEventDelegate;
        hasHiddenInput = false;
        iframeElement = null;
        iframeHTML;
        initialized = false;
        notificationManager;
        orgDisplay;
        orgVisibility;
        parser;
        quirks;
        readonly = false;
        removed = false;
        schema;
        selection;
        serializer;
        startContent = '';
        targetElm;
        theme;
        model;
        undoManager;
        windowManager;
        licenseKeyManager;
        _beforeUnload;
        _eventDispatcher;
        _nodeChangeDispatcher;
        _pendingNativeEvents = [];
        _selectionOverrides;
        _skinLoaded = false;
        _editableRoot = true;
        // EditorObservable patches
        bindPendingEventDelegates;
        toggleNativeEvent;
        unbindAllNativeEvents;
        fire;
        dispatch;
        on;
        off;
        once;
        hasEventListeners;
        /**
         * Constructs a editor instance by id.
         *
         * @constructor
         * @method Editor
         * @param {String} id Unique id for the editor.
         * @param {Object} options Options for the editor.
         * @param {tinymce.EditorManager} editorManager EditorManager instance.
         */
        constructor(id, options, editorManager) {
            this.editorManager = editorManager;
            // Patch in the EditorObservable functions
            extend(this, EditorObservable);
            const self = this;
            this.id = id;
            this.editorUid = uuidV4();
            this.hidden = false;
            const normalizedOptions = normalizeOptions(editorManager.defaultOptions, options);
            this.options = create$4(self, normalizedOptions, options);
            register$7(self);
            this.userLookup = createUserLookup(this);
            const getOption = this.options.get;
            if (getOption('deprecation_warnings')) {
                logWarnings(options, normalizedOptions);
            }
            const suffix = getOption('suffix');
            if (suffix) {
                editorManager.suffix = suffix;
            }
            this.suffix = editorManager.suffix;
            const baseUrl = getOption('base_url');
            if (baseUrl) {
                editorManager._setBaseUrl(baseUrl);
            }
            this.baseUri = editorManager.baseURI;
            const referrerPolicy = getReferrerPolicy(self);
            if (referrerPolicy) {
                ScriptLoader.ScriptLoader._setReferrerPolicy(referrerPolicy);
                DOMUtils.DOM.styleSheetLoader._setReferrerPolicy(referrerPolicy);
            }
            ScriptLoader.ScriptLoader._setCrossOrigin((url) => {
                const crossOrigin = getCrossOrigin(self);
                return crossOrigin(url, 'script');
            });
            DOMUtils.DOM.styleSheetLoader._setCrossOrigin((url) => {
                const crossOrigin = getCrossOrigin(self);
                return crossOrigin(url, 'stylesheet');
            });
            const contentCssCors = hasContentCssCors(self);
            if (isNonNullable(contentCssCors)) {
                DOMUtils.DOM.styleSheetLoader._setContentCssCors(contentCssCors);
            }
            AddOnManager.languageLoad = getOption('language_load');
            AddOnManager.baseURL = editorManager.baseURL;
            this.setDirty(false);
            this.documentBaseURI = new URI(getDocumentBaseUrl(self), {
                base_uri: this.baseUri
            });
            this.baseURI = this.baseUri;
            this.inline = isInline$2(self);
            this.hasVisual = isVisualAidsEnabled(self);
            this.shortcuts = new Shortcuts(this);
            this.editorCommands = new EditorCommands(this);
            registerCommands(this);
            const cacheSuffix = getOption('cache_suffix');
            if (cacheSuffix) {
                Env.cacheSuffix = cacheSuffix.replace(/^[\?\&]+/, '');
            }
            this.ui = {
                registry: registry(),
                styleSheetLoader: undefined,
                show: noop,
                hide: noop,
                setEnabled: noop,
                isEnabled: always
            };
            this.mode = create$3(self);
            // Lock certain properties to reduce misuse
            Object.defineProperty(this, 'editorUid', {
                writable: false,
                configurable: false,
                enumerable: true,
            });
            // Call setup
            editorManager.dispatch('SetupEditor', { editor: this });
            const setupCallback = getSetupCallback(self);
            if (isFunction(setupCallback)) {
                setupCallback.call(self, self);
            }
        }
        /**
         * Renders the editor/adds it to the page.
         *
         * @method render
         */
        render() {
            render(this);
        }
        /**
         * Focuses/activates the editor. This will set this editor as the activeEditor in the tinymce collection
         * it will also place DOM focus inside the editor.
         *
         * @method focus
         * @param {Boolean} skipFocus Skip DOM focus. Just set is as the active editor.
         */
        focus(skipFocus) {
            this.execCommand('mceFocus', false, skipFocus);
        }
        /**
         * Returns true/false if the editor has real keyboard focus.
         *
         * @method hasFocus
         * @return {Boolean} Current focus state of the editor.
         */
        hasFocus() {
            return hasFocus(this);
        }
        /**
         * Translates the specified string by replacing variables with language pack items it will also check if there is
         * a key matching the input.
         *
         * @method translate
         * @param {String} text String to translate by the language pack data.
         * @return {String} Translated string.
         */
        translate(text) {
            return I18n.translate(text);
        }
        getParam(name, defaultVal, type) {
            const options = this.options;
            // To keep the legacy API we need to register the option if it's not already been registered
            if (!options.isRegistered(name)) {
                if (isNonNullable(type)) {
                    options.register(name, { processor: type, default: defaultVal });
                }
                else {
                    options.register(name, { processor: always, default: defaultVal });
                }
            }
            // Attempt to use the passed default value if nothing has been set already
            return !options.isSet(name) && !isUndefined(defaultVal) ? defaultVal : options.get(name);
        }
        /**
         * Checks that the plugin is in the editor configuration and can optionally check if the plugin has been loaded.
         *
         * @method hasPlugin
         * @param {String} name The name of the plugin, as specified for the TinyMCE `plugins` option.
         * @param {Boolean} loaded If `true`, will also check that the plugin has been loaded.
         * @return {Boolean} If `loaded` is `true`, returns `true` if the plugin is in the configuration and has been loaded. If `loaded` is `false`, returns `true` if the plugin is in the configuration, regardless of plugin load status.
         * @example
         * // Returns `true` if the Comments plugin is in the editor configuration and has loaded successfully:
         * tinymce.activeEditor.hasPlugin('tinycomments', true);
         * // Returns `true` if the Table plugin is in the editor configuration, regardless of whether or not it loads:
         * tinymce.activeEditor.hasPlugin('table');
         */
        hasPlugin(name, loaded) {
            const hasPlugin = contains$2(getPlugins(this), name);
            if (hasPlugin) {
                return loaded ? PluginManager.get(name) !== undefined : true;
            }
            else {
                return false;
            }
        }
        /**
         * Dispatches out a onNodeChange event to all observers. This method should be called when you
         * need to update the UI states or element path etc.
         *
         * @method nodeChanged
         * @param {Object} args Optional args to pass to NodeChange event handlers.
         */
        nodeChanged(args) {
            this._nodeChangeDispatcher.nodeChanged(args);
        }
        addCommand(name, callback, scope) {
            /**
             * Callback function that gets called when a command is executed.
             *
             * @callback addCommandCallback
             * @param {Boolean} ui Display UI state true/false.
             * @param {Object} value Optional value for command.
             * @return {Boolean} True/false state if the command was handled or not.
             */
            this.editorCommands.addCommand(name, callback, scope);
        }
        addQueryStateHandler(name, callback, scope) {
            /**
             * Callback function that gets called when a queryCommandState is executed.
             *
             * @callback addQueryStateHandlerCallback
             * @return {Boolean} True/false state if the command is enabled or not like is it bold.
             */
            this.editorCommands.addQueryStateHandler(name, callback, scope);
        }
        addQueryValueHandler(name, callback, scope) {
            /**
             * Callback function that gets called when a queryCommandValue is executed.
             *
             * @callback addQueryValueHandlerCallback
             * @return {Object} Value of the command or undefined.
             */
            this.editorCommands.addQueryValueHandler(name, callback, scope);
        }
        /**
         * Adds a keyboard shortcut for some command or function.
         *
         * @method addShortcut
         * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
         * @param {String} desc Text description for the command.
         * @param {String/Function} cmdFunc Command name string or function to execute when the key is pressed.
         * @param {Object} scope Optional scope to execute the function in.
         * @return {Boolean} true/false state if the shortcut was added or not.
         * @example
         * editor.addShortcut('ctrl+a', 'description of the shortcut', () => {});
         * editor.addShortcut('ctrl+alt+a', 'description of the shortcut', () => {});
         * // "meta" maps to Command on Mac and Ctrl on PC
         * editor.addShortcut('meta+a', 'description of the shortcut', () => {});
         * // "access" maps to Control+Option on Mac and shift+alt on PC
         * editor.addShortcut('access+a', 'description of the shortcut', () => {});
         *
         * editor.addShortcut('meta+access+c', 'Opens the code editor dialog.', () => {
         *   editor.execCommand('mceCodeEditor');
         * });
         *
         * editor.addShortcut('meta+shift+32', 'Inserts "Hello, World!" for meta+shift+space', () => {
         *   editor.execCommand('mceInsertContent', false, 'Hello, World!');
         * });
         */
        addShortcut(pattern, desc, cmdFunc, scope) {
            this.shortcuts.add(pattern, desc, cmdFunc, scope);
        }
        /**
         * Executes a registered command on the current instance. A list of available commands can be found in
         * the tinymce command identifiers documentation.
         *
         * @method execCommand
         * @param {String} cmd Command name to execute, for example mceLink or Bold.
         * @param {Boolean} ui Specifies if a UI (dialog) should be presented or not.
         * @param {Object/Array/String/Number/Boolean} value Optional command value, this can be anything.
         * @param {Object} args Optional arguments object.
         * @return {Boolean} true or false if the command was supported or not.
         */
        execCommand(cmd, ui, value, args) {
            return this.editorCommands.execCommand(cmd, ui, value, args);
        }
        /**
         * Returns a command specific state, for example if bold is enabled or not.
         *
         * @method queryCommandState
         * @param {String} cmd Command to query state from.
         * @return {Boolean} Command specific state, for example if bold is enabled or not.
         */
        queryCommandState(cmd) {
            return this.editorCommands.queryCommandState(cmd);
        }
        /**
         * Returns a command specific value, for example the current font size.
         *
         * @method queryCommandValue
         * @param {String} cmd Command to query value from.
         * @return {String} Command value, for example the current font size or an empty string (`""`) if the query command is not found.
         */
        queryCommandValue(cmd) {
            return this.editorCommands.queryCommandValue(cmd);
        }
        /**
         * Returns true/false if the command is supported or not.
         *
         * @method queryCommandSupported
         * @param {String} cmd Command that we check support for.
         * @return {Boolean} true/false if the command is supported or not.
         */
        queryCommandSupported(cmd) {
            return this.editorCommands.queryCommandSupported(cmd);
        }
        /**
         * Shows the editor and hides any textarea/div that the editor is supposed to replace.
         *
         * @method show
         */
        show() {
            const self = this;
            if (self.hidden) {
                self.hidden = false;
                if (self.inline) {
                    self.getBody().contentEditable = 'true';
                }
                else {
                    DOM$1.show(self.getContainer());
                    DOM$1.hide(self.id);
                }
                self.load();
                self.dispatch('show');
            }
        }
        /**
         * Hides the editor and shows any textarea/div that the editor is supposed to replace.
         *
         * @method hide
         */
        hide() {
            const self = this;
            if (!self.hidden) {
                // We must save before we hide so Safari doesn't crash
                self.save();
                if (self.inline) {
                    self.getBody().contentEditable = 'false';
                    // Make sure the editor gets blurred
                    if (self === self.editorManager.focusedEditor) {
                        self.editorManager.focusedEditor = null;
                    }
                }
                else {
                    DOM$1.hide(self.getContainer());
                    DOM$1.setStyle(self.id, 'display', self.orgDisplay);
                }
                self.hidden = true;
                self.dispatch('hide');
            }
        }
        /**
         * Returns true/false if the editor is hidden or not.
         *
         * @method isHidden
         * @return {Boolean} True/false if the editor is hidden or not.
         */
        isHidden() {
            return this.hidden;
        }
        /**
         * Sets the progress state, this will display a throbber/progess for the editor.
         * This is ideal for asynchronous operations like an AJAX save call.
         *
         * @method setProgressState
         * @param {Boolean} state Boolean state if the progress should be shown or hidden.
         * @param {Number} time Optional time to wait before the progress gets shown.
         * @return {Boolean} Same as the input state.
         * @example
         * // Show progress for the active editor
         * tinymce.activeEditor.setProgressState(true);
         *
         * // Hide progress for the active editor
         * tinymce.activeEditor.setProgressState(false);
         *
         * // Show progress after 3 seconds
         * tinymce.activeEditor.setProgressState(true, 3000);
         */
        setProgressState(state, time) {
            this.dispatch('ProgressState', { state, time });
        }
        /**
         * Loads contents from the textarea, input or other element that got converted into an editor instance.
         * This method will move the contents from that textarea, input or other element into the editor by using setContent
         * so all events etc that method has will get dispatched as well.
         *
         * @method load
         * @param {Object} args Optional content object, this gets passed around through the whole load process.
         */
        load(args = {}) {
            const self = this;
            const elm = self.getElement();
            if (self.removed) {
                return;
            }
            if (elm) {
                const loadArgs = {
                    ...args,
                    load: true
                };
                const value = isTextareaOrInput(elm) ? elm.value : elm.innerHTML;
                self.setContent(value, loadArgs);
                if (!loadArgs.no_events) {
                    self.dispatch('LoadContent', {
                        ...loadArgs,
                        element: elm
                    });
                }
            }
        }
        /**
         * Saves the contents from an editor out to the textarea or div element that got converted into an editor instance.
         * This method will move the HTML contents from the editor into that textarea or div by getContent
         * so all events etc that method has will get dispatched as well.
         *
         * @method save
         * @param {Object} args Optional content object, this gets passed around through the whole save process.
         * @return {String} HTML string that got set into the textarea/div.
         */
        save(args = {}) {
            const self = this;
            let elm = self.getElement();
            if (!elm || !self.initialized || self.removed) {
                return '';
            }
            const getArgs = {
                ...args,
                save: true,
                element: elm
            };
            let html = self.getContent(getArgs);
            const saveArgs = { ...getArgs, content: html };
            if (!saveArgs.no_events) {
                self.dispatch('SaveContent', saveArgs);
            }
            // Always run this internal event
            if (saveArgs.format === 'raw') {
                self.dispatch('RawSaveContent', saveArgs);
            }
            html = saveArgs.content;
            if (!isTextareaOrInput(elm)) {
                if (args.is_removing || !self.inline) {
                    elm.innerHTML = html;
                }
                // Update hidden form element
                const form = DOM$1.getParent(self.id, 'form');
                if (form) {
                    each$1(form.elements, (elm) => {
                        if (elm.name === self.id) {
                            elm.value = html;
                            return false;
                        }
                        else {
                            return true;
                        }
                    });
                }
            }
            else {
                elm.value = html;
            }
            saveArgs.element = getArgs.element = elm = null;
            if (saveArgs.set_dirty !== false) {
                self.setDirty(false);
            }
            return html;
        }
        setContent(content, args) {
            setContent(this, content, args);
        }
        getContent(args) {
            return getContent(this, args);
        }
        /**
         * Inserts content at caret position.
         *
         * @method insertContent
         * @param {String} content Content to insert.
         * @param {Object} args Optional args to pass to insert call.
         */
        insertContent(content, args) {
            if (args) {
                content = extend({ content }, args);
            }
            this.execCommand('mceInsertContent', false, content);
        }
        /**
         * Resets the editors content, undo/redo history and dirty state. If `initialContent` isn't specified, then
         * the editor is reset back to the initial start content.
         *
         * @method resetContent
         * @param {String} initialContent An optional string to use as the initial content of the editor.
         */
        resetContent(initialContent) {
            // Set the editor content
            if (initialContent === undefined) {
                // editor.startContent is generated by using the `raw` format, so we should set it the same way
                setContent(this, this.startContent, { initial: true, format: 'raw' });
            }
            else {
                setContent(this, initialContent, { initial: true });
            }
            // Update the editor/undo manager state
            this.undoManager.reset();
            this.setDirty(false);
            // Fire a node change event
            this.nodeChanged();
        }
        /**
         * Returns true/false if the editor is dirty or not. It will get dirty if the user has made modifications to the contents.
         *
         * The dirty state is automatically set to `true` when the user modifies editor content after initialization or the
         * last `editor.save()` call. This includes changes made using undo or redo.
         *
         * @method isDirty
         * @return {Boolean} True/false if the editor is dirty or not. It will get dirty if the user has made modifications to the contents.
         * @example
         * if (tinymce.activeEditor.isDirty()) {
         *   alert("You must save your contents.");
         * }
         */
        isDirty() {
            return !this.isNotDirty;
        }
        /**
         * Explicitly sets the dirty state. This will fire the dirty event if the editor dirty state is changed from false to true
         * by invoking this method.
         *
         * @method setDirty
         * @param {Boolean} state True/false if the editor is considered dirty.
         * @example
         * const ajaxSave = () => {
         *   const editor = tinymce.get('elm1');
         *
         *   // Save contents using some XHR call
         *   alert(editor.getContent());
         *
         *   editor.setDirty(false); // Force not dirty state
         * }
         */
        setDirty(state) {
            const oldState = !this.isNotDirty;
            this.isNotDirty = !state;
            if (state && state !== oldState) {
                this.dispatch('dirty');
            }
        }
        /**
         * Returns the container element of the editor. The container element includes
         * all the elements added to the page for the editor. Such as UI, iframe, etc.
         *
         * @method getContainer
         * @return {Element} HTML DOM element for the editor container.
         */
        getContainer() {
            const self = this;
            if (!self.container) {
                self.container = self.editorContainer || DOM$1.get(self.id + '_parent');
            }
            return self.container;
        }
        /**
         * Returns the content area container element of the editor. This element
         * holds the iframe or the editable element.
         *
         * @method getContentAreaContainer
         * @return {Element} HTML DOM element for the editor area container.
         */
        getContentAreaContainer() {
            return this.contentAreaContainer;
        }
        /**
         * Returns the target element/textarea that got replaced with a TinyMCE editor instance.
         *
         * @method getElement
         * @return {Element} HTML DOM element for the replaced element.
         */
        getElement() {
            if (!this.targetElm) {
                this.targetElm = DOM$1.get(this.id);
            }
            return this.targetElm;
        }
        /**
         * Returns the iframes window object.
         *
         * @method getWin
         * @return {Window} Iframe DOM window object.
         */
        getWin() {
            const self = this;
            if (!self.contentWindow) {
                const elm = self.iframeElement;
                if (elm) {
                    self.contentWindow = elm.contentWindow;
                }
            }
            return self.contentWindow;
        }
        /**
         * Returns the iframes document object.
         *
         * @method getDoc
         * @return {Document} Iframe DOM document object.
         */
        getDoc() {
            const self = this;
            if (!self.contentDocument) {
                const win = self.getWin();
                if (win) {
                    self.contentDocument = win.document;
                }
            }
            return self.contentDocument;
        }
        /**
         * Returns the root element of the editable area.
         * For a non-inline iframe-based editor, returns the iframe's body element.
         *
         * @method getBody
         * @return {Element} The root element of the editable area.
         */
        getBody() {
            const doc = this.getDoc();
            return this.bodyElement ?? doc?.body ?? null;
        }
        /**
         * URL converter function this gets executed each time a user adds an img, a or
         * any other element that has a URL in it. This will be called both by the DOM and HTML
         * manipulation functions.
         *
         * @method convertURL
         * @param {String} url URL to convert.
         * @param {String} name Attribute name src, href etc.
         * @param {String/HTMLElement} elm Tag name or HTML DOM element depending on HTML or DOM insert.
         * @return {String} Converted URL string.
         */
        convertURL(url, name, elm) {
            const self = this, getOption = self.options.get;
            // Use callback instead
            const urlConverterCallback = getUrlConverterCallback(self);
            if (isFunction(urlConverterCallback)) {
                return urlConverterCallback.call(self, url, elm, true, name);
            }
            // Don't convert link href since that's the CSS files that gets loaded into the editor also skip local file URLs
            if (!getOption('convert_urls') ||
                elm === 'link' ||
                (isObject(elm) && elm.nodeName === 'LINK') ||
                url.indexOf('file:') === 0 ||
                url.length === 0) {
                return url;
            }
            const urlObject = new URI(url);
            if (urlObject.protocol !== 'http' && urlObject.protocol !== 'https' && urlObject.protocol !== '') {
                return url;
            }
            // Convert to relative
            if (getOption('relative_urls')) {
                return self.documentBaseURI.toRelative(url);
            }
            // Convert to absolute
            url = self.documentBaseURI.toAbsolute(url, getOption('remove_script_host'));
            return url;
        }
        /**
         * Adds visual aids for tables, anchors, etc so they can be more easily edited inside the editor.
         *
         * @method addVisual
         * @param {Element} elm Optional root element to loop though to find tables, etc that needs the visual aid.
         */
        addVisual(elm) {
            addVisual(this, elm);
        }
        /**
         * Changes the editable state of the editor's root element.
         *
         * @method setEditableRoot
         * @param {Boolean} state State to set true for editable and false for non-editable.
         */
        setEditableRoot(state) {
            setEditableRoot(this, state);
        }
        /**
         * Returns the current editable state of the editor's root element.
         *
         * @method hasEditableRoot
         * @return {Boolean} True if the root element is editable, false if it is not editable.
         */
        hasEditableRoot() {
            return hasEditableRoot(this);
        }
        /**
         * Removes the editor from the dom and tinymce collection.
         *
         * @method remove
         */
        remove() {
            remove$1(this);
        }
        /**
         * Destroys the editor instance by removing all events, element references or other resources
         * that could leak memory. This method will be called automatically when the page is unloaded
         * but you can also call it directly if you know what you are doing.
         *
         * @method destroy
         * @param {Boolean} automatic Optional state if the destroy is an automatic destroy or user called one.
         */
        destroy(automatic) {
            destroy(this, automatic);
        }
        /**
         * Uploads all data uri/blob uri images in the editor contents to server.
         *
         * @method uploadImages
         * @return {Promise} Promise instance with images and status for each image.
         */
        uploadImages() {
            return this.editorUpload.uploadImages();
        }
        // Internal functions
        _scanForImages() {
            return this.editorUpload.scanForImages();
        }
    }

// The FakeClipboard has been designed to match the native Clipboard API as closely as possible
    const setup = () => {
        const dataValue = value$1();
        const FakeClipboardItem = (items) => ({
            items,
            types: keys(items),
            getType: (type) => get$a(items, type).getOrUndefined()
        });
        const write = (data) => {
            dataValue.set(data);
        };
        const read = () => dataValue.get().getOrUndefined();
        const clear = dataValue.clear;
        return {
            FakeClipboardItem,
            write,
            read,
            clear
        };
    };
    const FakeClipboard = setup();

/**
 * Contains various tools for rect/position calculation.
 *
 * @class tinymce.geom.Rect
 */
 const min = Math.min, max = Math.max, round = Math.round;
 /**
 * Returns the rect positioned based on the relative position name
 * to the target rect.
 *
 * @method relativePosition
 * @param {Rect} rect Source rect to modify into a new rect.
 * @param {Rect} targetRect Rect to move relative to based on the rel option.
 * @param {String} rel Relative position. For example: tr-bl.
 */
 const relativePosition = (rect, targetRect, rel) => {
 let x = targetRect.x;
 let y = targetRect.y;
 const w = rect.w;
 const h = rect.h;
 const targetW = targetRect.w;
 const targetH = targetRect.h;
 const relChars = (rel || '').split('');
 if (relChars[0] === 'b') {
 y += targetH;
 }
 if (relChars[1] === 'r') {
 x += targetW;
 }
 if (relChars[0] === 'c') {
 y += round(targetH / 2);
 }
 if (relChars[1] === 'c') {
 x += round(targetW / 2);
 }
 if (relChars[3] === 'b') {
 y -= h;
 }
 if (relChars[4] === 'r') {
 x -= w;
 }
 if (relChars[3] === 'c') {
 y -= round(h / 2);
 }
 if (relChars[4] === 'c') {
 x -= round(w / 2);
 }
 return create$2(x, y, w, h);
 };
 /**
 * Tests various positions to get the most suitable one.
 *
 * @method findBestRelativePosition
 * @param {Rect} rect Rect to use as source.
 * @param {Rect} targetRect Rect to move relative to.
 * @param {Rect} constrainRect Rect to constrain within.
 * @param {Array} rels Array of relative positions to test against.
 */
 const findBestRelativePosition = (rect, targetRect, constrainRect, rels) => {
 for (let i = 0; i < rels.length; i++) {
 const pos = relativePosition(rect, targetRect, rels[i]);
 if (pos.x >= constrainRect.x && pos.x + pos.w <= constrainRect.w + constrainRect.x &&
 pos.y >= constrainRect.y && pos.y + pos.h <= constrainRect.h + constrainRect.y) {
 return rels[i];
 }
 }
 return null;
 };
 /**
 * Inflates the rect in all directions.
 *
 * @method inflate
 * @param {Rect} rect Rect to expand.
 * @param {Number} w Relative width to expand by.
 * @param {Number} h Relative height to expand by.
 * @return {Rect} New expanded rect.
 */
 const inflate = (rect, w, h) => {
 return create$2(rect.x - w, rect.y - h, rect.w + w * 2, rect.h + h * 2);
 };
 /**
 * Returns the intersection of the specified rectangles.
 *
 * @method intersect
 * @param {Rect} rect The first rectangle to compare.
 * @param {Rect} cropRect The second rectangle to compare.
 * @return {Rect} The intersection of the two rectangles or null if they don't intersect.
 */
 const intersect = (rect, cropRect) => {
 const x1 = max(rect.x, cropRect.x);
 const y1 = max(rect.y, cropRect.y);
 const x2 = min(rect.x + rect.w, cropRect.x + cropRect.w);
 const y2 = min(rect.y + rect.h, cropRect.y + cropRect.h);
 if (x2 - x1 < 0 || y2 - y1 < 0) {
 return null;
 }
 return create$2(x1, y1, x2 - x1, y2 - y1);
 };
 /**
 * Returns a rect clamped within the specified clamp rect. This forces the
 * rect to be inside the clamp rect.
 *
 * @method clamp
 * @param {Rect} rect Rectangle to force within clamp rect.
 * @param {Rect} clampRect Rectable to force within.
 * @param {Boolean} fixedSize True/false if size should be fixed.
 * @return {Rect} Clamped rect.
 */
 const clamp = (rect, clampRect, fixedSize) => {
 let x1 = rect.x;
 let y1 = rect.y;
 let x2 = rect.x + rect.w;
 let y2 = rect.y + rect.h;
 const cx2 = clampRect.x + clampRect.w;
 const cy2 = clampRect.y + clampRect.h;
 const underflowX1 = max(0, clampRect.x - x1);
 const underflowY1 = max(0, clampRect.y - y1);
 const overflowX2 = max(0, x2 - cx2);
 const overflowY2 = max(0, y2 - cy2);
 x1 += underflowX1;
 y1 += underflowY1;
 if (fixedSize) {
 x2 += underflowX1;
 y2 += underflowY1;
 x1 -= overflowX2;
 y1 -= overflowY2;
 }
 x2 -= overflowX2;
 y2 -= overflowY2;
 return create$2(x1, y1, x2 - x1, y2 - y1);
 };
 /**
 * Creates a new rectangle object.
 *
 * @method create
 * @param {Number} x Rectangle x location.
 * @param {Number} y Rectangle y location.
 * @param {Number} w Rectangle width.
 * @param {Number} h Rectangle height.
 * @return {Rect} New rectangle object.
 */
 const create$2 = (x, y, w, h) => {
 return { x, y, w, h };
 };
 /**
 * Creates a new rectangle object form a clientRects object.
 *
 * @method fromClientRect
 * @param {ClientRect} clientRect DOM ClientRect object.
 * @return {Rect} New rectangle object.
 */
 const fromClientRect = (clientRect) => {
 return create$2(clientRect.left, clientRect.top, clientRect.width, clientRect.height);
 };
 const Rect = {
 inflate,
 relativePosition,
 findBestRelativePosition,
 intersect,
 clamp,
 create: create$2,
 fromClientRect
 };

// Simple stub of localstorage with strict security settings #TINY-1782
    const create = () => (() => {
        let data = {};
        let keys = [];
        const storage = {
            getItem: (key) => {
                const item = data[key];
                return item ? item : null;
            },
            setItem: (key, value) => {
                keys.push(key);
                data[key] = String(value);
            },
            key: (index) => {
                return keys[index];
            },
            removeItem: (key) => {
                keys = keys.filter((k) => k === key);
                delete data[key];
            },
            clear: () => {
                keys = [];
                data = {};
            },
            length: 0
        };
        Object.defineProperty(storage, 'length', {
            get: () => keys.length,
            configurable: false,
            enumerable: false
        });
        return storage;
    })();

/**
     * @class tinymce.util.LocalStorage
     * @static
     * @version 4.0
     * @private
     * @example
     * tinymce.util.LocalStorage.setItem('key', 'value');
     * const value = tinymce.util.LocalStorage.getItem('key');
     */
    let localStorage;
    // Browsers with certain strict security settings will explode when trying to access localStorage
    // so we need to do a try/catch and a simple stub here. #TINY-1782 & #TINY-5935
    try {
        const test = '__storage_test__';
        localStorage = window.localStorage;
        // Make sure we can set a value, as storage may also be full
        localStorage.setItem(test, test);
        localStorage.removeItem(test);
    }
    catch {
        localStorage = create();
    }
    var LocalStorage = localStorage;

/**
     * @include ../../../../../tools/docs/tinymce.js
     */
    /**
     * @include ../../../../../tools/docs/tinymce.Event.js
     */
    /**
     * @include ../../../../../tools/docs/tinymce.editor.ui.Ui.js
     */
    const publicApi = {
        geom: {
            Rect
        },
        util: {
            Delay,
            Tools,
            VK,
            URI,
            EventDispatcher,
            Observable,
            I18n,
            LocalStorage,
            ImageUploader
        },
        dom: {
            EventUtils,
            TreeWalker: DomTreeWalker,
            TextSeeker,
            DOMUtils,
            ScriptLoader,
            RangeUtils,
            Serializer: DomSerializer,
            StyleSheetLoader,
            ControlSelection,
            BookmarkManager,
            Selection: EditorSelection,
            Event: EventUtils.Event
        },
        html: {
            Styles,
            Entities,
            Node: AstNode,
            Schema,
            DomParser,
            Writer,
            Serializer: HtmlSerializer
        },
        Env,
        AddOnManager,
        Annotator,
        Formatter,
        UndoManager,
        EditorCommands,
        WindowManager,
        NotificationManager,
        EditorObservable,
        Shortcuts,
        Editor,
        FocusManager,
        EditorManager,
        // Global instances
        DOM: DOMUtils.DOM,
        ScriptLoader: ScriptLoader.ScriptLoader,
        PluginManager,
        ThemeManager,
        ModelManager,
        IconManager,
        Resource,
        FakeClipboard,
        // Global utility functions
        trim: Tools.trim,
        isArray: Tools.isArray,
        is: Tools.is,
        toArray: Tools.toArray,
        makeMap: Tools.makeMap,
        each: Tools.each,
        map: Tools.map,
        grep: Tools.grep,
        inArray: Tools.inArray,
        extend: Tools.extend,
        walk: Tools.walk,
        resolve: Tools.resolve,
        explode: Tools.explode,
        _addCacheSuffix: Tools._addCacheSuffix
    };
    const tinymce$1 = Tools.extend(EditorManager, publicApi);

})();