https://golf4holland.nl/g4h_assets/application-271187c20331aeb770b…6e9f43b50138df9a77502e3f03f0ac7fdc1a9926.js

57)
58 */
59
60(function () {
61    'use strict';
62
63    var typeOf$1 = function (x) {
64        if (x === null) {
65            return 'null';
66        }
67        if (x === undefined) {
68            return 'undefined';
69        }
70        var t = typeof x;
71        if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
72            return 'array';
73        }
74        if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
75            return 'string';
76        }
77        return t;
78    };
79    var isEquatableType = function (x) {
80        return ['undefined', 'boolean', 'number', 'string', 'function', 'xml', 'null'].indexOf(x) !== -1;
81    };
82
83    var sort$1 = function (xs, compareFn) {
84        var clone = Array.prototype.slice.call(xs);
85        return clone.sort(compareFn);
86    };
87
88    var contramap = function (eqa, f) {
89        return eq$2(function (x, y) { return eqa.eq(f(x), f(y)); });
90    };
91    var eq$2 = function (f) {
92        return ({ eq: f });
93    };
94    var tripleEq = eq$2(function (x, y) { return x === y; });
95    var eqString = tripleEq;
96    var eqArray = function (eqa) { return eq$2(function (x, y) {
97        if (x.length !== y.length) {
98            return false;
99        }
100        var len = x.length;
101        for (var i = 0; i < len; i++) {
102            if (!eqa.eq(x[i], y[i])) {
103                return false;
104            }
105        }
106        return true;
107    }); };
108    // TODO: Make an Ord typeclass
109    var eqSortedArray = function (eqa, compareFn) {
110        return contramap(eqArray(eqa), function (xs) { return sort$1(xs, compareFn); });
111    };
112    var eqRecord = function (eqa) { return eq$2(function (x, y) {
113        var kx = Object.keys(x);
114        var ky = Object.keys(y);
115        if (!eqSortedArray(eqString).eq(kx, ky)) {
116            return false;
117        }
118        var len = kx.length;
119        for (var i = 0; i < len; i++) {
120            var q = kx[i];
121            if (!eqa.eq(x[q], y[q])) {
122                return false;
123            }
124        }
125        return true;
126    }); };
127    var eqAny = eq$2(function (x, y) {
128        if (x === y) {
129            return true;
130        }
131        var tx = typeOf$1(x);
132        var ty = typeOf$1(y);
133        if (tx !== ty) {
134            return false;
135        }
136        if (isEquatableType(tx)) {
137            return x === y;
138        }
139        else if (tx === 'array') {
140            return eqArray(eqAny).eq(x, y);
141        }
142        else if (tx === 'object') {
143            return eqRecord(eqAny).eq(x, y);
144        }
145        return false;
146    });
147
148    /* eslint-disable @typescript-eslint/no-wrapper-object-types */
149    const getPrototypeOf$2 = Object.getPrototypeOf;
150    const hasProto = (v, constructor, predicate) => {
151        if (predicate(v, constructor.prototype)) {
152            return true;
153        }
154        else {
155            // String-based fallback time
156            return v.constructor?.name === constructor.name;
157        }
158    };
159    const typeOf = (x) => {
160        const t = typeof x;
161        if (x === null) {
162            return 'null';
163        }
164        else if (t === 'object' && Array.isArray(x)) {
165            return 'array';
166        }
167        else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
168            return 'string';
169        }
170        else {
171            return t;
172        }
173    };
174    const isType$1 = (type) => (value) => typeOf(value) === type;
175    const isSimpleType = (type) => (value) => typeof value === type;
176    const eq$1 = (t) => (a) => t === a;
177    const is$5 = (value, constructor) => isObject(value) && hasProto(value, constructor, (o, proto) => getPrototypeOf$2(o) === proto);
178    const isString = isType$1('string');
179    const isObject = isType$1('object');
180    const isPlainObject = (value) => is$5(value, Object);
181    const isArray$1 = isType$1('array');
182    const isNull = eq$1(null);
183    const isBoolean = isSimpleType('boolean');
184    const isUndefined = eq$1(undefined);
185    const isNullable = (a) => a === null || a === undefined;
186    const isNonNullable = (a) => !isNullable(a);
187    const isFunction = isSimpleType('function');
188    const isNumber = isSimpleType('number');
189    const isArrayOf = (value, pred) => {
190        if (isArray$1(value)) {
191            for (let i = 0, len = value.length; i < len; ++i) {
192                if (!(pred(value[i]))) {
193                    return false;
194                }
195            }
196            return true;
197        }
198        return false;
199    };
200
201    const noop = () => { };
202    /** Compose a unary function with an n-ary function */
203    const compose = (fa, fb) => {
204        return (...args) => {
205            return fa(fb.apply(null, args));
206        };
207    };
208    /** Compose two unary functions. Similar to compose, but avoids using Function.prototype.apply. */
209    const compose1 = (fbc, fab) => (a) => fbc(fab(a));
210    const constant = (value) => {
211        return () => {
212            return value;
213        };
214    };
215    const identity = (x) => {
216        return x;
217    };
218    const tripleEquals = (a, b) => {
219        return a === b;
220    };
221    function curry(fn, ...initialArgs) {
222        return (...restArgs) => {
223            const all = initialArgs.concat(restArgs);
224            return fn.apply(null, all);
225        };
226    }
227    const not = (f) => (t) => !f(t);
228    const die = (msg) => {
229        return () => {
230            throw new Error(msg);
231        };
232    };
233    const apply$1 = (f) => {
234        return f();
235    };
236    const call = (f) => {
237        f();
238    };
239    const never = constant(false);
240    const always = constant(true);
241
242    /**
243     * The `Optional` type represents a value (of any type) that potentially does
244     * not exist. Any `Optional<T>` can either be a `Some<T>` (in which case the
245     * value does exist) or a `None` (in which case the value does not exist). This
246     * module defines a whole lot of FP-inspired utility functions for dealing with
247     * `Optional` objects.
248     *
249     * Comparison with null or undefined:
250     * - We don't get fancy null coalescing operators with `Optional`
251     * - We do get fancy helper functions with `Optional`
252     * - `Optional` support nesting, and allow for the type to still be nullable (or
253     * another `Optional`)
254     * - There is no option to turn off strict-optional-checks like there is for
255     * strict-null-checks
256     */
257    class Optional {
258        tag;
259        value;
260        // Sneaky optimisation: every instance of Optional.none is identical, so just
261        // reuse the same object
262        static singletonNone = new Optional(false);
263        // The internal representation has a `tag` and a `value`, but both are
264        // private: able to be console.logged, but not able to be accessed by code
265        constructor(tag, value) {
266            this.tag = tag;
267            this.value = value;
268        }
269        // --- Identities ---
270        /**
271         * Creates a new `Optional<T>` that **does** contain a value.
272         */
273        static some(value) {
274            return new Optional(true, value);
275        }
276        /**
277         * Create a new `Optional<T>` that **does not** contain a value. `T` can be
278         * any type because we don't actually have a `T`.
279         */
280        static none() {
281            return Optional.singletonNone;
282        }
283        /**
284         * Perform a transform on an `Optional` type. Regardless of whether this
285         * `Optional` contains a value or not, `fold` will return a value of type `U`.
286         * If this `Optional` does not contain a value, the `U` will be created by
287         * calling `onNone`. If this `Optional` does contain a value, the `U` will be
288         * created by calling `onSome`.
289         *
290         * For the FP enthusiasts in the room, this function:
291         * 1. Could be used to implement all of the functions below
292         * 2. Forms a catamorphism
293         */
294        fold(onNone, onSome) {
295            if (this.tag) {
296                return onSome(this.value);
297            }
298            else {
299                return onNone();
300            }
301        }
302        /**
303         * Determine if this `Optional` object contains a value.
304         */
305        isSome() {
306            return this.tag;
307        }
308        /**
309         * Determine if this `Optional` object **does not** contain a value.
310         */
311        isNone() {
312            return !this.tag;
313        }
314        // --- Functor (name stolen from Haskell / maths) ---
315        /**
316         * Perform a transform on an `Optional` object, **if** there is a value. If
317         * you provide a function to turn a T into a U, this is the function you use
318         * to turn an `Optional<T>` into an `Optional<U>`. If this **does** contain
319         * a value then the output will also contain a value (that value being the
320         * output of `mapper(this.value)`), and if this **does not** contain a value
321         * then neither will the output.
322         */
323        map(mapper) {
324            if (this.tag) {
325                return Optional.some(mapper(this.value));
326            }
327            else {
328                return Optional.none();
329            }
330        }
331        // --- Monad (name stolen from Haskell / maths) ---
332        /**
333         * Perform a transform on an `Optional` object, **if** there is a value.
334         * Unlike `map`, here the transform itself also returns an `Optional`.
335         */
336        bind(binder) {
337            if (this.tag) {
338                return binder(this.value);
339            }
340            else {
341                return Optional.none();
342            }
343        }
344        // --- Traversable (name stolen from Haskell / maths) ---
345        /**
346         * For a given predicate, this function finds out if there **exists** a value
347         * inside this `Optional` object that meets the predicate. In practice, this
348         * means that for `Optional`s that do not contain a value it returns false (as
349         * no predicate-meeting value exists).
350         */
351        exists(predicate) {
352            return this.tag && predicate(this.value);
353        }
354        /**
355         * For a given predicate, this function finds out if **all** the values inside
356         * this `Optional` object meet the predicate. In practice, this means that
357         * for `Optional`s that do not contain a value it returns true (as all 0
358         * objects do meet the predicate).
359         */
360        forall(predicate) {
361            return !this.tag || predicate(this.value);
362        }
363        filter(predicate) {
364            if (!this.tag || predicate(this.value)) {
365                return this;
366            }
367            else {
368                return Optional.none();
369            }
370        }
371        // --- Getters ---
372        /**
373         * Get the value out of the inside of the `Optional` object, using a default
374         * `replacement` value if the provided `Optional` object does not contain a
375         * value.
376         */
377        getOr(replacement) {
378            return this.tag ? this.value : replacement;
379        }
380        /**
381         * Get the value out of the inside of the `Optional` object, using a default
382         * `replacement` value if the provided `Optional` object does not contain a
383         * value.  Unlike `getOr`, in this method the `replacement` object is also
384         * `Optional` - meaning that this method will always return an `Optional`.
385         */
386        or(replacement) {
387            return this.tag ? this : replacement;
388        }
389        /**
390         * Get the value out of the inside of the `Optional` object, using a default
391         * `replacement` value if the provided `Optional` object does not contain a
392         * value. Unlike `getOr`, in this method the `replacement` value is
393         * "thunked" - that is to say that you don't pass a value to `getOrThunk`, you
394         * pass a function which (if called) will **return** the `value` you want to
395         * use.
396         */
397        getOrThunk(thunk) {
398            return this.tag ? this.value : thunk();
399        }
400        /**
401         * Get the value out of the inside of the `Optional` object, using a default
402         * `replacement` value if the provided Optional object does not contain a
403         * value.
404         *
405         * Unlike `or`, in this method the `replacement` value is "thunked" - that is
406         * to say that you don't pass a value to `orThunk`, you pass a function which
407         * (if called) will **return** the `value` you want to use.
408         *
409         * Unlike `getOrThunk`, in this method the `replacement` value is also
410         * `Optional`, meaning that this method will always return an `Optional`.
411         */
412        orThunk(thunk) {
413            return this.tag ? this : thunk();
414        }
415        /**
416         * Get the value out of the inside of the `Optional` object, throwing an
417         * exception if the provided `Optional` object does not contain a value.
418         *
419         * WARNING:
420         * You should only be using this function if you know that the `Optional`
421         * object **is not** empty (otherwise you're throwing exceptions in production
422         * code, which is bad).
423         *
424         * In tests this is more acceptable.
425         *
426         * Prefer other methods to this, such as `.each`.
427         */
428        getOrDie(message) {
429            if (!this.tag) {
430                throw new Error(message ?? 'Called getOrDie on None');
431            }
432            else {
433                return this.value;
434            }
435        }
436        // --- Interop with null and undefined ---
437        /**
438         * Creates an `Optional` value from a nullable (or undefined-able) input.
439         * Null, or undefined, is converted to `None`, and anything else is converted
440         * to `Some`.
441         */
442        static from(value) {
443            return isNonNullable(value) ? Optional.some(value) : Optional.none();
444        }
445        /**
446         * Converts an `Optional` to a nullable type, by getting the value if it
447         * exists, or returning `null` if it does not.
448         */
449        getOrNull() {
450            return this.tag ? this.value : null;
451        }
452        /**
453         * Converts an `Optional` to an undefined-able type, by getting the value if
454         * it exists, or returning `undefined` if it does not.
455         */
456        getOrUndefined() {
457            return this.value;
458        }
459        // --- Utilities ---
460        /**
461         * If the `Optional` contains a value, perform an action on that value.
462         * Unlike the rest of the methods on this type, `.each` has side-effects. If
463         * you want to transform an `Optional<T>` **into** something, then this is not
464         * the method for you. If you want to use an `Optional<T>` to **do**
465         * something, then this is the method for you - provided you're okay with not
466         * doing anything in the case where the `Optional` doesn't have a value inside
467         * it. If you're not sure whether your use-case fits into transforming
468         * **into** something or **doing** something, check whether it has a return
469         * value. If it does, you should be performing a transform.
470         */
471        each(worker) {
472            if (this.tag) {
473                worker(this.value);
474            }
475        }
476        /**
477         * Turn the `Optional` object into an array that contains all of the values
478         * stored inside the `Optional`. In practice, this means the output will have
479         * either 0 or 1 elements.
480         */
481        toArray() {
482            return this.tag ? [this.value] : [];
483        }
484        /**
485         * Turn the `Optional` object into a string for debugging or printing. Not
486         * recommended for production code, but good for debugging. Also note that
487         * these days an `Optional` object can be logged to the console directly, and
488         * its inner value (if it exists) will be visible.
489         */
490        toString() {
491            return this.tag ? `some(${this.value})` : 'none()';
492        }
493    }
494
495    const nativeSlice = Array.prototype.slice;
496    const nativeIndexOf = Array.prototype.indexOf;
497    const nativePush = Array.prototype.push;
498    const rawIndexOf = (ts, t) => nativeIndexOf.call(ts, t);
499    const indexOf$1 = (xs, x) => {
500        // The rawIndexOf method does not wrap up in an option. This is for performance reasons.
501        const r = rawIndexOf(xs, x);
502        return r === -1 ? Optional.none() : Optional.some(r);
503    };
504    const contains$2 = (xs, x) => rawIndexOf(xs, x) > -1;
505    const exists = (xs, pred) => {
506        for (let i = 0, len = xs.length; i < len; i++) {
507            const x = xs[i];
508            if (pred(x, i)) {
509                return true;
510            }
511        }
512        return false;
513    };
514    const map$3 = (xs, f) => {
515        // pre-allocating array size when it's guaranteed to be known
516        // http://jsperf.com/push-allocated-vs-dynamic/22
517        const len = xs.length;
518        const r = new Array(len);
519        for (let i = 0; i < len; i++) {
520            const x = xs[i];
521            r[i] = f(x, i);
522        }
523        return r;
524    };
525    // Unwound implementing other functions in terms of each.
526    // The code size is roughly the same, and it should allow for better optimisation.
527    // const each = function<T, U>(xs: T[], f: (x: T, i?: number, xs?: T[]) => void): void {
528    const each$e = (xs, f) => {
529        for (let i = 0, len = xs.length; i < len; i++) {
530            const x = xs[i];
531            f(x, i);
532        }
533    };
534    const eachr = (xs, f) => {
535        for (let i = xs.length - 1; i >= 0; i--) {
536            const x = xs[i];
537            f(x, i);
538        }
539    };
540    const partition$2 = (xs, pred) => {
541        const pass = [];
542        const fail = [];
543        for (let i = 0, len = xs.length; i < len; i++) {
544            const x = xs[i];
545            const arr = pred(x, i) ? pass : fail;
546            arr.push(x);
547        }
548        return { pass, fail };
549    };
550    const filter$5 = (xs, pred) => {
551        const r = [];
552        for (let i = 0, len = xs.length; i < len; i++) {
553            const x = xs[i];
554            if (pred(x, i)) {
555                r.push(x);
556            }
557        }
558        return r;
559    };
560    /*
561     * Groups an array into contiguous arrays of like elements. Whether an element is like or not depends on f.
562     *
563     * f is a function that derives a value from an element - e.g. true or false, or a string.
564     * Elements are like if this function generates the same value for them (according to ===).
565     *
566     *
567     * Order of the elements is preserved. Arr.flatten() on the result will return the original list, as with Haskell groupBy function.
568     *  For a good explanation, see the group function (which is a special case of groupBy)
569     *  http://hackage.haskell.org/package/base-4.7.0.0/docs/Data-List.html#v:group
570     */
571    const groupBy = (xs, f) => {
572        if (xs.length === 0) {
573            return [];
574        }
575        else {
576            let wasType = f(xs[0]); // initial case for matching
577            const r = [];
578            let group = [];
579            for (let i = 0, len = xs.length; i < len; i++) {
580                const x = xs[i];
581                const type = f(x);
582                if (type !== wasType) {
583                    r.push(group);
584                    group = [];
585                }
586                wasType = type;
587                group.push(x);
588            }
589            if (group.length !== 0) {
590                r.push(group);
591            }
592            return r;
593        }
594    };
595    const foldr = (xs, f, acc) => {
596        eachr(xs, (x, i) => {
597            acc = f(acc, x, i);
598        });
599        return acc;
600    };
601    const foldl = (xs, f, acc) => {
602        each$e(xs, (x, i) => {
603            acc = f(acc, x, i);
604        });
605        return acc;
606    };
607    const findUntil$1 = (xs, pred, until) => {
608        for (let i = 0, len = xs.length; i < len; i++) {
609            const x = xs[i];
610            if (pred(x, i)) {
611                return Optional.some(x);
612            }
613            else if (until(x, i)) {
614                break;
615            }
616        }
617        return Optional.none();
618    };
619    const find$2 = (xs, pred) => {
620        return findUntil$1(xs, pred, never);
621    };
622    const findIndex$2 = (xs, pred) => {
623        for (let i = 0, len = xs.length; i < len; i++) {
624            const x = xs[i];
625            if (pred(x, i)) {
626                return Optional.some(i);
627            }
628        }
629        return Optional.none();
630    };
631    const findLast

643        // With this change it will throw an error.
644        const r = [];
645        for (let i = 0, len = xs.length; i < len; ++i) {
646            // Ensure that each value is an array itself
647            if (!isArray$1(xs[i])) {
648                throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
649            }
650            nativePush.apply(r, xs[i]);
651        }
652        return r;
653    };
654    const bind$3 = (xs, f) => flatten$1(map$3(xs, f));
655    const forall = (xs, pred) => {
656        for (let i = 0, len = xs.length; i < len; ++i) {
657            const x = xs[i];
658            if (pred(x, i) !== true) {
659                return false;
660            }
661        }
662        return true;
663    };
664    const reverse = (xs) => {
665        const r = nativeSlice.call(xs, 0);
666        r.reverse();
667        return r;
668    };
669    const difference = (a1, a2) => filter$5(a1, (x) => !contains$2(a2, x));
670    const mapToObject = (xs, f) => {
671        const r = {};
672        for (let i = 0, len = xs.length; i < len; i++) {
673            const x = xs[i];
674            r[String(x)] = f(x, i);
675        }
676        return r;
677    };
678    const sort = (xs, comparator) => {
679        const copy = nativeSlice.call(xs, 0);
680        copy.sort(comparator);
681        return copy;
682    };
683    const get$b = (xs, i) => i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
684    const head = (xs) => get$b(xs, 0);
685    const last$2 = (xs) => get$b(xs, xs.length - 1);
686    const from = isFunction(Array.from) ? Array.from : (x) => nativeSlice.call(x);
687    const findMap = (arr, f) => {
688        for (let i = 0; i < arr.length; i++) {
689            const r = f(arr[i], i);
690            if (r.isSome()) {
691                return r;
692            }
693        }
694        return Optional.none();
695    };
696    const unique$1 = (xs, comparator) => {
697        const r = [];
698        const isDuplicated = isFunction(comparator) ?
699            (x) => exists(r, (i) => comparator(i, x)) :
700            (x) => contains$2(r, x);
701        for (let i = 0, len = xs.length; i < len; i++) {
702            const x = xs[i];
703            if (!isDuplicated(x)) {
704                r.push(x);
705            }
706        }
707        return r;
708    };
709
710    // There are many variations of Object iteration that are faster than the 'for-in' style:
711    // http://jsperf.com/object-keys-iteration/107
712    //
713    // Use the native keys if it is available (IE9+), otherwise fall back to manually filtering
714    const keys = Object.keys;
715    const hasOwnProperty$1 = Object.hasOwnProperty;
716    const each$d = (obj, f) => {
717        const props = keys(obj);
718        for (let k = 0, len = props.length; k < len; k++) {
719            const i = props[k];
720            const x = obj[i];
721            f(x, i);
722        }
723    };
724    const map$2 = (obj, f) => {
725        return tupleMap(obj, (x, i) => ({
726            k: i,
727            v: f(x, i)
728        }));
729    };
730    const tupleMap = (obj, f) => {
731        const r = {};
732        each$d(obj, (x, i) => {
733            const tuple = f(x, i);
734            r[tuple.k] = tuple.v;
735        });
736        return r;
737    };
738    const objAcc = (r) => (x, i) => {
739        r[i] = x;
740    };
741    const internalFilter = (obj, pred, onTrue, onFalse) => {
742        each$d(obj, (x, i) => {
743            (pred(x, i) ? onTrue : onFalse)(x, i);
744        });
745    };
746    const bifilter = (obj, pred) => {
747        const t = {};
748        const f = {};
749        internalFilter(obj, pred, objAcc(t), objAcc(f));
750        return { t, f };
751    };
752    const filter$4 = (obj, pred) => {
753        const t = {};
754        internalFilter(obj, pred, objAcc(t), noop);
755        return t;
756    };
757    const mapToArray = (obj, f) => {
758        const r = [];
759        each$d(obj, (value, name) => {
760            r.push(f(value, name));
761        });
762        return r;
763    };
764    const values = (obj) => {
765        return mapToArray(obj, identity);
766    };
767    const get$a

767 = (obj, key) => {
768        return has$2(obj, key) ? Optional.from(obj[key]) : Optional.none();
769    };
770    const has$2 = (obj, key) => hasOwnProperty$1.call(obj, key);
771    const hasNonNullableKey = (obj, key) => has$2(obj, key) && obj[key] !== undefined && obj[key] !== null;
772    const equal$1 = (a1, a2, eq = eqAny) => eqRecord(eq).eq(a1, a2);
773
774    /*
775     * Generates a church encoded ADT (https://en.wikipedia.org/wiki/Church_encoding)
776     * For syntax and use, look at the test code.
777     */
778    const generate$1 = (cases) => {
779        // validation
780        if (!isArray$1(cases)) {
781            throw new Error('cases must be an array');
782        }
783        if (cases.length === 0) {
784            throw new Error('there must be at least one case');
785        }
786        const constructors = [];
787        // adt is mutated to add the individual cases
788        const adt = {};
789        each$e(cases, (acase, count) => {
790            const keys$1 = keys(acase);
791            // validation
792            if (keys$1.length !== 1) {
793                throw new Error('one and only one name per case');
794            }
795            const key = keys$1[0];
796            const value = acase[key];
797            // validation
798            if (adt[key] !== undefined) {
799                throw new Error('duplicate key detected:' + key);
800            }
801            else if (key === 'cata') {
802                throw new Error('cannot have a case named cata (sorry)');
803            }
804            else if (!isArray$1(value)) {
805                // this implicitly checks if acase is an object
806                throw new Error('case arguments must be an array');
807            }
808            constructors.push(key);
809            //
810            // constructor for key
811            //
812            adt[key] = (...args) => {
813                const argLength = args.length;
814                // validation
815                if (argLength !== value.length) {
816                    throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
817                }
818                const match = (branches) => {
819                    const branchKeys = keys(branches);
820                    if (constructors.length !== branchKeys.length) {
821                        throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
822                    }
823                    const allReqd = forall(constructors, (reqKey) => {
824                        return contains$2(branchKeys, reqKey);
825                    });
826                    if (!allReqd) {
827                        throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
828                    }
829                    return branches[key].apply(null, args);
830                };
831                //
832                // the fold function for key
833                //
834                return {
835                    fold: (...foldArgs) => {
836                        // runtime validation
837                        if (foldArgs.length !== cases.length) {
838                            throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
839                        }
840                        const target = foldArgs[count];
841                        return target.apply(null, args);
842                    },
843                    match,
844                    // NOTE: Only for debugging.
845                    log: (label) => {
846                        // eslint-disable-next-line no-console
847                        console.log(label, {
848                            constructors,
849                            constructor: key,
850                            params: args
851                        });
852                    }
853                };
854            };
855        });
856        return adt;
857    };
858    const Adt = {
859        generate: generate$1
860    };
861
862    const Cell = (initial) => {
863        let value = initial;
864        const get = () => {
865            return value;
866        };
867        const set = (v) => {
868            value = v;
869        };
870        return {
871            get,
872            set
873        };
874    };
875
876    /**
877     * Creates a new `Result<T, E>` that **does** contain a value.
878     */
879    const value$2 = (value) => {
880        const applyHelper = (fn) => fn(value);
881        const constHelper = constant(value);
882        const outputHelper = () => output;
883        const output = {
884            // Debug info
885            tag: true,
886            inner: value,
887            // Actual Result methods
888            fold: (_onError, onValue) => onValue(value),
889            isValue: always,
890            isError: never,
891            map: (mapper) => Result.value(mapper(value)),
892            mapError: outputHelper,
893            bind: applyHelper,
894            exists: applyHelper,
895            forall: applyHelper,
896            getOr: constHelper,
897            or: outputHelper,
898            getOrThunk: constHelper,
899            orThunk: outputHelper,
900            getOrDie: constHelper,
901            each: (fn) => {
902                // Can't write the function inline because we don't want to return something by mistake
903                fn(value);
904            },
905            toOptional: () => Optional.some(value),
906        };
907        return output;
908    };
909    /**
910     * Creates a new `Result<T, E>` that **does not** contain a value, and therefore
911     * contains an error.
912     */
913    const error = (error) => {
914        const outputHelper = () => output;
915        const output = {
916            // Debug info
917            tag: false,
918            inner: error,
919            // Actual Result methods
920            fold: (onError, _onValue) => onError(error),
921            isValue: never,
922            isError: always,
923            map: outputHelper,
924            mapError: (mapper) => Result.error(mapper(error)),
925            bind: outputHelper,
926            exists: never,
927            forall: always,
928            getOr: identity,
929            or: identity,
930            getOrThunk: apply$1,
931            orThunk: apply$1,
932            getOrDie: die(String(error)),
933            each: noop,
934            toOptional: Optional.none,
935        };
936        return output;
937    };
938    /**
939     * Creates a new `Result<T, E>` from an `Optional<T>` and an `E`. If the
940     * `Optional` contains a value, so will the outputted `Result`. If it does not,
941     * the outputted `Result` will contain an error (and that error will be the
942     * error passed in).
943     */
944    const fromOption = (optional, err) => optional.fold(() => error(err), value$2);
945    const Result = {
946        value: value$2,
947        error,
948        fromOption
949    };
950
951    // Use window object as the global if it's available since CSP will block script evals
952    // eslint-disable-next-line @typescript-eslint/no-implied-eval
953    const Global = typeof window !== 'undefined' ? window : Function('return this;')();
954
955    /* eslint-disable no-bitwise */
956    const uuidV4Bytes = () => {
957        const bytes = window.crypto.getRandomValues(new Uint8Array(16));
958        // https://tools.ietf.org/html/rfc4122#section-4.1.3
959        // This will first bit mask away the most significant 4 bits (version octet)
960        // then mask in the v4 number we only care about v4 random version at this point so (byte & 0b00001111 | 0b01000000)
961        bytes[6] = bytes[6] & 15 | 64;
962        // https://tools.ietf.org/html/rfc4122#section-4.1.1
963        // This will first bit mask away the highest two bits then masks in the highest bit so (byte & 0b00111111 | 0b10000000)
964        // So it will set the Msb0=1 & Msb1=0 described by the "The variant specified in this document." row in the table
965        bytes[8] = bytes[8] & 63 | 128;
966        return bytes;
967    };
968    const uuidV4String = () => {
969        const uuid = uuidV4Bytes();
970        const getHexRange = (startIndex, endIndex) => {
971            let buff = '';
972            for (let i = startIndex; i <= endIndex; ++i) {
973                const hexByte = uuid[i].toString(16).padStart(2, '0');
974                buff += hexByte;
975            }
976            return buff;
977        };
978        // RFC 4122 UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
979        return `${getHexRange(0, 3)}-${getHexRange(4, 5)}-${getHexRange(6, 7)}-${getHexRange(8, 9)}-${getHexRange(10, 15)}`;
980    };
981
982    /**
983     * Adds two numbers, and wrap to a range.
984     * If the result overflows to the right, snap to the left.
985     * If the result overflows to the left, snap to the right.
986     */
987    // ASSUMPTION: Max will always be larger than min
988    const clamp$2 = (value, min, max) => Math.min(Math.max(value, min), max);
989    // 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
990    const random = () => window.crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;
991
992    /**
993     * Generate a unique identifier.
994     *
995     * The unique portion of the identifier only contains an underscore
996     * and digits, so that it may safely be used within HTML attributes.
997     *
998     * The chance of generating a non-unique identifier has been minimized
999     * by combining the current time, a random number and a one-up counter.
1000     *
1001     * generate :: String -> String
1002     */
1003    let unique = 0;
1004    const generate = (prefix) => {
1005        const date = new Date();
1006        const time = date.getTime();
1007        const random$1 = Math.floor(random() * 1000000000);
1008        unique++;
1009        return prefix + '_' + random$1 + unique + String(time);
1010    };
1011    /**
1012     * Generate a uuidv4 string
1013     * In accordance with RFC 4122 (https://datatracker.ietf.org/doc/html/rfc4122)
1014     */
1015    const uuidV4 = () => {
1016        if (window.isSecureContext) {
1017            return window.crypto.randomUUID();
1018        }
1019        else {
1020            return uuidV4String();
1021        }
1022    };
1023
1024    const shallow$1 = (old, nu) => {
1025        return nu;
1026    };
1027    const deep$1 = (old, nu) => {
1028        const bothObjects = isPlainObject(old) && isPlainObject(nu);
1029        return bothObjects ? deepMerge(old, nu) : nu;
1030    };
1031    const baseMerge = (merger) => {
1032        return (...objects) => {
1033            if (objects.length === 0) {
1034                throw new Error(`Can't merge zero objects`);
1035            }
1036            const ret = {};
1037            for (let j = 0; j < objects.length; j++) {
1038                const curObject = objects[j];
1039                for (const key in curObject) {
1040                    if (has$2(curObject, key)) {
1041                        ret[key] = merger(ret[key], curObject[key]);
1042                    }
1043                }
1044            }
1045            return ret;
1046        };
1047    };
1048    const deepMerge = baseMerge(deep$1);
1049    const merge$1 = baseMerge(shallow$1);
1050
1051    /**
1052     * **Is** the value stored inside this Optional object equal to `rhs`?
1053     */
1054    const is$4 = (lhs, rhs, comparator = tripleEquals) => lhs.exists((left) => comparator(left, rhs));
1055    /**
1056     * Are these two Optional objects equal? Equality here means either they're both
1057     * `Some` (and the values are equal under the comparator) or they're both `None`.
1058     */
1059    const equals = (lhs, rhs, comparator = tripleEquals) => lift2(lhs, rhs, comparator).getOr(lhs.isNone() && rhs.isNone());
1060    const cat = (arr) => {
1061        const r = [];
1062        const push = (x) => {
1063            r.push(x);
1064        };
1065        for (let i = 0; i < arr.length; i++) {
1066            arr[i].each(push);
1067        }
1068        return r;
1069    };
1070    /*
1071    Notes on the lift functions:
1072    - We used to have a generic liftN, but we were concerned about its type-safety, and the below variants were faster in microbenchmarks.
1073    - The getOrDie calls are partial functions, but are checked beforehand. This is faster and more convenient (but less safe) than folds.
1074    - && is used instead of a loop for simplicity and performance.
1075    */
1076    const lift2 = (oa, ob, f) => oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none();
1077    const lift3 = (oa, ob, oc, f) => oa.isSome() && ob.isSome() && oc.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie(), oc.getOrDie())) : Optional.none();
1078    const flatten = (oot) => oot.bind(identity);
1079    // This can help with type inference, by specifying the type param on the none case, so the caller doesn't have to.
1080    const someIf = (b, a) => b ? Optional.some(a) : Optional.none();
1081
1082    /** path :: ([String], JsObj?) -> JsObj */
1083    const path = (parts, scope) => {
1084        let o = scope !== undefined && scope !== null ? scope : Global;
1085        for (let i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
1086            o = o[parts[i]];
1087        }
1088        return o;
1089    };
1090    /** resolve :: (String, JsObj?) -> JsObj */
1091    const resolve$3 = (p, scope) => {
1092        const parts = p.split('.');
1093        return path(parts, scope);
1094    };
1095
1096    Adt.generate([
1097        { bothErrors: ['error1', 'error2'] },
1098        { firstError: ['error1', 'value2'] },
1099        { secondError: ['value1', 'error2'] },
1100        { bothValues: ['value1', 'value2'] }
1101    ]);
1102    /** partition :: [Result a] -> { errors: [String], values: [a] } */
1103    const partition$1 = (results) => {
1104        const errors = [];
1105        const values = [];
1106        each$e(results, (result) => {
1107            result.fold((err) => {
1108                errors.push(err);
1109            }, (value) => {
1110                values.push(value);
1111            });
1112        });
1113        return { errors, values };
1114    };
1115
1116    const singleton = (doRevoke) => {
1117        const subject = Cell(Optional.none());
1118        const revoke = () => subject.get().each(doRevoke);
1119        const clear = () => {
1120            revoke();
1121            subject.set(Optional.none());
1122        };
1123        const isSet = () => subject.get().isSome();
1124        const get = () => subject.get();
1125        const set = (s) => {
1126            revoke();
1127            subject.set(Optional.some(s));
1128        };
1129        return {
1130            clear,
1131            isSet,
1132            get,
1133            set
1134        };
1135    };
1136    const repeatable = (delay) => {
1137        const intervalId = Cell(Optional.none());
1138        const revoke = () => intervalId.get().each((id) => clearInterval(id));
1139        const clear = () => {
1140            revoke();
1141            intervalId.set(Optional.none());
1142        };
1143        const isSet = () => intervalId.get().isSome();
1144        const get = () => intervalId.get();
1145        const set = (functionToRepeat) => {
1146            revoke();
1147            intervalId.set(Optional.some(setInterval(functionToRepeat, delay)));
1148        };
1149        return {
1150            clear,
1151            isSet,
1152            get,
1153            set,
1154        };
1155    };
1156    const value$1 = () => {
1157        const subject = singleton(noop);
1158        const on = (f) => subject.get().each(f);
1159        return {
1160            ...subject,
1161            on
1162        };
1163    };
1164
1165    const removeFromStart = (str, numChars) => {
1166        return str.substring(numChars);
1167    };
1168
1169    const checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
1170    const removeLeading = (str, prefix) => {
1171        return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
1172    };
1173    const contains$1 = (str, substr, start = 0, end) => {
1174        const idx = str.indexOf(substr, start);
1175        if (idx !== -1) {
1176            return isUndefined(end) ? true : idx + substr.length <= end;
1177        }
1178        else {
1179            return false;
1180        }
1181    };
1182    /** Does 'str' start with 'prefix'?
1183     *  Note: all strings start with the empty string.
1184     *        More formally, for all strings x, startsWith(x, "").
1185     *        This is so that for all strings x and y, startsWith(y + x, y)
1186     */
1187    const startsWith = (str, prefix) => {
1188        return checkRange(str, prefix, 0);
1189    };
1190    /** Does 'str' end with 'suffix'?
1191     *  Note: all strings end with the empty string.
1192     *        More formally, for all strings x, endsWith(x, "").
1193     *        This is so that for all strings x and y, endsWith(x + y, y)
1194     */
1195    const endsWith = (str, suffix) => {
1196        return checkRange(str, suffix, str.length - suffix.length);
1197    };
1198    const blank = (r) => (s) => s.replace(r, '');
1199    /** removes all leading and trailing spaces */
1200    const trim$4 = blank(/^\s+|\s+$/g);
1201    const lTrim = blank(/^\s+/g);
1202    const rTrim = blank(/\s+$/g);
1203    const isNotEmpty = (s) => s.length > 0;
1204    const isEmpty$5 = (s) => !isNotEmpty(s);
1205    const repeat = (s, count) => count <= 0 ? '' : new Array(count + 1).join(s);
1206    const toInt = (value, radix = 10) => {
1207        const num = parseInt(value, radix);
1208        return isNaN(num) ? Optional.none() : Optional.some(num);
1209    };
1210
1211    // Run a function fn after rate ms. If another invocation occurs
1212    // during the time it is waiting, ignore it completely.
1213    const first$1 = (fn, rate) => {
1214        let timer = null;
1215        const cancel = () => {
1216            if (!isNull(timer)) {
1217                clearTimeout(timer);
1218                timer = null;
1219            }
1220        };
1221        const throttle = (...args) => {
1222            if (isNull(timer)) {
1223                timer = setTimeout(() => {
1224                    timer = null;
1225                    fn.apply(null, args);
1226                }, rate);
1227            }
1228        };
1229        return {
1230            cancel,
1231            throttle
1232        };
1233    };
1234    // Run a function fn after rate ms. If another invocation occurs
1235    // during the time it is waiting, reschedule the function again
1236    // with the new arguments.
1237    const last$1 = (fn, rate) => {
1238        let timer = null;
1239        const cancel = () => {
1240            if (!isNull(timer)) {
1241                clearTimeout(timer);
1242                timer = null;
1243            }
1244        };
1245        const throttle = (...args) => {
1246            cancel();
1247            timer = setTimeout(() => {
1248                timer = null;
1249                fn.apply(null, args);
1250            }, rate);
1251        };
1252        return {
1253            cancel,
1254            throttle
1255        };
1256    };
1257
1258    const cached = (f) => {
1259        let called = false;
1260        let r;
1261        return (...args) => {
1262            if (!called) {
1263                called = true;
1264                r = f.apply(null, args);
1265            }
1266            return r;
1267        };
1268    };
1269
1270    const zeroWidth = '\uFEFF';
1271    const nbsp = '\u00A0';
1272    const ellipsis = '\u2026';
1273    const isZwsp$2 = (char) => char === zeroWidth;
1274    const removeZwsp = (s) => s.replace(/\uFEFF/g, '');
1275
1276    const stringArray = (a) => {
1277        const all = {};
1278        each$e(a, (key) => {
1279            all[key] = {};
1280        });
1281        return keys(all);
1282    };
1283
1284    const isArrayLike = (o) => o.length !== undefined;
1285    const isArray = Array.isArray;
1286    const toArray$1 = (obj) => {
1287        if (!isArray(obj)) {
1288            const array = [];
1289            for (let i = 0, l = obj.length; i < l; i++) {
1290                array[i] = obj[i];
1291            }
1292            return array;
1293        }
1294        else {
1295            return obj;
1296        }
1297    };
1298    const each$c = (o, cb, s) => {
1299        if (!o) {
1300            return false;
1301        }
1302        s = s || o;
1303        if (isArrayLike(o)) {
1304            // Indexed arrays, needed for Safari
1305            for (let n = 0, l = o.length; n < l; n++) {
1306                if (cb.call(s, o[n], n, o) === false) {
1307                    return false;
1308                }
1309            }
1310        }
1311        else {
1312            // Hashtables
1313            for (const n in o) {
1314                if (has$2(o, n)) {
1315                    if (cb.call(s, o[n], n, o) === false) {
1316                        return false;
1317                    }
1318                }
1319            }
1320        }
1321        return true;
1322    };
1323    const map$1 = (array, callback) => {
1324        const out = [];
1325        each$c(array, (item, index) => {
1326            out.push(callback(item, index, array));
1327        });
1328        return out;
1329    };
1330    const filter$3 = (a, f) => {
1331        const o = [];
1332        each$c(a, (v, index) => {
1333            if (!f || f(v, index, a)) {
1334                o.push(v);
1335            }
1336        });
1337        return o;
1338    };
1339    const indexOf = (a, v) => {
1340        if (a) {
1341            for (let i = 0, l = a.length; i < l; i++) {
1342                if (a[i] === v) {
1343                    return i;
1344                }
1345            }
1346        }
1347        return -1;
1348    };
1349    const reduce = (collection, iteratee, accumulator, thisArg) => {
1350        let acc = isUndefined(accumulator) ? collection[0] : accumulator;
1351        for (let i = 0; i < collection.length; i++) {
1352            acc = iteratee.call(thisArg, acc, collection[i], i);
1353        }
1354        return acc;
1355    };
1356    const findIndex$1 = (array, predicate, thisArg) => {
1357        for (let i = 0, l = array.length; i < l; i++) {
1358            if (predicate.call(thisArg, array[i], i, array)) {
1359                return i;
1360            }
1361        }
1362        return -1;
1363    };
1364    const last = (collection) => collection[collection.length - 1];
1365
1366    const DeviceType = (os, browser, userAgent, mediaMatch) => {
1367        const isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
1368        const isiPhone = os.isiOS() && !isiPad;
1369        const isMobile = os.isiOS() || os.isAndroid();
1370        const isTouch = isMobile || mediaMatch('(pointer:coarse)');
1371        const isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');
1372        const isPhone = isiPhone || isMobile && !isTablet;
1373        const iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
1374        const isDesktop = !isPhone && !isTablet && !iOSwebview;
1375        return {
1376            isiPad: constant(isiPad),
1377            isiPhone: constant(isiPhone),
1378            isTablet: constant(isTablet),
1379            isPhone: constant(isPhone),
1380            isTouch: constant(isTouch),
1381            isAndroid: os.isAndroid,
1382            isiOS: os.isiOS,
1383            isWebView: constant(iOSwebview),
1384            isDesktop: constant(isDesktop)
1385        };
1386    };
1387
1388    const firstMatch = (regexes, s) => {
1389        for (let i = 0; i < regexes.length; i++) {
1390            const x = regexes[i];
1391            if (x.test(s)) {
1392                return x;
1393            }
1394        }
1395        return undefined;
1396    };
1397    const find$1 = (regexes, agent) => {
1398        const r = firstMatch(regexes, agent);
1399        if (!r) {
1400            return { major: 0, minor: 0 };
1401        }
1402        const group = (i) => {
1403            return Number(agent.replace(r, '$' + i));
1404        };
1405        return nu$3(group(1), group(2));
1406    };
1407    const detect$4 = (versionRegexes, agent) => {
1408        const cleanedAgent = String(agent).toLowerCase();
1409        if (versionRegexes.length === 0) {
1410            return unknown$2();
1411        }
1412        return find$1(versionRegexes, cleanedAgent);
1413    };
1414    const unknown$2 = () => {
1415        return nu$3(0, 0);
1416    };
1417    const nu$3 = (major, minor) => {
1418        return { major, minor };
1419    };
1420    const Version = {
1421        nu: nu$3,
1422        detect: detect$4,
1423        unknown: unknown$2
1424    };
1425
1426    const detectBrowser$1 = (browsers, userAgentData) => {
1427        return findMap(userAgentData.brands, (uaBrand) => {
1428            const lcBrand = uaBrand.brand.toLowerCase();
1429            return find$2(browsers, (browser) => lcBrand === browser.brand?.toLowerCase())
1430                .map((info) => ({
1431                current: info.name,
1432                version: Version.nu(parseInt(uaBrand.version, 10), 0)
1433            }));
1434        });
1435    };
1436
1437    const detect$3 = (candidates, userAgent) => {
1438        const agent = String(userAgent).toLowerCase();
1439        return find$2(candidates, (candidate) => {
1440            return candidate.search(agent);
1441        });
1442    };
1443    // They (browser and os) are the same at the moment, but they might
1444    // not stay that way.
1445    const detectBrowser = (browsers, userAgent) => {
1446        return detect$3(browsers, userAgent).map((browser) => {
1447            const version = Version.detect(browser.versionRegexes, userAgent);
1448            return {
1449                current: browser.name,
1450                version
1451            };
1452        });
1453    };
1454    const detectOs = (oses, userAgent) => {
1455        return detect$3(oses, userAgent).map((os) => {
1456            const version = Version.detect(os.versionRegexes, userAgent);
1457            return {
1458                current: os.name,
1459                version
1460            };
1461        });
1462    };
1463
1464    const normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
1465    const checkContains = (target) => {
1466        return (uastring) => {
1467            return contains$1(uastring, target);
1468        };
1469    };
1470    const browsers = [
1471        // This is legacy Edge
1472        {
1473            name: 'Edge',
1474            versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
1475            search: (uastring) => {
1476                return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
1477            }
1478        },
1479        // This is Google Chrome and Chromium Edge
1480        {
1481            name: 'Chromium',
1482            brand: 'Chromium',
1483            versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/, normalVersionRegex],
1484            search: (uastring) => {
1485                return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
1486            }
1487        },
1488        {
1489            name: 'IE',
1490            versionRegexes: [/.*?msie\ ?([0-9]+)\.([0-9]+).*/, /.*?rv:([0-9]+)\.([0-9]+).*/],
1491            search: (uastring) => {
1492                return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
1493            }
1494        },
1495        // INVESTIGATE: Is this still the Opera user agent?
1496        {
1497            name: 'Opera',
1498            versionRegexes: [normalVersionRegex, /.*?opera\/([0-9]+)\.([0-9]+).*/],
1499            search: checkContains('opera')
1500        },
1501        {
1502            name: 'Firefox',
1503            versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
1504            search: checkContains('firefox')
1505        },
1506        {
1507            name: 'Safari',
1508            versionRegexes: [normalVersionRegex, /.*?cpu os ([0-9]+)_([0-9]+).*/],
1509            search: (uastring) => {
1510                return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
1511            }
1512        }
1513    ];
1514    const oses = [
1515        {
1516            name: 'Windows',
1517            search: checkContains('win'),
1518            versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
1519        },
1520        {
1521            name: 'iOS',
1522            search: (uastring) => {
1523                return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
1524            },
1525            versionRegexes: [/.*?version\/\ ?([0-9]+)\.([0-9]+).*/, /.*cpu os ([0-9]+)_([0-9]+).*/, /.*cpu iphone os ([0-9]+)_([0-9]+).*/]
1526        },
1527        {
1528            name: 'Android',
1529            search: checkContains('android'),
1530            versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
1531        },
1532        {
1533            name: 'macOS',
1534            search: checkContains('mac os x'),
1535            versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
1536        },
1537        {
1538            name: 'Linux',
1539            search: checkContains('linux'),
1540            versionRegexes: []
1541        },
1542        { name: 'Solaris',
1543            search: checkContains('sunos'),
1544            versionRegexes: []
1545        },
1546        {
1547            name: 'FreeBSD',
1548            search: checkContains('freebsd'),
1549            versionRegexes: []
1550        },
1551        {
1552            name: 'ChromeOS',
1553            search: checkContains('cros'),
1554            versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
1555        }
1556    ];
1557    const PlatformInfo = {
1558        browsers: constant(browsers),
1559        oses: constant(oses)
1560    };
1561
1562    const edge = 'Edge';
1563    const chromium = 'Chromium';
1564    const ie = 'IE';
1565    const opera = 'Opera';
1566    const firefox = 'Firefox';
1567    const safari = 'Safari';
1568    const unknown$1 = () => {
1569        return nu$2({
1570            current: undefined,
1571            version: Version.unknown()
1572        });
1573    };
1574    const nu$2 = (info) => {
1575        const current = info.current;
1576        const version = info.version;
1577        const isBrowser = (name) => () => current === name;
1578        return {
1579            current,
1580            version,
1581            isEdge: isBrowser(edge),
1582            isChromium: isBrowser(chromium),
1583            // NOTE: isIe just looks too weird
1584            isIE: isBrowser(ie),
1585            isOpera: isBrowser(opera),
1586            isFirefox: isBrowser(firefox),
1587            isSafari: isBrowser(safari)
1588        };
1589    };
1590    const Browser = {
1591        unknown: unknown$1,
1592        nu: nu$2,
1593        edge: constant(edge),
1594        chromium: constant(chromium),
1595        ie: constant(ie),
1596        opera: constant(opera),
1597        firefox: constant(firefox),
1598        safari: constant(safari)
1599    };
1600
1601    const windows = 'Windows';
1602    const ios = 'iOS';
1603    const android = 'Android';
1604    const linux = 'Linux';
1605    const macos = 'macOS';
1606    const solaris = 'Solaris';
1607    const freebsd = 'FreeBSD';
1608    const chromeos = 'ChromeOS';
1609    // Though there is a bit of dupe with this and Browser, trying to
1610    // reuse code makes it much harder to follow and change.
1611    const unknown = () => {
1612        return nu$1({
1613            current: undefined,
1614            version: Version.unknown()
1615        });
1616    };
1617    const nu$1 = (info) => {
1618        const current = info.current;
1619        const version = info.version;
1620        const isOS = (name) => () => current === name;
1621        return {
1622            current,
1623            version,
1624            isWindows: isOS(windows),
1625            // TODO: Fix capitalisation
1626            isiOS: isOS(ios),
1627            isAndroid: isOS(android),
1628            isMacOS: isOS(macos),
1629            isLinux: isOS(linux),
1630            isSolaris: isOS(solaris),
1631            isFreeBSD: isOS(freebsd),
1632            isChromeOS: isOS(chromeos)
1633        };
1634    };
1635    const OperatingSystem = {
1636        unknown,
1637        nu: nu$1,
1638        windows: constant(windows),
1639        ios: constant(ios),
1640        android: constant(android),
1641        linux: constant(linux),
1642        macos: constant(macos),
1643        solaris: constant(solaris),
1644        freebsd: constant(freebsd),
1645        chromeos: constant(chromeos)
1646    };
1647
1648    const detect$2 = (userAgent, userAgentDataOpt, mediaMatch) => {
1649        const browsers = PlatformInfo.browsers();
1650        const oses = PlatformInfo.oses();
1651        const browser = userAgentDataOpt.bind((userAgentData) => detectBrowser$1(browsers, userAgentData))
1652            .orThunk(() => detectBrowser(browsers, userAgent))
1653            .fold(Browser.unknown, Browser.nu);
1654        const os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
1655        const deviceType = DeviceType(os, browser, userAgent, mediaMatch);
1656        return {
1657            browser,
1658            os,
1659            deviceType
1660        };
1661    };
1662    const PlatformDetection = {
1663        detect: detect$2
1664    };
1665
1666    const mediaMatch = (query) => window.matchMedia(query).matches;
1667    // IMPORTANT: Must be in a thunk, otherwise rollup thinks calling this immediately
1668    // causes side effects and won't tree shake this away
1669    // Note: navigator.userAgentData is not part of the native typescript types yet
1670    let platform$4 = cached(() => PlatformDetection.detect(window.navigator.userAgent, Optional.from((window.navigator.userAgentData)), mediaMatch));
1671    const detect$1 = () => platform$4();
1672
1673    const unsafe = (name, scope) => {
1674        return resolve$3(name, scope);
1675    };
1676    const getOrDie = (name, scope) => {
1677        const actual = unsafe(name, scope);
1678        if (actual === undefined || actual === null) {
1679            throw new Error(name + ' not available on this browser');
1680        }
1681        return actual;
1682    };
1683
1684    const getPrototypeOf$1 = Object.getPrototypeOf;
1685    /*
1686     * IE9 and above
1687     *
1688     * MDN no use on this one, but here's the link anyway:
1689     * https://developer.mozilla.org/en/docs/Web/API/HTMLElement
1690     */
1691    const sandHTMLElement = (scope) => {
1692        return getOrDie('HTMLElement', scope);
1693    };
1694    const isPrototypeOf = (x) => {
1695        // use Resolve to get the window object for x and just return undefined if it can't find it.
1696        // undefined scope later triggers using the global window.
1697        const scope = resolve$3('ownerDocument.defaultView', x);
1698        // TINY-7374: We can't rely on looking at the owner window HTMLElement as the element may have
1699        // been constructed in a different window and then appended to the current window document.
1700        return isObject(x) && (sandHTMLElement(scope).prototype.isPrototypeOf(x) || /^HTML\w*Element$/.test(getPrototypeOf$1(x).constructor.name));
1701    };
1702
1703    /**
1704     * This class contains various environment constants like browser versions etc.
1705     * Normally you don't want to sniff specific browser versions but sometimes you have
1706     * to when it's impossible to feature detect. So use this with care.
1707     *
1708     * @class tinymce.Env
1709     * @static
1710     */
1711    const userAgent = window.navigator.userAgent;
1712    const platform$3 = detect$1();
1713    const browser$3 = platform$3.browser;
1714    const os$1 = platform$3.os;
1715    const deviceType = platform$3.deviceType;
1716    const windowsPhone = userAgent.indexOf('Windows Phone') !== -1;
1717    const Env = {
1718        /**
1719         * Transparent image data url.
1720         *
1721         * @property transparentSrc
1722         * @type Boolean
1723         * @final
1724         */
1725        transparentSrc: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
1726        /**
1727         * Returns the IE document mode. For non IE browsers, this will fake IE 10 document mode.
1728         *
1729         * @property documentMode
1730         * @type Number
1731         */
1732        documentMode: browser$3.isIE() ? (document.documentMode || 7) : 10,
1733        cacheSuffix: null,
1734        container: null,
1735        /**
1736         * Constant if CSP mode is possible or not. Meaning we can't use script urls for the iframe.
1737         */
1738        canHaveCSP: !browser$3.isIE(),
1739        windowsPhone,
1740        /**
1741         * @include ../../../../../tools/docs/tinymce.Env.js
1742         */
1743        browser: {
1744            current: browser$3.current,
1745            version: browser$3.version,
1746            isChromium: browser$3.isChromium,
1747            isEdge: browser$3.isEdge,
1748            isFirefox: browser$3.isFirefox,
1749            isIE: browser$3.isIE,
1750            isOpera: browser$3.isOpera,
1751            isSafari: browser$3.isSafari
1752        },
1753        os: {
1754            current: os$1.current,
1755            version: os$1.version,
1756            isAndroid: os$1.isAndroid,
1757            isChromeOS: os$1.isChromeOS,
1758            isFreeBSD: os$1.isFreeBSD,
1759            isiOS: os$1.isiOS,
1760            isLinux: os$1.isLinux,
1761            isMacOS: os$1.isMacOS,
1762            isSolaris: os$1.isSolaris,
1763            isWindows: os$1.isWindows
1764        },
1765        deviceType: {
1766            isDesktop: deviceType.isDesktop,
1767            isiPad: deviceType.isiPad,
1768            isiPhone: deviceType.isiPhone,
1769            isPhone: deviceType.isPhone,
1770            isTablet: deviceType.isTablet,
1771            isTouch: deviceType.isTouch,
1772            isWebView: deviceType.isWebView
1773        }
1774    };
1775
1776    /**
1777     * This class contains various utility functions. These are also exposed
1778     * directly on the tinymce namespace.
1779     *
1780     * @class tinymce.util.Tools
1781     */
1782    /**
1783     * Removes whitespace from the beginning and end of a string.
1784     *
1785     * @method trim
1786     * @param {String} s String to remove whitespace from.
1787     * @return {String} New string with removed whitespace.
1788     */
1789    const whiteSpaceRegExp$1 = /^\s*|\s*$/g;
1790    const trim$3 = (str) => {
1791        return isNullable(str) ? '' : ('' + str).replace(whiteSpaceRegExp$1, '');
1792    };
1793    /**
1794     * Checks if a object is of a specific type for example an array.
1795     *
1796     * @method is
1797     * @param {Object} obj Object to check type of.
1798     * @param {String} type Optional type to check for.
1799     * @return {Boolean} true/false if the object is of the specified type.
1800     */
1801    const is$3 = (obj, type) => {
1802        if (!type) {
1803            return obj !== undefined;
1804        }
1805        if (type === 'array' && isArray(obj)) {
1806            return true;
1807        }
1808        return typeof obj === type;
1809    };
1810    /**
1811     * Makes a name/object map out of an array with names.
1812     *
1813     * @method makeMap
1814     * @param {Array/String} items Items to make map out of.
1815     * @param {String} delim Optional delimiter to split string by.
1816     * @param {Object} map Optional map to add items to.
1817     * @return {Object} Name/value map of items.
1818     */
1819    const makeMap$4 = (items, delim, map = {}) => {
1820        const resolvedItems = isString(items) ? items.split(delim || ',') : (items || []);
1821        let i = resolvedItems.length;
1822        while (i--) {
1823            map[resolvedItems[i]] = {};
1824        }
1825        return map;
1826    };
1827    /**
1828     * JavaScript does not protect hasOwnProperty method, so it is possible to overwrite it. This is
1829     * an object independent version.
1830     * Checks if the input object "<code>obj</code>" has the property "<code>prop</code>".
1831     *
1832     * @method hasOwnProperty
1833     * @param {Object} obj Object to check if the property exists.
1834     * @param {String} prop Name of a property on the object.
1835     * @returns {Boolean} true if the object has the specified property.
1836     */
1837    const hasOwnProperty = has$2;
1838    const extend$3 = (obj, ...exts) => {
1839        for (let i = 0; i < exts.length; i++) {
1840            const ext = exts[i];
1841            for (const name in ext) {
1842                if (has$2(ext, name)) {
1843                    const value = ext[name];
1844                    if (value !== undefined) {
1845                        obj[name] = value;
1846                    }
1847                }
1848            }
1849        }
1850        return obj;
1851    };
1852    /**
1853     * Executed the specified function for each item in a object tree.
1854     *
1855     * @method walk
1856     * @param {Object} o Object tree to walk though.
1857     * @param {Function} f Function to call for each item.
1858     * @param {String} n Optional name of collection inside the objects to walk for example childNodes.
1859     * @param {String} s Optional scope to execute the function in.
1860     */
1861    const walk$4 = function (o, f, n, s) {
1862        s = s || this;
1863        if (o) {
1864            if (n) {
1865                o = o[n];
1866            }
1867            each$c(o, (o, i) => {
1868                if (f.call(s, o, i, n) === false) {
1869                    return false;
1870                }
1871                else {
1872                    walk$4(o, f, n, s);
1873                    return true;
1874                }
1875            });
1876        }
1877    };
1878    /**
1879     * Resolves a string and returns the object from a specific structure.
1880     *
1881     * @method resolve
1882     * @param {String} n Path to resolve for example a.b.c.d.
1883     * @param {Object} o Optional object to search though, defaults to window.
1884     * @return {Object} Last object in path or null if it couldn't be resolved.
1885     * @example
1886     * // Resolve a path into an object reference
1887     * const obj = tinymce.resolve('a.b.c.d');
1888     */
1889    const resolve$2 = (n, o = window) => {
1890        const path = n.split('.');
1891        for (let i = 0, l = path.length; i < l; i++) {
1892            o = o[path[i]];
1893            if (!o) {
1894                break;
1895            }
1896        }
1897        return o;
1898    };
1899    /**
1900     * Splits a string but removes the whitespace before and after each value.
1901     *
1902     * @method explode
1903     * @param {String} s String to split.
1904     * @param {String} d Delimiter to split by.
1905     * @example
1906     * // Split a string into an array with a,b,c
1907     * const arr = tinymce.explode('a, b,   c');
1908     */
1909    const explode$3 = (s, d) => {
1910        if (isArray$1(s)) {
1911            return s;
1912        }
1913        else if (s === '') {
1914            return [];
1915        }
1916        else {
1917            return map$1(s.split(d || ','), trim$3);
1918        }
1919    };
1920    const _addCacheSuffix = (url) => {
1921        const cacheSuffix = Env.cacheSuffix;
1922        if (cacheSuffix) {
1923            url += (url.indexOf('?') === -1 ? '?' : '&') + cacheSuffix;
1924        }
1925        return url;
1926    };
1927    const Tools = {
1928        trim: trim$3,
1929        /**
1930         * Returns true/false if the object is an array or not.
1931         *
1932         * @method isArray
1933         * @param {Object} obj Object to check.
1934         * @return {Boolean} true/false state if the object is an array or not.
1935         */
1936        isArray: isArray,
1937        is: is$3,
1938        /**
1939         * Converts the specified object into a real JavaScript array.
1940         *
1941         * @method toArray
1942         * @param {Object} obj Object to convert into array.
1943         * @return {Array} Array object based in input.
1944         */
1945        toArray: toArray$1,
1946        makeMap: makeMap$4,
1947        /**
1948         * Performs an iteration of all items in a collection such as an object or array. This method will execute the
1949         * callback function for each item in the collection, if the callback returns false the iteration will terminate.
1950         * The callback has the following format: `cb(value, key_or_index)`.
1951         *
1952         * @method each
1953         * @param {Object} o Collection to iterate.
1954         * @param {Function} cb Callback function to execute for each item.
1955         * @param {Object} s Optional scope to execute the callback in.
1956         * @example
1957         * // Iterate an array
1958         * tinymce.each([ 1,2,3 ], (v, i) => {
1959         *   console.debug("Value: " + v + ", Index: " + i);
1960         * });
1961         *
1962         * // Iterate an object
1963         * tinymce.each({ a: 1, b: 2, c: 3 }, (v, k) => {
1964         *   console.debug("Value: " + v + ", Key: " + k);
1965         * });
1966         */
1967        each: each$c,
1968        /**
1969         * Creates a new array by the return value of each iteration function call. This enables you to convert
1970         * one array list into another.
1971         *
1972         * @method map
1973         * @param {Array} array Array of items to iterate.
1974         * @param {Function} callback Function to call for each item. It's return value will be the new value.
1975         * @return {Array} Array with new values based on function return values.
1976         */
1977        map: map$1,
1978        /**
1979         * Filters out items from the input array by calling the specified function for each item.
1980         * If the function returns false the item will be excluded if it returns true it will be included.
1981         *
1982         * @method grep
1983         * @param {Array} a Array of items to loop though.
1984         * @param {Function} f Function to call for each item. Include/exclude depends on it's return value.
1985         * @return {Array} New array with values imported and filtered based in input.
1986         * @example
1987         * // Filter out some items, this will return an array with 4 and 5
1988         * const items = tinymce.grep([ 1,2,3,4,5 ], (v) => v > 3);
1989         */
1990        grep: filter$3,
1991        /**
1992         * Returns an index of the item or -1 if item is not present in the array.
1993         *
1994         * @method inArray
1995         * @param {any} item Item to search for.
1996         * @param {Array} arr Array to search in.
1997         * @return {Number} index of the item or -1 if item was not found.
1998         */
1999        inArray: indexOf,
2000        hasOwn: hasOwnProperty,
2001        extend: extend$3,
2002        walk: walk$4,
2003        resolve: resolve$2,
2004        explode: explode$3,
2005        _addCacheSuffix
2006    };
2007
2008    const fromHtml$1 = (html, scope) => {
2009        const doc = scope || document;
2010        const div = doc.createElement('div');
2011        div.innerHTML = html;
2012        if (!div.hasChildNodes() || div.childNodes.length > 1) {
2013            const message = 'HTML does not have a single root node';
2014            // eslint-disable-next-line no-console
2015            console.error(message, html);
2016            throw new Error(message);
2017        }
2018        return fromDom$2(div.childNodes[0]);
2019    };
2020    const fromTag = (tag, scope) => {
2021        const doc = scope || document;
2022        const node = doc.createElement(tag);
2023        return fromDom$2(node);
2024    };
2025    const fromText = (text, scope) => {
2026        const doc = scope || document;
2027        const node = doc.createTextNode(text);
2028        return fromDom$2(node);
2029    };
2030    const fromDom$2 = (node) => {
2031        // TODO: Consider removing this check, but left atm for safety
2032        if (node === null || node === undefined) {
2033            throw new Error('Node cannot be null or undefined');
2034        }
2035        return {
2036            dom: node
2037        };
2038    };
2039    const fromPoint$2 = (docElm, x, y) => Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom$2);
2040    // tslint:disable-next-line:variable-name
2041    const SugarElement = {
2042        fromHtml: fromHtml$1,
2043        fromTag,
2044        fromText,
2045        fromDom: fromDom$2,
2046        fromPoint: fromPoint$2
2047    };
2048
2049    // NOTE: Mutates the range.
2050    const setStart = (rng, situ) => {
2051        situ.fold((e) => {
2052            rng.setStartBefore(e.dom);
2053        }, (e, o) => {
2054            rng.setStart(e.dom, o);
2055        }, (e) => {
2056            rng.setStartAfter(e.dom);
2057        });
2058    };
2059    const setFinish = (rng, situ) => {
2060        situ.fold((e) => {
2061            rng.setEndBefore(e.dom);
2062        }, (e, o) => {
2063            rng.setEnd(e.dom, o);
2064        }, (e) => {
2065            rng.setEndAfter(e.dom);
2066        });
2067    };
2068    const relativeToNative = (win, startSitu, finishSitu) => {
2069        const range = win.document.createRange();
2070        setStart(range, startSitu);
2071        setFinish(range, finishSitu);
2072        return range;
2073    };
2074    const exactToNative = (win, start, soffset, finish, foffset) => {
2075        const rng = win.document.createRange();
2076        rng.setStart(start.dom, soffset);
2077        rng.setEnd(finish.dom, foffset);
2078        return rng;
2079    };
2080
2081    const adt$3 = Adt.generate([
2082        { ltr: ['start', 'soffset', 'finish', 'foffset'] },
2083        { rtl: ['start', 'soffset', 'finish', 'foffset'] }
2084    ]);
2085    const fromRange = (win, type, range) => type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);
2086    const getRanges$1 = (win, selection) => selection.match({
2087        domRange: (rng) => {
2088            return {
2089                ltr: constant(rng),
2090                rtl: Optional.none
2091            };
2092        },
2093        relative: (startSitu, finishSitu) => {
2094            return {
2095                ltr: cached(() => relativeToNative(win, startSitu, finishSitu)),
2096                rtl: cached(() => Optional.some(relativeToNative(win, finishSitu, startSitu)))
2097            };
2098        },
2099        exact: (start, soffset, finish, foffset) => {
2100            return {
2101                ltr: cached(() => exactToNative(win, start, soffset, finish, foffset)),
2102                rtl: cached(() => Optional.some(exactToNative(win, finish, foffset, start, soffset)))
2103            };
2104        }
2105    });
2106    const doDiagnose = (win, ranges) => {
2107        // If we cannot create a ranged selection from start > finish, it could be RTL
2108        const rng = ranges.ltr();
2109        if (rng.collapsed) {
2110            // Let's check if it's RTL ... if it is, then reversing the direction will not be collapsed
2111            const reversed = ranges.rtl().filter((rev) => rev.collapsed === false);
2112            return reversed.map((rev) => 
2113            // We need to use "reversed" here, because the original only has one point (collapsed)
2114            adt$3.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset)).getOrThunk(() => fromRange(win, adt$3.ltr, rng));
2115        }
2116        else {
2117            return fromRange(win, adt$3.ltr, rng);
2118        }
2119    };
2120    const diagnose = (win, selection) => {
2121        const ranges = getRanges$1(win, selection);
2122        return doDiagnose(win, ranges);
2123    };
2124    adt$3.ltr;
2125    adt$3.rtl;
2126
2127    const COMMENT = 8;
2128    const DOCUMENT = 9;
2129    const DOCUMENT_FRAGMENT = 11;
2130    const ELEMENT = 1;
2131    const TEXT = 3;
2132
2133    const is$2 = (element, selector) => {
2134        const dom = element.dom;
2135        if (dom.nodeType !== ELEMENT) {
2136            return false;
2137        }
2138        else {
2139            const elem = dom;
2140            if (elem.matches !== undefined) {
2141                return elem.matches(selector);
2142            }
2143            else if (elem.msMatchesSelector !== undefined) {
2144                return elem.msMatchesSelector(selector);
2145            }
2146            else if (elem.webkitMatchesSelector !== undefined) {
2147                return elem.webkitMatchesSelector(selector);
2148            }
2149            else if (elem.mozMatchesSelector !== undefined) {
2150                // cast to any as mozMatchesSelector doesn't exist in TS DOM lib
2151                return elem.mozMatchesSelector(selector);
2152            }
2153            else {
2154                throw new Error('Browser lacks native selectors');
2155            } // unfortunately we can't throw this on startup :(
2156        }
2157    };
2158    const bypassSelector = (dom) => 
2159    // Only elements, documents and shadow roots support querySelector
2160    // shadow root element type is DOCUMENT_FRAGMENT
2161    dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT ||
2162        // IE fix for complex queries on empty nodes: http://jsfiddle.net/spyder/fv9ptr5L/
2163        dom.childElementCount === 0;
2164    const all = (selector, scope) => {
2165        const base = scope === undefined ? document : scope.dom;
2166        return bypassSelector(base) ? [] : map$3(base.querySelectorAll(selector), SugarElement.fromDom);
2167    };
2168    const one = (selector, scope) => {
2169        const base = scope === undefined ? document : scope.dom;
2170        return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom);
2171    };
2172
2173    const eq = (e1, e2) => e1.dom === e2.dom;
2174    // Returns: true if node e1 contains e2, otherwise false.
2175    // (returns false if e1===e2: A node does not contain itself).
2176    const contains = (e1, e2) => {
2177        const d1 = e1.dom;
2178        const d2 = e2.dom;
2179        return d1 === d2 ? false : d1.contains(d2);
2180    };
2181    const is$1 = is$2;
2182
2183    /**
2184     * Applies f repeatedly until it completes (by returning Optional.none()).
2185     *
2186     * Normally would just use recursion, but JavaScript lacks tail call optimisation.
2187     *
2188     * This is what recursion looks like when manually unravelled :)
2189     */
2190    const toArray = (target, f) => {
2191        const r = [];
2192        const recurse = (e) => {
2193            r.push(e);
2194            return f(e);
2195        };
2196        let cur = f(target);
2197        do {
2198            cur = cur.bind(recurse);
2199        } while (cur.isSome());
2200        return r;
2201    };
2202
2203    const name = (element) => {
2204        const r = element.dom.nodeName;
2205        return r.toLowerCase();
2206    };
2207    const type$1 = (element) => element.dom.nodeType;
2208    const isType = (t) => (element) => type$1(element) === t;
2209    const isComment$1 = (element) => type$1(element) === COMMENT || name(element) === '#comment';
2210    const isHTMLElement$1 = (element) => isElement$8(element) && isPrototypeOf(element.dom);
2211    const isElement$8 = isType(ELEMENT);
2212    const isText$c = isType(TEXT);
2213    const isDocument$2 = isType(DOCUMENT);
2214    const isDocumentFragment$1 = isType(DOCUMENT_FRAGMENT);
2215    const isTag = (tag) => (e) => isElement$8(e) && name(e) === tag;
2216
2217    /**
2218     * The document associated with the current element
2219     * NOTE: this will throw if the owner is null.
2220     */
2221    const owner$1 = (element) => SugarElement.fromDom(element.dom.ownerDocument);
2222    /**
2223     * If the element is a document, return it. Otherwise, return its ownerDocument.
2224     * @param dos
2225     */
2226    const documentOrOwner = (dos) => isDocument$2(dos) ? dos : owner$1(dos);
2227    const documentElement = (element) => SugarElement.fromDom(documentOrOwner(element).dom.documentElement);
2228    /**
2229     * The window element associated with the element
2230     * NOTE: this will throw if the defaultView is null.
2231     */
2232    const defaultView = (element) => SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
2233    const parent = (element) => Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
2234    const parentElement = (element) => Optional.from(element.dom.parentElement).map(SugarElement.fromDom);
2235    const parents$1 = (element, isRoot) => {
2236        const stop = isFunction(isRoot) ? isRoot : never;
2237        // This is used a *lot* so it needs to be performant, not recursive
2238        let dom = element.dom;
2239        const ret = [];
2240        while (dom.parentNode !== null && dom.parentNode !== undefined) {
2241            const rawParent = dom.parentNode;
2242            const p = SugarElement.fromDom(rawParent);
2243            ret.push(p);
2244            if (stop(p) === true) {
2245                break;
2246            }
2247            else {
2248                dom = rawParent;
2249            }
2250        }
2251        return ret;
2252    };
2253    const siblings = (element) => {
2254        // TODO: Refactor out children so we can just not add self instead of filtering afterwards
2255        const filterSelf = (elements) => filter$5(elements, (x) => !eq(element, x));
2256        return parent(element).map(children$

22561).map(filterSelf).getOr([]);
2257    };
2258    const prevSibling = (element) => Optional.from(element.dom.previousSibling).map(SugarElement.fromDom);
2259    const nextSibling = (element) => Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
2260    // This one needs to be reversed, so they're still in DOM order
2261    const prevSiblings = (element) => reverse(toArray(element, prevSibling));
2262    const nextSiblings = (element) => toArray(element, nextSibling);
2263    const children$1 = (element) => map$3(element.dom.childNodes, SugarElement.fromDom);
2264    const child$1 = (element, index) => {
2265        const cs = element.dom.childNodes;
2266        return Optional.from(cs[index]).map(SugarElement.fromDom);
2267    };
2268    const firstChild = (element) => child$1(element, 0);
2269    const lastChild = (element) => child$1(element, element.dom.childNodes.length - 1);
2270    const childNodesCount = (element) => element.dom.childNodes.length;
2271
2272    const getHead = (doc) => {
2273        /*
2274         * IE9 and above per
2275         * https://developer.mozilla.org/en-US/docs/Web/API/Document/head
2276         */
2277        const b = doc.dom.head;
2278        if (b === null || b === undefined) {
2279            throw new Error('Head is not available yet');
2280        }
2281        return SugarElement.fromDom(b);
2282    };
2283
2284    /**
2285     * Is the element a ShadowRoot?
2286     *
2287     * Note: this is insufficient to test if any element is a shadow root, but it is sufficient to differentiate between
2288     * a Document and a ShadowRoot.
2289     */
2290    const isShadowRoot = (dos) => isDocumentFragment$1(dos) && isNonNullable(dos.dom.host);
2291    const getRootNode = (e) => SugarElement.fromDom(e.dom.getRootNode());
2292    /** Where style tags need to go. ShadowRoot or document head */
2293    const getStyleContainer = (dos) => isShadowRoot(dos) ? dos : getHead(documentOrOwner(dos));
2294    /** Where content needs to go. ShadowRoot or document body */
2295    const getContentContainer = (dos) => 
2296    // Can't use SugarBody.body without causing a circular module reference (since SugarBody.inBody uses SugarShadowDom)
2297    isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
2298    /** If this element is in a ShadowRoot, return it. */
2299    const getShadowRoot = (e) => {
2300        const r = getRootNode(e);
2301        return isShadowRoot(r) ? Optional.some(r) : Optional.none();
2302    };
2303    /** Return the host of a ShadowRoot.
2304     *
2305     * This function will throw if Shadow DOM is unsupported in the browser, or if the host is null.
2306     * If you actually have a ShadowRoot, this shouldn't happen.
2307     */
2308    const getShadowHost = (e) => SugarElement.fromDom(e.dom.host);
2309    /**
2310     * When Events bubble up through a ShadowRoot, the browser changes the target to be the shadow host.
2311     * This function gets the "original" event target if possible.
2312     * This only works if the shadow tree is open - if the shadow tree is closed, event.target is returned.
2313     * See: https://developers.google.com/web/fundamentals/web-components/shadowdom#events
2314     */
2315    const getOriginalEventTarget = (event) => {
2316        if (isNonNullable(event.target)) {
2317            const el = SugarElement.fromDom(event.target);
2318            if (isElement$8(el) && isOpenShadowHost(el)) {
2319                // When target element is inside Shadow DOM we need to take first element from composedPath
2320                // otherwise we'll get Shadow Root parent, not actual target element.
2321                if (event.composed && event.composedPath) {
2322                    const composedPath = event.composedPath();
2323                    if (composedPath) {
2324                        return head(composedPath);
2325                    }
2326                }
2327            }
2328        }
2329        return Optional.from(event.target);
2330    };
2331    /** Return true if the element is a host of an open shadow root.
2332     *  Return false if the element is a host of a closed shadow root, or if the element is not a host.
2333     */
2334    const isOpenShadowHost = (element) => isNonNullable(element.dom.shadowRoot);
2335
2336    const mkEvent = (target, x, y, stop, prevent, kill, raw) => ({
2337        target,
2338        x,
2339        y,
2340        stop,
2341        prevent,
2342        kill,
2343        raw
2344    });
2345    /** Wraps an Event in an EventArgs structure.
2346     * The returned EventArgs structure has its target set to the "original" target if possible.
2347     * See SugarShadowDom.getOriginalEventTarget
2348     */
2349    const fromRawEvent = (rawEvent) => {
2350        const target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target));
2351        const stop = () => rawEvent.stopPropagation();
2352        const prevent = () => rawEvent.preventDefault();
2353        const kill = compose(prevent, stop); // more of a sequence than a compose, but same effect
2354        // FIX: Don't just expose the raw event. Need to identify what needs standardisation.
2355        return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent);
2356    };
2357    const handle$1 = (filter, handler) => (rawEvent) => {
2358        if (filter(rawEvent)) {
2359            handler(fromRawEvent(rawEvent));
2360        }
2361    };
2362    const binder = (element, event, filter, handler, useCapture) => {
2363        const wrapped = handle$1(filter, handler);
2364        // IE9 minimum
2365        element.dom.addEventListener(event, wrapped, useCapture);
2366        return {
2367            unbind: curry(unbind, element, event, wrapped, useCapture)
2368        };
2369    };
2370    const bind$2 = (element, event, filter, handler) => binder(element, event, filter, handler, false);
2371    const unbind = (element, event, handler, useCapture) => {
2372        // IE9 minimum
2373        element.dom.removeEventListener(event, handler, useCapture);
2374    };
2375
2376    const filter$2 = always; // no filter on plain DomEvents
2377    const bind$1 = (element, event, handler) => bind$2(element, event, filter$2, handler);
2378
2379    const getDocument = () => SugarElement.fromDom(document);
2380
2381    const focus$1 = (element, preventScroll = false) => element.dom.focus({ preventScroll });
2382    const hasFocus$1 = (element) => {
2383        const root = getRootNode(element).dom;
2384        return element.dom === root.activeElement;
2385    };
2386    // Note: assuming that activeElement will always be a HTMLElement (maybe we should add a runtime check?)
2387    const active = (root = getDocument()) => Optional.from(root.dom.activeElement).map(SugarElement.fromDom);
2388    /**
2389     * Return the descendant element that has focus.
2390     * Use instead of SelectorFind.descendant(container, ':focus')
2391     *  because the :focus selector relies on keyboard focus.
2392     */
2393    const search = (element) => active(getRootNode(element))
2394        .filter((e) => element.dom.contains(e.dom));
2395
2396    const before$4 = (marker, element) => {
2397        const parent$1 = parent(marker);
2398        parent$1.each((v) => {
2399            v.dom.insertBefore(element.dom, marker.dom);
2400        });
2401    };
2402    const after$4 = (marker, element) => {
2403        const sibling = nextSibling(marker);
2404        sibling.fold(() => {
2405            const parent$1 = parent(marker);
2406            parent$1.each((v) => {
2407                append$1(v, element);
2408            });
2409        }, (v) => {
2410            before$4(v, element);
2411        });
2412    };
2413    const prepend = (parent, element) => {
2414        const firstChild$1 = firstChild(parent);
2415        firstChild$1.fold(() => {
2416            append$1(parent, element);
2417        }, (v) => {
2418            parent.dom.insertBefore(element.dom, v.dom);
2419        });
2420    };
2421    const append$1 = (parent, element) => {
2422        parent.dom.appendChild(element.dom);
2423    };
2424    const wrap$2 = (element, wrapper) => {
2425        before$4(element, wrapper);
2426        append$1(wrapper, element);
2427    };
2428
2429    const before$3 = (marker, elements) => {
2430        each$e(elements, (x) => {
2431            before$4(marker, x);
2432        });
2433    };
2434    const after$3 = (marker, elements) => {
2435        each$e(elements, (x, i) => {
2436            const e = i === 0 ? marker : elements[i - 1];
2437            after$4(e, x);
2438        });
2439    };
2440    const append = (parent, elements) => {
2441        each$e(elements, (x) => {
2442            append$1(parent, x);
2443        });
2444    };
2445
2446    const rawSet = (dom, key, value) => {
2447        /*
2448         * JQuery coerced everything to a string, and silently did nothing on text node/null/undefined.
2449         *
2450         * We fail on those invalid cases, only allowing numbers and booleans.
2451         */
2452        if (isString(value) || isBoolean(value) || isNumber(value)) {
2453            dom.setAttribute(key, value + '');
2454        }
2455        else {
2456            // eslint-disable-next-line no-console
2457            console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
2458            throw new Error('Attribute value was not simple');
2459        }
2460    };
2461    const set$4 = (element, key, value) => {
2462        rawSet(element.dom, key, value);
2463    };
2464    const setAll$1 = (element, attrs) => {
2465        const dom = element.dom;
2466        each$d(attrs, (v, k) => {
2467            rawSet(dom, k, v);
2468        });
2469    };
2470    const get$9 = (element, key) => {
2471        const v = element.dom.getAttribute(key);
2472        // undefined is the more appropriate value for JS, and this matches JQuery
2473        return v === null ? undefined : v;
2474    };
2475    const getOpt = (element, key) => Optional.from(get$9(element, key));
2476    const has$1 = (element, key) => {
2477        const dom = element.dom;
2478        // return false for non-element nodes, no point in throwing an error
2479        return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
2480    };
2481    const remove$9 = (element, key) => {
2482        element.dom.removeAttribute(key);
2483    };
2484    const hasNone = (element) => {
2485        const attrs = element.dom.attributes;
2486        return attrs === undefined || attrs === null || attrs.length === 0;
2487    };
2488    const clone$4 = (element) => foldl(element.dom.attributes, (acc, attr) => {
2489        acc[attr.name] = attr.value;
2490        return acc;
2491    }, {});
2492
2493    const empty = (element) => {
2494        // shortcut "empty node" trick. Requires IE 9.
2495        element.dom.textContent = '';
2496        // If the contents was a single empty text node, the above doesn't remove it. But, it's still faster in general
2497        // than removing every child node manually.
2498        // The following is (probably) safe for performance as 99.9% of the time the trick works and
2499        // Traverse.children will return an empty array.
2500        each$e(children$1(element), (rogue) => {
2501            remove$8(rogue);
2502        });
2503    };
2504    const remove$8 = (element) => {
2505        const dom = element.dom;
2506        if (dom.parentNode !== null) {
2507            dom.parentNode.removeChild(dom);
2508        }
2509    };
2510    const unwrap = (wrapper) => {
2511        const children = children$1(wrapper);
2512        if (children.length > 0) {
2513            after$3(wrapper, children);
2514        }
2515        remove$8(wrapper);
2516    };
2517
2518    const clone$3 = (original, isDeep) => SugarElement.fromDom(original.dom.cloneNode(isDeep));
2519    /** Shallow clone - just the tag, no children */
2520    const shallow = (original) => clone$3(original, false);
2521    /** Deep clone - everything copied including children */
2522    const deep = (original) => clone$3(original, true);
2523    /** Shallow clone, with a new tag */
2524    const shallowAs = (original, tag) => {
2525        const nu = SugarElement.fromTag(tag);
2526        const attributes = clone$4(original);
2527        setAll$1(nu, attributes);
2528        return nu;
2529    };
2530    /** Change the tag name, but keep all children */
2531    const mutate = (original, tag) => {
2532        const nu = shallowAs(original, tag);
2533        after$4(original, nu);
2534        const children = children$1(original);
2535        append(nu, children);
2536        remove$8(original);
2537        return nu;
2538    };
2539
2540    const fromHtml = (html, scope) => {
2541        const doc = scope || document;
2542        const div = doc.createElement('div');
2543        div.innerHTML = html;
2544        return children$1(SugarElement.fromDom(div));
2545    };
2546    const fromDom$1 = (nodes) => map$3(nodes, SugarElement.fromDom);
2547
2548    const get$8 = (element) => element.dom.innerHTML;
2549    const set$3 = (element, content) => {
2550        const owner = owner$1(element);
2551        const docDom = owner.dom;
2552        // FireFox has *terrible* performance when using innerHTML = x
2553        const fragment = SugarElement.fromDom(docDom.createDocumentFragment());
2554        const contentElements = fromHtml(content, docDom);
2555        append(fragment, contentElements);
2556        empty(element);
2557        append$1(element, fragment);
2558    };
2559    const getOuter = (element) => {
2560        const container = SugarElement.fromTag('div');
2561        const clone = SugarElement.fromDom(element.dom.cloneNode(true));
2562        append$1(container, clone);
2563        return get$8(container);
2564    };
2565
2566    // some elements, such as mathml, don't have style attributes
2567    // others, such as angular elements, have style attributes that aren't a CSSStyleDeclaration
2568    const isSupported = (dom) => dom.style !== undefined && isFunction(dom.style.getPropertyValue);
2569
2570    // Node.contains() is very, very, very good performance
2571    // http://jsperf.com/closest-vs-contains/5
2572    const inBody = (element) => {
2573        // Technically this is only required on IE, where contains() returns false for text nodes.
2574        // But it's cheap enough to run everywhere and Sugar doesn't have platform detection (yet).
2575        const dom = isText$c(element) ? element.dom.parentNode : element.dom;
2576        // use ownerDocument.body to ensure this works inside iframes.
2577        // Normally contains is bad because an element "contains" itself, but here we want that.
2578        if (dom === undefined || dom === null || dom.ownerDocument === null) {
2579            return false;
2580        }
2581        const doc = dom.ownerDocument;
2582        return getShadowRoot(SugarElement.fromDom(dom)).fold(() => doc.body.contains(dom), compose1(inBody, getShadowHost));
2583    };
2584
2585    const internalSet = (dom, property, value) => {
2586        // This is going to hurt. Apologies.
2587        // JQuery coerces numbers to pixels for certain property names, and other times lets numbers through.
2588        // we're going to be explicit; strings only.
2589        if (!isString(value)) {
2590            // eslint-disable-next-line no-console
2591            console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
2592            throw new Error('CSS value must be a string: ' + value);
2593        }
2594        // removed: support for dom().style[property] where prop is camel case instead of normal property name
2595        if (isSupported(dom)) {
2596            dom.style.setProperty(property, value);
2597        }
2598    };
2599    const internalRemove = (dom, property) => {
2600        /*
2601         * IE9 and above - MDN doesn't have details, but here's a couple of random internet claims
2602         *
2603         * http://help.dottoro.com/ljopsjck.php
2604         * http://stackoverflow.com/a/7901886/7546
2605         */
2606        if (isSupported(dom)) {
2607            dom.style.removeProperty(property);
2608        }
2609    };
2610    const set$2 = (element, property, value) => {
2611        const dom = element.dom;
2612        internalSet(dom, property, value);
2613    };
2614    const setAll = (element, css) => {
2615        const dom = element.dom;
2616        each$d(css, (v, k) => {
2617            internalSet(dom, k, v);
2618        });
2619    };
2620    /*
2621     * NOTE: For certain properties, this returns the "used value" which is subtly different to the "computed value" (despite calling getComputedStyle).
2622     * Blame CSS 2.0.
2623     *
2624     * https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
2625     */
2626    const get$7 = (element, property) => {
2627        const dom = element.dom;
2628        /*
2629         * IE9 and above per
2630         * https://developer.mozilla.org/en/docs/Web/API/window.getComputedStyle
2631         *
2632         * Not in numerosity, because it doesn't memoize and looking this up dynamically in performance critical code would be horrendous.
2633         *
2634         * JQuery has some magic here for IE popups, but we don't really need that.
2635         * It also uses element.ownerDocument.defaultView to handle iframes but that hasn't been required since FF 3.6.
2636         */
2637        const styles = window.getComputedStyle(dom);
2638        const r = styles.getPropertyValue(property);
2639        // jquery-ism: If r is an empty string, check that the element is not in a document. If it isn't, return the raw value.
2640        // Turns out we do this a lot.
2641        return (r === '' && !inBody(element)) ? getUnsafeProperty(dom, property) : r;
2642    };
2643    // removed: support for dom().style[property] where prop is camel case instead of normal property name
2644    // empty string is what the browsers (IE11 and Chrome) return when the propertyValue doesn't exists.
2645    const getUnsafeProperty = (dom, property) => isSupported(dom) ? dom.style.getPropertyValue(property) : '';
2646    /*
2647     * Gets the raw value from the style attribute. Useful for retrieving "used values" from the DOM:
2648     * https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
2649     *
2650     * Returns NONE if the property isn't set, or the value is an empty string.
2651     */
2652    const getRaw$1 = (element, property) => {
2653        const dom = element.dom;
2654        const raw = getUnsafeProperty(dom, property);
2655        return Optional.from(raw).filter((r) => r.length > 0);
2656    };
2657    const getAllRaw = (element) => {
2658        const css = {};
2659        const dom = element.dom;
2660        if (isSupported(dom)) {
2661            for (let i = 0; i < dom.style.length; i++) {
2662                const ruleName = dom.style.item(i);
2663                css[ruleName] = dom.style[ruleName];
2664            }
2665        }
2666        return css;
2667    };
2668    const remove$7 = (element, property) => {
2669        const dom = element.dom;
2670        internalRemove(dom, property);
2671        if (is$4(getOpt(element, 'style').map(trim$4), '')) {
2672            // No more styles left, remove the style attribute as well
2673            remove$9(element, 'style');
2674        }
2675    };
2676    /* NOTE: This function is here for the side effect it triggers.
2677    The value itself is not used.
2678    Be sure to not use the return value, and that it is not removed by a minifier.
2679     */
2680    const reflow = (e) => e.dom.offsetWidth;
2681
2682    const Dimension = (name, getOffset) => {
2683        const set = (element, h) => {
2684            if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
2685                throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
2686            }
2687            const dom = element.dom;
2688            if (isSupported(dom)) {
2689                dom.style[name] = h + 'px';
2690            }
2691        };
2692        /*
2693         * jQuery supports querying width and height on the document and window objects.
2694         *
2695         * TBIO doesn't do this, so the code is removed to save space, but left here just in case.
2696         */
2697        /*
2698        var getDocumentWidth = (element) => {
2699          var dom = element.dom;
2700          if (Node.isDocument(element)) {
2701            var body = dom.body;
2702            var doc = dom.documentElement;
2703            return Math.max(
2704              body.scrollHeight,
2705              doc.scrollHeight,
2706              body.offsetHeight,
2707              doc.offsetHeight,
2708              doc.clientHeight
2709            );
2710          }
2711        };
2712      
2713        var getWindowWidth = (element) => {
2714          var dom = element.dom;
2715          if (dom.window === dom) {
2716            // There is no offsetHeight on a window, so use the clientHeight of the document
2717            return dom.document.documentElement.clientHeight;
2718          }
2719        };
2720      */
2721        const get = (element) => {
2722            const r = getOffset(element);
2723            // zero or null means non-standard or disconnected, fall back to CSS
2724            if (r <= 0 || r === null) {
2725                const css = get$7(element, name);
2726                // ugh this feels dirty, but it saves cycles
2727                return parseFloat(css) || 0;
2728            }
2729            return r;
2730        };
2731        // in jQuery, getOuter replicates (or uses) box-sizing: border-box calculations
2732        // although these calculations only seem relevant for quirks mode, and edge cases TBIO doesn't rely on
2733        const getOuter = get;
2734        const aggregate = (element, properties) => foldl(properties, (acc, property) => {
2735            const val = get$7(element, property);
2736            const value = val === undefined ? 0 : parseInt(val, 10);
2737            return isNaN(value) ? acc : acc + value;
2738        }, 0);
2739        const max = (element, value, properties) => {
2740            const cumulativeInclusions = aggregate(element, properties);
2741            // if max-height is 100px and your cumulativeInclusions is 150px, there is no way max-height can be 100px, so we return 0.
2742            const absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
2743            return absoluteMax;
2744        };
2745        return {
2746            set,
2747            get,
2748            getOuter,
2749            aggregate,
2750            max
2751        };
2752    };
2753
2754    const api$1 = Dimension('height', (element) => {
2755        // getBoundingClientRect gives better results than offsetHeight for tables with captions on Firefox
2756        const dom = element.dom;
2757        return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
2758    });
2759    const get$6 = (element) => api$1.get(element);
2760
2761    const r = (left, top) => {
2762        const translate = (x, y) => r(left + x, top + y);
2763        return {
2764            left,
2765            top,
2766            translate
2767        };
2768    };
2769    // tslint:disable-next-line:variable-name
2770    const SugarPosition = r;
2771
2772    const boxPosition = (dom) => {
2773        const box = dom.getBoundingClientRect();
2774        return SugarPosition(box.left, box.top);
2775    };
2776    // Avoids falsy false fallthrough
2777    const firstDefinedOrZero = (a, b) => {
2778        if (a !== undefined) {
2779            return a;
2780        }
2781        else {
2782            return b !== undefined ? b : 0;
2783        }
2784    };
2785    const absolute = (element) => {
2786        const doc = element.dom.ownerDocument;
2787        const body = doc.body;
2788        const win = doc.defaultView;
2789        const html = doc.documentElement;
2790        if (body === element.dom) {
2791            return SugarPosition(body.offsetLeft, body.offsetTop);
2792        }
2793        const scrollTop = firstDefinedOrZero(win?.pageYOffset, html.scrollTop);
2794        const scrollLeft = firstDefinedOrZero(win?.pageXOffset, html.scrollLeft);
2795        const clientTop = firstDefinedOrZero(html.clientTop, body.clientTop);
2796        const clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft);
2797        return viewport(element).translate(scrollLeft - clientLeft, scrollTop - clientTop);
2798    };
2799    const viewport = (element) => {
2800        const dom = element.dom;
2801        const doc = dom.ownerDocument;
2802        const body = doc.body;
2803        if (body === dom) {
2804            return SugarPosition(body.offsetLeft, body.offsetTop);
2805        }
2806        if (!inBody(element)) {
2807            return SugarPosition(0, 0);
2808        }
2809        return boxPosition(dom);
2810    };
2811
2812    // get scroll position (x,y) relative to document _doc (or global if not supplied)
2813    const get$5 = (_DOC) => {
2814        const doc = _DOC !== undefined ? _DOC.dom : document;
2815        // ASSUMPTION: This is for cross-browser support, body works for Safari & EDGE, and when we have an iframe body scroller
2816        const x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
2817        const y = doc.body.scrollTop || doc.documentElement.scrollTop;
2818        return SugarPosition(x, y);
2819    };
2820    // Scroll content to (x,y) relative to document _doc (or global if not supplied)
2821    const to = (x, y, _DOC) => {
2822        const doc = _DOC !== undefined ? _DOC.dom : document;
2823        const win = doc.defaultView;
2824        if (win) {
2825            win.scrollTo(x, y);
2826        }
2827    };
2828    // TBIO-4472 Safari 10 - Scrolling typeahead with keyboard scrolls page
2829    const intoView = (element, alignToTop) => {
2830        const isSafari = detect$1().browser.isSafari();
2831        // this method isn't in TypeScript
2832        if (isSafari && isFunction(element.dom.scrollIntoViewIfNeeded)) {
2833            element.dom.scrollIntoViewIfNeeded(false); // false=align to nearest edge
2834        }
2835        else {
2836            element.dom.scrollIntoView(alignToTop); // true=to top, false=to bottom
2837        }
2838    };
2839
2840    const NodeValue = (is, name) => {
2841        const get = (element) => {
2842            if (!is(element)) {
2843                throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
2844            }
2845            return getOption(element).getOr('');
2846        };
2847        const getOption = (element) => is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();
2848        const set = (element, value) => {
2849            if (!is(element)) {
2850                throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
2851            }
2852            element.dom.nodeValue = value;
2853        };
2854        return {
2855            get,
2856            getOption,
2857            set
2858        };
2859    };
2860
2861    const fromElements = (elements, scope) => {
2862        const doc = scope || document;
2863        const fragment = doc.createDocumentFragment();
2864        each$e(elements, (element) => {
2865            fragment.appendChild(element.dom);
2866        });
2867        return SugarElement.fromDom(fragment);
2868    };
2869
2870    const api = NodeValue(isText$c, 'text');
2871    const get$4 = (element) => api.get(element);
2872    const getOption = (element) => api.getOption(element);
2873    const set$1 = (element, value) => api.set(element, value);
2874
2875    // Methods for handling attributes that contain a list of values <div foo="alpha beta theta">
2876    const read$4 = (element, attr) => {
2877        const value = get$9(element, attr);
2878        return value === undefined || value === '' ? [] : value.split(' ');
2879    };
2880    const add$4 = (element, attr, id) => {
2881        const old = read$4(element, attr);
2882        const nu = old.concat([id]);
2883        set$4(element, attr, nu.join(' '));
2884        return true;
2885    };
2886    const remove$6 = (element, attr, id) => {
2887        const nu = filter$5(read$4(element, attr), (v) => v !== id);
2888        if (nu.length > 0) {
2889            set$4(element, attr, nu.join(' '));
2890        }
2891        else {
2892            remove$9(element, attr);
2893        }
2894        return false;
2895    };
2896
2897    var ClosestOrAncestor = (is, ancestor, scope, a, isRoot) => {
2898        if (is(scope, a)) {
2899            return Optional.some(scope);
2900        }
2901        else if (isFunction(isRoot) && isRoot(scope)) {
2902            return Optional.none();
2903        }
2904        else {
2905            return ancestor(scope, a, isRoot);
2906        }
2907    };
2908
2909    const ancestor$5 = (scope, predicate, isRoot) => {
2910        let element = scope.dom;
2911        const stop = isFunction(isRoot) ? isRoot : never;
2912        while (element.parentNode) {
2913            element = element.parentNode;
2914            const el = SugarElement.fromDom(element);
2915            if (predicate(el)) {
2916                return Optional.some(el);
2917            }
2918            else if (stop(el)) {
2919                break;
2920            }
2921        }
2922        return Optional.none();
2923    };
2924    const closest$5 = (scope, predicate, isRoot) => {
2925        // This is required to avoid ClosestOrAncestor passing the predicate to itself
2926        const is = (s, test) => test(s);
2927        return ClosestOrAncestor(is, ancestor$5, scope, predicate, isRoot);
2928    };
2929    const sibling$1 = (scope, predicate) => {
2930        const element = scope.dom;
2931        if (!element.parentNode) {
2932            return Optional.none();
2933        }
2934        return child(SugarElement.fromDom(element.parentNode), (x) => !eq(scope, x) && predicate(x));
2935    };
2936    const child = (scope, predicate) => {
2937        const pred = (node) => predicate(SugarElement.fromDom(node));
2938        const result = find$2(scope.dom.childNodes, pred);
2939        return result.map(SugarElement.fromDom);
2940    };
2941    const descendant$2 = (scope, predicate) => {
2942        const descend = (node) => {
2943            // tslint:disable-next-line:prefer-for-of
2944            for (let i = 0; i < node.childNodes.length; i++) {
2945                const child = SugarElement.fromDom(node.childNodes[i]);
2946                if (predicate(child)) {
2947                    return Optional.some(child);
2948                }
2949                const res = descend(node.childNodes[i]);
2950                if (res.isSome()) {
2951                    return res;
2952                }
2953            }
2954            return Optional.none();
2955        };
2956        return descend(scope.dom);
2957    };
2958
2959    const ancestor$4 = (scope, selector, isRoot) => ancestor$5(scope, (e) => is$2(e, selector), isRoot);
2960    const descendant$1 = (scope, selector) => one(selector, scope);
2961    // Returns Some(closest ancestor element (sugared)) matching 'selector' up to isRoot, or None() otherwise
2962    const closest$4 = (scope, selector, isRoot) => {
2963        const is = (element, selector) => is$2(element, selector);
2964        return ClosestOrAncestor(is, ancestor$4, scope, selector, isRoot);
2965    };
2966
2967    // 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.
2968    const supports = (element) => element.dom.classList !== undefined;
2969    const get$3 = (element) => read$4(element, 'class');
2970    const add$3 = (element, clazz) => add$4(element, 'class', clazz);
2971    const remove$5 = (element, clazz) => remove$6(element, 'class', clazz);
2972    const toggle$2 = (element, clazz) => {
2973        if (contains$2(get$3(element), clazz)) {
2974            return remove$5(element, clazz);
2975        }
2976        else {
2977            return add$3(element, clazz);
2978        }
2979    };
2980
2981    /*
2982     * ClassList is IE10 minimum:
2983     * https://developer.mozilla.org/en-US/docs/Web/API/Element.classList
2984     *
2985     * Note that IE doesn't support the second argument to toggle (at all).
2986     * If it did, the toggler could be better.
2987     */
2988    const add$2 = (element, clazz) => {
2989        if (supports(element)) {
2990            element.dom.classList.add(clazz);
2991        }
2992        else {
2993            add$3(element, clazz);
2994        }
2995    };
2996    const cleanClass = (element) => {
2997        const classList = supports(element) ? element.dom.classList : get$3(element);
2998        // classList is a "live list", so this is up to date already
2999        if (classList.length === 0) {
3000            // No more classes left, remove the class attribute as well
3001            remove$9(element, 'class');
3002        }
3003    };
3004    const remove$4 = (element, clazz) => {
3005        if (supports(element)) {
3006            const classList = element.dom.classList;
3007            classList.remove(clazz);
3008        }
3009        else {
3010            remove$5(element, clazz);
3011        }
3012        cleanClass(element);
3013    };
3014    const toggle$1 = (element, clazz) => {
3015        const result = supports(element) ? element.dom.classList.toggle(clazz) : toggle$2(element, clazz);
3016        cleanClass(element);
3017        return result;
3018    };
3019    const has = (element, clazz) => supports(element) && element.dom.classList.contains(clazz);
3020
3021    /*
3022     * ClassList is IE10 minimum:
3023     * https://developer.mozilla.org/en-US/docs/Web/API/Element.classList
3024     */
3025    const add$1 = (element, classes) => {
3026        each$e(classes, (x) => {
3027            add$2(element, x);
3028        });
3029    };
3030    const remove$3 = (element, classes) => {
3031        each$e(classes, (x) => {
3032            remove$4(element, x);
3033        });
3034    };
3035
3036    const closest$3 = (target) => closest$4(target, '[contenteditable]');
3037    const isEditable$2 = (element, assumeEditable = false) => {
3038        if (inBody(element)) {
3039            return element.dom.isContentEditable;
3040        }
3041        else {
3042            // Find the closest contenteditable element and check if it's editable
3043            return closest$3(element).fold(constant(assumeEditable), (editable) => getRaw(editable) === 'true');
3044        }
3045    };
3046    const getRaw = (element) => element.dom.contentEditable;
3047    const set = (element, editable) => {
3048        element.dom.contentEditable = editable ? 'true' : 'false';
3049    };
3050
3051    const ancestors$1 = (scope, predicate, isRoot) => filter$5(parents$1(scope, isRoot), predicate);
3052    const children = (scope, predicate) => filter$5(children$1(scope), predicate);
3053    const descendants$1 = (scope, predicate) => {
3054        let result = [];
3055        // Recurse.toArray() might help here
3056        each$e(children$1(scope), (x) => {
3057            if (predicate(x)) {
3058                result = result.concat([x]);
3059            }
3060            result = result.concat(descendants$1(x, predicate));
3061        });
3062        return result;
3063    };
3064
3065    // For all of the following:
3066    //
3067    // jQuery does siblings of firstChild. IE9+ supports scope.dom.children (similar to Traverse.children but elements only).
3068    // Traverse should also do this (but probably not by default).
3069    //
3070    const ancestors = (scope, selector, isRoot) => 
3071    // It may surprise you to learn this is exactly what JQuery does
3072    // TODO: Avoid all this wrapping and unwrapping
3073    ancestors$1(scope, (e) => is$2(e, selector), isRoot);
3074    const descendants = (scope, selector) => all(selector, scope);
3075
3076    const ancestor$3 = (scope, predicate, isRoot) => ancestor$5(scope, predicate, isRoot).isSome();
3077    const sibling = (scope, predicate) => sibling$1(scope, predicate).isSome();
3078    const descendant = (scope, predicate) => descendant$2(scope, predicate).isSome();
3079
3080    const ancestor$2 = (element, target) => ancestor$3(element, curry(eq, target));
3081
3082    const ancestor$1 = (scope, selector, isRoot) => ancestor$4(scope, selector, isRoot).isSome();
3083    const closest$2 = (scope, selector, isRoot) => closest$4(scope, selector, isRoot).isSome();
3084
3085    const ensureIsRoot = (isRoot) => isFunction(isRoot) ? isRoot : never;
3086    const ancestor = (scope, transform, isRoot) => {
3087        let element = scope.dom;
3088        const stop = ensureIsRoot(isRoot);
3089        while (element.parentNode) {
3090            element = element.parentNode;
3091            const el = SugarElement.fromDom(element);
3092            const transformed = transform(el);
3093            if (transformed.isSome()) {
3094                return transformed;
3095            }
3096            else if (stop(el)) {
3097                break;
3098            }
3099        }
3100        return Optional.none();
3101    };
3102    const closest$1 = (scope, transform, isRoot) => {
3103        const current = transform(scope);
3104        const stop = ensureIsRoot(isRoot);
3105        return current.orThunk(() => stop(scope) ? Optional.none() : ancestor(scope, transform, stop));
3106    };
3107
3108    const isTextNodeWithCursorPosition = (el) => getOption(el).filter((text) => 
3109    // For the purposes of finding cursor positions only allow text nodes with content,
3110    // but trim removes &nbsp; and that's allowed
3111    text.trim().length !== 0 || text.indexOf(nbsp) > -1).isSome();
3112    const isContentEditableFalse$b = (elem) => isHTMLElement$1(elem) && (get$9(elem, 'contenteditable') === 'false');
3113    const elementsWithCursorPosition = ['img', 'br'];
3114    const isCursorPosition = (elem) => {
3115        const hasCursorPosition = isTextNodeWithCursorPosition(elem);
3116        return hasCursorPosition || contains$2(elementsWithCursorPosition, name(elem)) || isContentEditableFalse$b(elem);
3117    };
3118
3119    const first = (element) => descendant$2(element, isCursorPosition);
3120
3121    const create$c = (start, soffset, finish, foffset) => ({
3122        start,
3123        soffset,
3124        finish,
3125        foffset
3126    });
3127    // tslint:disable-next-line:variable-name
3128    const SimRange = {
3129        create: create$c
3130    };
3131
3132    const adt$2 = Adt.generate([
3133        { before: ['element'] },
3134        { on: ['element', 'offset'] },
3135        { after: ['element'] }
3136    ]);
3137    // Probably don't need this given that we now have "match"
3138    const cata = (subject, onBefore, onOn, onAfter) => subject.fold(onBefore, onOn, onAfter);
3139    const getStart$2 = (situ) => situ.fold(identity, identity, identity);
3140    const before$2 = adt$2.before;
3141    const on = adt$2.on;
3142    const after$2 = adt$2.after;
3143    // tslint:disable-next-line:variable-name
3144    const Situ = {
3145        before: before$2,
3146        on,
3147        after: after$2,
3148        cata,
3149        getStart: getStart$2
3150    };
3151
3152    // Consider adding a type for "element"
3153    const adt$1 = Adt.generate([
3154        { domRange: ['rng'] },
3155        { relative: ['startSitu', 'finishSitu'] },
3156        { exact: ['start', 'soffset', 'finish', 'foffset'] }
3157    ]);
3158    const exactFromRange = (simRange) => adt$1.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
3159    const getStart$1 = (selection) => selection.match({
3160        domRange: (rng) => SugarElement.fromDom(rng.startContainer),
3161        relative: (startSitu, _finishSitu) => Situ.getStart(startSitu),
3162        exact: (start, _soffset, _finish, _foffset) => start
3163    });
3164    const domRange = adt$1.domRange;
3165    const relative = adt$1.relative;
3166    const exact = adt$1.exact;
3167    const getWin = (selection) => {
3168        const start = getStart$1(selection);
3169        return defaultView(start);
3170    };
3171    // This is out of place but it's API so I can't remove it
3172    const range = SimRange.create;
3173    // tslint:disable-next-line:variable-name
3174    const SimSelection = {
3175        domRange,
3176        relative,
3177        exact,
3178        exactFromRange,
3179        getWin,
3180        range
3181    };
3182
3183    const caretPositionFromPoint = (doc, x, y) => Optional.from(doc.caretPositionFromPoint?.(x, y))
3184        .bind((pos) => {
3185        // It turns out that Firefox can return null for pos.offsetNode
3186        if (pos.offsetNode === null) {
3187            return Optional.none();
3188        }
3189        const r = doc.createRange();
3190        r.setStart(pos.offsetNode, pos.offset);
3191        r.collapse();
3192        return Optional.some(r);
3193    });
3194    const caretRangeFromPoint = (doc, x, y) => Optional.from(doc.caretRangeFromPoint?.(x, y));
3195    const availableSearch = (doc, x, y) => {
3196        if (doc.caretPositionFromPoint) {
3197            return caretPositionFromPoint(doc, x, y); // defined standard, firefox only
3198        }
3199        else if (doc.caretRangeFromPoint) {
3200            return caretRangeFromPoint(doc, x, y); // webkit/blink implementation
3201        }
3202        else {
3203            return Optional.none(); // unsupported browser
3204        }
3205    };
3206    const fromPoint$1 = (win, x, y) => {
3207        const doc = win.document;
3208        return availableSearch(doc, x, y).map((rng) => SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset));
3209    };
3210
3211    const beforeSpecial = (element, offset) => {
3212        // From memory, we don't want to use <br> directly on Firefox because it locks the keyboard input.
3213        // It turns out that <img> directly on IE locks the keyboard as well.
3214        // If the offset is 0, use before. If the offset is 1, use after.
3215        // TBIO-3889: Firefox Situ.on <input> results in a child of the <input>; Situ.before <input> results in platform inconsistencies
3216        const name$1 = name(element);
3217        if ('input' === name$1) {
3218            return Situ.after(element);
3219        }
3220        else if (!contains$2(['br', 'img'], name$1)) {
3221            return Situ.on(element, offset);
3222        }
3223        else {
3224            return offset === 0 ? Situ.before(element) : Situ.after(element);
3225        }
3226    };
3227    const preprocessRelative = (startSitu, finishSitu) => {
3228        const start = startSitu.fold(Situ.before, beforeSpecial, Situ.after);
3229        const finish = finishSitu.fold(Situ.before, beforeSpecial, Situ.after);
3230        return SimSelection.relative(start, finish);
3231    };
3232    const preprocessExact = (start, soffset, finish, foffset) => {
3233        const startSitu = beforeSpecial(start, soffset);
3234        const finishSitu = beforeSpecial(finish, foffset);
3235        return SimSelection.relative(startSitu, finishSitu);
3236    };
3237    const preprocess = (selection) => selection.match({
3238        domRange: (rng) => {
3239            const start = SugarElement.fromDom(rng.startContainer);
3240            const finish = SugarElement.fromDom(rng.endContainer);
3241            return preprocessExact(start, rng.startOffset, finish, rng.endOffset);
3242        },
3243        relative: preprocessRelative,
3244        exact: preprocessExact
3245    });
3246
3247    const toNative = (selection) => {
3248        const win = SimSelection.getWin(selection).dom;
3249        const getDomRange = (start, soffset, finish, foffset) => exactToNative(win, start, soffset, finish, foffset);
3250        const filtered = preprocess(selection);
3251        return diagnose(win, filtered).match({
3252            ltr: getDomRange,
3253            rtl: getDomRange
3254        });
3255    };
3256    const getAtPoint = (win, x, y) => fromPoint$1(win, x, y);
3257
3258    const get$2 = (_win) => {
3259        const win = _win === undefined ? window : _win;
3260        if (detect$1().browser.isFirefox()) {
3261            // TINY-7984: Firefox 91 is returning incorrect values for visualVie