https://eredaktor.no/_content/ExireNexus.Backstage/lib/tinymce/themes/silver/theme.oee66qcb6q.js

1/**
2 * TinyMCE version 8.8.2 (2026-07-27)
3 */
4
5(function () {
6    'use strict';
7
8    /* eslint-disable @typescript-eslint/no-wrapper-object-types */
9    const getPrototypeOf$2 = Object.getPrototypeOf;
10    const hasProto = (v, constructor, predicate) => {
11        if (predicate(v, constructor.prototype)) {
12            return true;
13        }
14        else {
15            // String-based fallback time
16            return v.constructor?.name === constructor.name;
17        }
18    };
19    const typeOf = (x) => {
20        const t = typeof x;
21        if (x === null) {
22            return 'null';
23        }
24        else if (t === 'object' && Array.isArray(x)) {
25            return 'array';
26        }
27        else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
28            return 'string';
29        }
30        else {
31            return t;
32        }
33    };
34    const isType$1 = (type) => (value) => typeOf(value) === type;
35    const isSimpleType = (type) => (value) => typeof value === type;
36    const eq$1 = (t) => (a) => t === a;
37    const is$2 = (value, constructor) => isObject(value) && hasProto(value, constructor, (o, proto) => getPrototypeOf$2(o) === proto);
38    const isString = isType$1('string');
39    const isObject = isType$1('object');
40    const isPlainObject = (value) => is$2(value, Object);
41    const isArray = isType$1('array');
42    const isNull = eq$1(null);
43    const isBoolean = isSimpleType('boolean');
44    const isUndefined = eq$1(undefined);
45    const isNullable = (a) => a === null || a === undefined;
46    const isNonNullable = (a) => !isNullable(a);
47    const isFunction = isSimpleType('function');
48    const isNumber = isSimpleType('number');
49    const isArrayOf = (value, pred) => {
50        if (isArray(value)) {
51            for (let i = 0, len = value.length; i < len; ++i) {
52                if (!(pred(value[i]))) {
53                    return false;
54                }
55            }
56            return true;
57        }
58        return false;
59    };
60
61    const noop = () => { };
62    const noarg = (f) => () => f();
63    /** Compose a unary function with an n-ary function */
64    const compose = (fa, fb) => {
65        return (...args) => {
66            return fa(fb.apply(null, args));
67        };
68    };
69    /** Compose two unary functions. Similar to compose, but avoids using Function.prototype.apply. */
70    const compose1 = (fbc, fab) => (a) => fbc(fab(a));
71    const constant$1 = (value) => {
72        return () => {
73            return value;
74        };
75    };
76    const identity = (x) => {
77        return x;
78    };
79    const tripleEquals = (a, b) => {
80        return a === b;
81    };
82    function curry(fn, ...initialArgs) {
83        return (...restArgs) => {
84            const all = initialArgs.concat(restArgs);
85            return fn.apply(null, all);
86        };
87    }
88    const not = (f) => (t) => !f(t);
89    const die = (msg) => {
90        return () => {
91            throw new Error(msg);
92        };
93    };
94    const apply$1 = (f) => {
95        return f();
96    };
97    const never = constant$1(false);
98    const always = constant$1

98(true);
99
100    /**
101     * The `Optional` type represents a value (of any type) that potentially does
102     * not exist. Any `Optional<T>` can either be a `Some<T>` (in which case the
103     * value does exist) or a `None` (in which case the value does not exist). This
104     * module defines a whole lot of FP-inspired utility functions for dealing with
105     * `Optional` objects.
106     *
107     * Comparison with null or undefined:
108     * - We don't get fancy null coalescing operators with `Optional`
109     * - We do get fancy helper functions with `Optional`
110     * - `Optional` support nesting, and allow for the type to still be nullable (or
111     * another `Optional`)
112     * - There is no option to turn off strict-optional-checks like there is for
113     * strict-null-checks
114     */
115    class Optional {
116        tag;
117        value;
118        // Sneaky optimisation: every instance of Optional.none is identical, so just
119        // reuse the same object
120        static singletonNone = new Optional(false);
121        // The internal representation has a `tag` and a `value`, but both are
122        // private: able to be console.logged, but not able to be accessed by code
123        constructor(tag, value) {
124            this.tag = tag;
125            this.value = value;
126        }
127        // --- Identities ---
128        /**
129         * Creates a new `Optional<T>` that **does** contain a value.
130         */
131        static some(value) {
132            return new Optional(true, value);
133        }
134        /**
135         * Create a new `Optional<T>` that **does not** contain a value. `T` can be
136         * any type because we don't actually have a `T`.
137         */
138        static none() {
139            return Optional.singletonNone;
140        }
141        /**
142         * Perform a transform on an `Optional` type. Regardless of whether this
143         * `Optional` contains a value or not, `fold` will return a value of type `U`.
144         * If this `Optional` does not contain a value, the `U` will be created by
145         * calling `onNone`. If this `Optional` does contain a value, the `U` will be
146         * created by calling `onSome`.
147         *
148         * For the FP enthusiasts in the room, this function:
149         * 1. Could be used to implement all of the functions below
150         * 2. Forms a catamorphism
151         */
152        fold(onNone, onSome) {
153            if (this.tag) {
154                return onSome(this.value);
155            }
156            else {
157                return onNone();
158            }
159        }
160        /**
161         * Determine if this `Optional` object contains a value.
162         */
163        isSome() {
164            return this.tag;
165        }
166        /**
167         * Determine if this `Optional` object **does not** contain a value.
168         */
169        isNone() {
170            return !this.tag;
171        }
172        // --- Functor (name stolen from Haskell / maths) ---
173        /**
174         * Perform a transform on an `Optional` object, **if** there is a value. If
175         * you provide a function to turn a T into a U, this is the function you use
176         * to turn an `Optional<T>` into an `Optional<U>`. If this **does** contain
177         * a value then the output will also contain a value (that value being the
178         * output of `mapper(this.value)`), and if this **does not** contain a value
179         * then neither will the output.
180         */
181        map(mapper) {
182            if (this.tag) {
183                return Optional.some(mapper(this.value));
184            }
185            else {
186                return Optional.none();
187            }
188        }
189        // --- Monad (name stolen from Haskell / maths) ---
190        /**
191         * Perform a transform on an `Optional` object, **if** there is a value.
192         * Unlike `map`, here the transform itself also returns an `Optional`.
193         */
194        bind(binder) {
195            if (this.tag) {
196                return binder(this.value);
197            }
198            else {
199                return Optional.none();
200            }
201        }
202        // --- Traversable (name stolen from Haskell / maths) ---
203        /**
204         * For a given predicate, this function finds out if there **exists** a value
205         * inside this `Optional` object that meets the predicate. In practice, this
206         * means that for `Optional`s that do not contain a value it returns false (as
207         * no predicate-meeting value exists).
208         */
209        exists(predicate) {
210            return this.tag && predicate(this.value);
211        }
212        /**
213         * For a given predicate, this function finds out if **all** the values inside
214         * this `Optional` object meet the predicate. In practice, this means that
215         * for `Optional`s that do not contain a value it returns true (as all 0
216         * objects do meet the predicate).
217         */
218        forall(predicate) {
219            return !this.tag || predicate(this.value);
220        }
221        filter(predicate) {
222            if (!this.tag || predicate(this.value)) {
223                return this;
224            }
225            else {
226                return Optional.none();
227            }
228        }
229        // --- Getters ---
230        /**
231         * Get the value out of the inside of the `Optional` object, using a default
232         * `replacement` value if the provided `Optional` object does not contain a
233         * value.
234         */
235        getOr(replacement) {
236            return this.tag ? this.value : replacement;
237        }
238        /**
239         * Get the value out of the inside of the `Optional` object, using a default
240         * `replacement` value if the provided `Optional` object does not contain a
241         * value.  Unlike `getOr`, in this method the `replacement` object is also
242         * `Optional` - meaning that this method will always return an `Optional`.
243         */
244        or(replacement) {
245            return this.tag ? this : replacement;
246        }
247        /**
248         * Get the value out of the inside of the `Optional` object, using a default
249         * `replacement` value if the provided `Optional` object does not contain a
250         * value. Unlike `getOr`, in this method the `replacement` value is
251         * "thunked" - that is to say that you don't pass a value to `getOrThunk`, you
252         * pass a function which (if called) will **return** the `value` you want to
253         * use.
254         */
255        getOrThunk(thunk) {
256            return this.tag ? this.value : thunk();
257        }
258        /**
259         * Get the value out of the inside of the `Optional` object, using a default
260         * `replacement` value if the provided Optional object does not contain a
261         * value.
262         *
263         * Unlike `or`, in this method the `replacement` value is "thunked" - that is
264         * to say that you don't pass a value to `orThunk`, you pass a function which
265         * (if called) will **return** the `value` you want to use.
266         *
267         * Unlike `getOrThunk`, in this method the `replacement` value is also
268         * `Optional`, meaning that this method will always return an `Optional`.
269         */
270        orThunk(thunk) {
271            return this.tag ? this : thunk();
272        }
273        /**
274         * Get the value out of the inside of the `Optional` object, throwing an
275         * exception if the provided `Optional` object does not contain a value.
276         *
277         * WARNING:
278         * You should only be using this function if you know that the `Optional`
279         * object **is not** empty (otherwise you're throwing exceptions in production
280         * code, which is bad).
281         *
282         * In tests this is more acceptable.
283         *
284         * Prefer other methods to this, such as `.each`.
285         */
286        getOrDie(message) {
287            if (!this.tag) {
288                throw new Error(message ?? 'Called getOrDie on None');
289            }
290            else {
291                return this.value;
292            }
293        }
294        // --- Interop with null and undefined ---
295        /**
296         * Creates an `Optional` value from a nullable (or undefined-able) input.
297         * Null, or undefined, is converted to `None`, and anything else is converted
298         * to `Some`.
299         */
300        static from(value) {
301            return isNonNullable(value) ? Optional.some(value) : Optional.none();
302        }
303        /**
304         * Converts an `Optional` to a nullable type, by getting the value if it
305         * exists, or returning `null` if it does not.
306         */
307        getOrNull() {
308            return this.tag ? this.value : null;
309        }
310        /**
311         * Converts an `Optional` to an undefined-able type, by getting the value if
312         * it exists, or returning `undefined` if it does not.
313         */
314        getOrUndefined() {
315            return this.value;
316        }
317        // --- Utilities ---
318        /**
319         * If the `Optional` contains a value, perform an action on that value.
320         * Unlike the rest of the methods on this type, `.each` has side-effects. If
321         * you want to transform an `Optional<T>` **into** something, then this is not
322         * the method for you. If you want to use an `Optional<T>` to **do**
323         * something, then this is the method for you - provided you're okay with not
324         * doing anything in the case where the `Optional` doesn't have a value inside
325         * it. If you're not sure whether your use-case fits into transforming
326         * **into** something or **doing** something, check whether it has a return
327         * value. If it does, you should be performing a transform.
328         */
329        each(worker) {
330            if (this.tag) {
331                worker(this.value);
332            }
333        }
334        /**
335         * Turn the `Optional` object into an array that contains all of the values
336         * stored inside the `Optional`. In practice, this means the output will have
337         * either 0 or 1 elements.
338         */
339        toArray() {
340            return this.tag ? [this.value] : [];
341        }
342        /**
343         * Turn the `Optional` object into a string for debugging or printing. Not
344         * recommended for production code, but good for debugging. Also note that
345         * these days an `Optional` object can be logged to the console directly, and
346         * its inner value (if it exists) will be visible.
347         */
348        toString() {
349            return this.tag ? `some(${this.value})` : 'none()';
350        }
351    }
352
353    const nativeSlice = Array.prototype.slice;
354    const nativeIndexOf = Array.prototype.indexOf;
355    const nativePush = Array.prototype.push;
356    const rawIndexOf = (ts, t) => nativeIndexOf.call(ts, t);
357    const indexOf

357 = (xs, x) => {
358        // The rawIndexOf method does not wrap up in an option. This is for performance reasons.
359        const r = rawIndexOf(xs, x);
360        return r === -1 ? Optional.none() : Optional.some(r);
361    };
362    const contains$2 = (xs, x) => rawIndexOf(xs, x) > -1;
363    const exists = (xs, pred) => {
364        for (let i = 0, len = xs.length; i < len; i++) {
365            const x = xs[i];
366            if (pred(x, i)) {
367                return true;
368            }
369        }
370        return false;
371    };
372    const range$2 = (num, f) => {
373        const r = [];
374        for (let i = 0; i < num; i++) {
375            r.push(f(i));
376        }
377        return r;
378    };
379    // It's a total micro optimisation, but these do make some difference.
380    // Particularly for browsers other than Chrome.
381    // - length caching
382    // http://jsperf.com/browser-diet-jquery-each-vs-for-loop/69
383    // - not using push
384    // http://jsperf.com/array-direct-assignment-vs-push/2
385    const chunk$1 = (array, size) => {
386        const r = [];
387        for (let i = 0; i < array.length; i += size) {
388            const s = nativeSlice.call(array, i, i + size);
389            r.push(s);
390        }
391        return r;
392    };
393    const map$2 = (xs, f) => {
394        // pre-allocating array size when it's guaranteed to be known
395        // http://jsperf.com/push-allocated-vs-dynamic/22
396        const len = xs.length;
397        const r = new Array(len);
398        for (let i = 0; i < len; i++) {
399            const x = xs[i];
400            r[i] = f(x, i);
401        }
402        return r;
403    };
404    // Unwound implementing other functions in terms of each.
405    // The code size is roughly the same, and it should allow for better optimisation.
406    // const each = function<T, U>(xs: T[], f: (x: T, i?: number, xs?: T[]) => void): void {
407    const each$1 = (xs, f) => {
408        for (let i = 0, len = xs.length; i < len; i++) {
409            const x = xs[i];
410            f(x, i);
411        }
412    };
413    const eachr = (xs, f) => {
414        for (let i = xs.length - 1; i >= 0; i--) {
415            const x = xs[i];
416            f(x, i);
417        }
418    };
419    const partition$3 = (xs, pred) => {
420        const pass = [];
421        const fail = [];
422        for (let i = 0, len = xs.length; i < len; i++) {
423            const x = xs[i];
424            const arr = pred(x, i) ? pass : fail;
425            arr.push(x);
426        }
427        return { pass, fail };
428    };
429    const filter$2 = (xs, pred) => {
430        const r = [];
431        for (let i = 0, len = xs.length; i < len; i++) {
432            const x = xs[i];
433            if (pred(x, i)) {
434                r.push(x);
435            }
436        }
437        return r;
438    };
439    const foldr = (xs, f, acc) => {
440        eachr(xs, (x, i) => {
441            acc = f(acc, x, i);
442        });
443        return acc;
444    };
445    const foldl = (xs, f, acc) => {
446        each$1(xs, (x, i) => {
447            acc = f(acc, x, i);
448        });
449        return acc;
450    };
451    const findUntil = (xs, pred, until) => {
452        for (let i = 0, len = xs.length; i < len; i++) {
453            const x = xs[i];
454            if (pred(x, i)) {
455                return Optional.some(x);
456            }
457            else if (until(x, i)) {
458                break;
459            }
460        }
461        return Optional.none();
462    };

463    const find$5 = (xs, pred) => {
464        return findUntil(xs, pred, never);
465    };
466    const findIndex$1 = (xs, pred) => {
467        for (let i = 0, len = xs.length; i < len; i++) {
468            const x = xs[i];
469            if (pred(x, i)) {
470                return Optional.some(i);
471            }
472        }
473        return Optional.none();
474    };
475    const flatten = (xs) => {
476        // Note, this is possible because push supports multiple arguments:
477        // http://jsperf.com/concat-push/6
478        // Note that in the past, concat() would silently work (very slowly) for array-like objects.
479        // With this change it will throw an error.
480        const r = [];
481        for (let i = 0, len = xs.length; i < len; ++i) {
482            // Ensure that each value is an array itself
483            if (!isArray(xs[i])) {
484                throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
485            }
486            nativePush.apply(r, xs[i]);
487        }
488        return r;
489    };
490    const bind$3 = (xs, f) => flatten(map$2(xs, f));
491    const forall = (xs, pred) => {
492        for (let i = 0, len = xs.length; i < len; ++i) {
493            const x = xs[i];
494            if (pred(x, i) !== true) {
495                return false;
496            }
497        }
498        return true;
499    };
500    const reverse = (xs) => {
501        const r = nativeSlice.call(xs, 0);
502        r.reverse();
503        return r;
504    };
505    const difference = (a1, a2) => filter$2(a1, (x) => !contains$2(a2, x));
506    const mapToObject = (xs, f) => {
507        const r = {};
508        for (let i = 0, len = xs.length; i < len; i++) {
509            const x = xs[i];
510            r[String(x)] = f(x, i);
511        }
512        return r;
513    };
514    const pure$2 = (x) => [x];
515    const sort = (xs, comparator) => {
516        const copy = nativeSlice.call(xs, 0);
517        copy.sort(comparator);
518        return copy;
519    };
520    const get$i = (xs, i) => i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
521    const head = (xs) => get$i(xs, 0);
522    const last$1 = (xs) => get$i(xs, xs.length - 1);
523    const from = isFunction(Array.from) ? Array.from : (x) => nativeSlice.call(x);
524    const findMap = (arr, f) => {
525        for (let i = 0; i < arr.length; i++) {
526            const r = f(arr[i], i);
527            if (r.isSome()) {
528                return r;
529            }
530        }
531        return Optional.none();
532    };
533
534    // There are many variations of Object iteration that are faster than the 'for-in' style:
535    // http://jsperf.com/object-keys-iteration/107
536    //
537    // Use the native keys if it is available (IE9+), otherwise fall back to manually filtering
538    const keys = Object.keys;
539    const hasOwnProperty = Object.hasOwnProperty;
540    const each = (obj, f) => {
541        const props = keys(obj);
542        for (let k = 0, len = props.length; k < len; k++) {
543            const i = props[k];
544            const x = obj[i];
545            f(x, i);
546        }
547    };
548    const map$1 = (obj, f) => {
549        return tupleMap(obj, (x, i) => ({
550            k: i,
551            v: f(x, i)
552        }));
553    };
554    const tupleMap = (obj, f) => {
555        const r = {};
556        each(obj, (x, i) => {
557            const tuple = f(x, i);
558            r[tuple.k] = tuple.v;
559        });
560        return r;
561    };
562    const objAcc = (r) => (x, i) => {
563        r[i] = x;
564    };
565    const internalFilter = (obj, pred, onTrue, onFalse) => {
566        each(obj, (x, i) => {
567            (pred(x, i) ? onTrue : onFalse)(x, i);
568        });
569    };
570    const bifilter = (obj, pred) => {
571        const t = {};
572        const f = {};
573        internalFilter(obj, pred, objAcc(t), objAcc(f));
574        return { t, f };
575    };
576    const filter$1 = (obj, pred) => {
577        const t = {};
578        internalFilter(obj, pred, objAcc(t), noop);
579        return t;
580    };
581    const mapToArray = (obj, f) => {
582        const r = [];
583        each(obj, (value, name) => {
584            r.push(f(value, name));
585        });
586        return r;
587    };
588    const find$4 = (obj, pred) => {
589        const props = keys(obj);
590        for (let k = 0, len = props.length; k < len; k++) {
591            const i = props[k];
592            const x = obj[i];
593            if (pred(x, i, obj)) {
594                return Optional.some(x);
595            }
596        }
597        return Optional.none();
598    };
599    const values = (obj) => {
600        return mapToArray(obj, identity);
601    };
602    const get$h = (obj, key) => {
603        return has$2(obj, key) ? Optional.from(obj[key]) : Optional.none();
604    };
605    const has$2 = (obj, key) => hasOwnProperty.call(obj, key);
606    const hasNonNullableKey = (obj, key) => has$2(obj, key) && obj[key] !== undefined && obj[key] !== null;
607
608    /*
609     * Generates a church encoded ADT (https://en.wikipedia.org/wiki/Church_encoding)
610     * For syntax and use, look at the test code.
611     */
612    const generate$7 = (cases) => {
613        // validation
614        if (!isArray(cases)) {
615            throw new Error('cases must be an array');
616        }
617        if (cases.length === 0) {
618            throw new Error('there must be at least one case');
619        }
620        const constructors = [];
621        // adt is mutated to add the individual cases
622        const adt = {};
623        each$1(cases, (acase, count) => {
624            const keys$1 = keys(acase);
625            // validation
626            if (keys$1.length !== 1) {
627                throw new Error('one and only one name per case');
628            }
629            const key = keys$1[0];
630            const value = acase[key];
631            // validation
632            if (adt[key] !== undefined) {
633                throw new Error('duplicate key detected:' + key);
634            }
635            else if (key === 'cata') {
636                throw new Error('cannot have a case named cata (sorry

1058    const cat = (arr) => {
1059        const r = [];
1060        const push = (x) => {
1061            r.push(x);
1062        };
1063        for (let i = 0; i < arr.length; i++) {
1064            arr[i].each(push);
1065        }
1066        return r;
1067    };
1068    const sequence = (arr) => {
1069        const r = [];
1070        for (let i = 0; i < arr.length; i++) {
1071            const x = arr[i];
1072            if (x.isSome()) {
1073                r.push(x.getOrDie());
1074            }
1075            else {
1076                return Optional.none();
1077            }
1078        }
1079        return Optional.some(r);
1080    };
1081    /*
1082    Notes on the lift functions:
1083    - We used to have a generic liftN, but we were concerned about its type-safety, and the below variants were faster in microbenchmarks.
1084    - The getOrDie calls are partial functions, but are checked beforehand. This is faster and more convenient (but less safe) than folds.
1085    - && is used instead of a loop for simplicity and performance.
1086    */
1087    const lift2 = (oa, ob, f) => oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none();
1088    const lift3 = (oa, ob, oc, f) => oa.isSome() && ob.isSome() && oc.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie(), oc.getOrDie())) : Optional.none();
1089    const mapFrom = (a, f) => (a !== undefined && a !== null) ? Optional.some(f(a)) : Optional.none();
1090    // This can help with type inference, by specifying the type param on the none case, so the caller doesn't have to.
1091    const someIf = (b, a) => b ? Optional.some(a) : Optional.none();
1092
1093    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
1094    const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
1095
1096    /** path :: ([String], JsObj?) -> JsObj */
1097    const path$1 = (parts, scope) => {
1098        let o = scope !== undefined && scope !== null ? scope : Global;
1099        for (let i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
1100            o = o[parts[i]];
1101        }
1102        return o;
1103    };
1104    /** resolve :: (String, JsObj?) -> JsObj */
1105    const resolve = (p, scope) => {
1106        const parts = p.split('.');
1107        return path$1(parts, scope);
1108    };
1109
1110    Adt.generate([
1111        { bothErrors: ['error1', 'error2'] },
1112        { firstError: ['error1', 'value2'] },
1113        { secondError: ['value1', 'error2'] },
1114        { bothValues: ['value1', 'value2'] }
1115    ]);
1116    /** partition :: [Result a] -> { errors: [String], values: [a] } */
1117    const partition$2 = (results) => {
1118        const errors = [];
1119        const values = [];
1120        each$1(results, (result) => {
1121            result.fold((err) => {
1122                errors.push(err);
1123            }, (value) => {
1124                values.push(value);
1125            });
1126        });
1127        return { errors, values };
1128    };
1129
1130    const singleton$1 = (doRevoke) => {
1131        const subject = Cell(Optional.none());
1132        const revoke = () => subject.get().each(doRevoke);
1133        const clear = () => {
1134            revoke();
1135            subject.set(Optional.none());
1136        };
1137        const isSet = () => subject.get().isSome();
1138        const get = () => subject.get();
1139        const set = (s) => {
1140            revoke();
1141            subject.set(Optional.some(s));
1142        };
1143        return {
1144            clear,
1145            isSet,
1146            get,
1147            set
1148        };
1149    };
1150    const destroyable = () => singleton$1((s) => s.destroy());
1151    const unbindable = () => singleton$1((s) => s.unbind());
1152    const value$2 = () => {
1153        const subject = singleton$1(noop);
1154        const on = (f) => subject.get().each(f);
1155        return {
1156            ...subject,
1157            on
1158        };
1159    };
1160
1161    const addToEnd = (str, suffix) => {
1162        return str + suffix;
1163    };
1164    const removeFromStart = (str, numChars) => {
1165        return str.substring(numChars);
1166    };
1167
1168    const checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
1169    const removeLeading = (str, prefix) => {
1170        return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
1171    };
1172    const ensureTrailing = (str, suffix) => {
1173        return endsWith(str, suffix) ? str : addToEnd(str, suffix);
1174    };
1175    const contains$1 = (str, substr, start = 0, end) => {
1176        const idx = str.indexOf(substr, start);
1177        if (idx !== -1) {
1178            return isUndefined(end) ? true : idx + substr.length <= end;
1179        }
1180        else {
1181            return false;
1182        }
1183    };
1184    /** Does 'str' start with 'prefix'?
1185     *  Note: all strings start with the empty string.
1186     *        More formally, for all strings x, startsWith(x, "").
1187     *        This is so that for all strings x and y, startsWith(y + x, y)
1188     */
1189    const startsWith = (str, prefix) => {
1190        return checkRange(str, prefix, 0);
1191    };
1192    /** Does 'str' end with 'suffix'?
1193     *  Note: all strings end with the empty string.
1194     *        More formally, for all strings x, endsWith(x, "").
1195     *        This is so that for all strings x and y, endsWith(x + y, y)
1196     */
1197    const endsWith = (str, suffix) => {
1198        return checkRange(str, suffix, str.length - suffix.length);
1199    };
1200    const blank = (r) => (s) => s.replace(r, '');
1201    /** removes all leading and trailing spaces */
1202    const trim$1 = blank(/^\s+|\s+$/g);
1203    const isNotEmpty = (s) => s.length > 0;
1204    const isEmpty = (s) => !isNotEmpty(s);
1205    const toFloat = (value) => {
1206        const num = parseFloat(value);
1207        return isNaN(num) ? Optional.none() : Optional.some(num);
1208    };
1209
1210    // Run a function fn after rate ms. If another invocation occurs
1211    // during the time it is waiting, update the arguments f will run
1212    // with (but keep the current schedule)
1213    const adaptable = (fn, rate) => {
1214        let timer = null;
1215        let args = null;
1216        const cancel = () => {
1217            if (!isNull(timer)) {
1218                clearTimeout(timer);
1219                timer = null;
1220                args = null;
1221            }
1222        };
1223        const throttle = (...newArgs) => {
1224            args = newArgs;
1225            if (isNull(timer)) {
1226                timer = setTimeout(() => {
1227                    const tempArgs = args;
1228                    timer = null;
1229                    args = null;
1230                    fn.apply(null, tempArgs);
1231                }, rate);
1232            }
1233        };
1234        return {
1235            cancel,
1236            throttle
1237        };
1238    };
1239    // Run a function fn after rate ms. If another invocation occurs
1240    // during the time it is waiting, ignore it completely.
1241    const first$1 = (fn, rate) => {
1242        let timer = null;
1243        const cancel = () => {
1244            if (!isNull(timer)) {
1245                clearTimeout(timer);
1246                timer = null;
1247            }
1248        };
1249        const throttle = (...args) => {
1250            if (isNull(timer)) {
1251                timer = setTimeout(() => {
1252                    timer = null;
1253                    fn.apply(null, args);
1254                }, rate);
1255            }
1256        };
1257        return {
1258            cancel,
1259            throttle
1260        };
1261    };
1262    // Run a function fn after rate ms. If another invocation occurs
1263    // during the time it is waiting, reschedule the function again
1264    // with the new arguments.
1265    const last = (fn, rate) => {
1266        let timer = null;
1267        const cancel = () => {
1268            if (!isNull(timer)) {
1269                clearTimeout(timer);
1270                timer = null;
1271            }
1272        };
1273        const throttle = (...args) => {
1274            cancel();
1275            timer = setTimeout(() => {
1276                timer = null;
1277                fn.apply(null, args);
1278            }, rate);
1279        };
1280        return {
1281            cancel,
1282            throttle
1283        };
1284    };
1285
1286    const cached = (f) => {
1287        let called = false;
1288        let r;
1289        return (...args) => {
1290            if (!called) {
1291                called = true;
1292                r = f.apply(null, args);
1293            }
1294            return r;
1295        };
1296    };
1297
1298    const zeroWidth = '\uFEFF';
1299    const nbsp = '\u00A0';
1300
1301    const fromHtml$2 = (html, scope) => {
1302        const doc = scope || document;
1303        const div = doc.createElement('div');
1304        div.innerHTML = html;
1305        if (!div.hasChildNodes() || div.childNodes.length > 1) {
1306            const message = 'HTML does not have a single root node';
1307            // eslint-disable-next-line no-console
1308            console.error(message, html);
1309            throw new Error(message);
1310        }
1311        return fromDom(div.childNodes[0]);
1312    };
1313    const fromTag = (tag, scope) => {
1314        const doc = scope || document;
1315        const node = doc.createElement(tag);
1316        return fromDom(node);
1317    };
1318    const fromText = (text, scope) => {
1319        const doc = scope || document;
1320        const node = doc.createTextNode(text);
1321        return fromDom(node);
1322    };
1323    const fromDom = (node) => {
1324        // TODO: Consider removing this check, but left atm for safety
1325        if (node === null || node === undefined) {
1326            throw new Error('Node cannot be null or undefined');
1327        }
1328        return {
1329            dom: node
1330        };
1331    };
1332    const fromPoint = (docElm, x, y) => Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
1333    // tslint:disable-next-line:variable-name
1334    const SugarElement = {
1335        fromHtml: fromHtml$2,
1336        fromTag,
1337        fromText,
1338        fromDom,
1339        fromPoint
1340    };
1341
1342    // NOTE: Mutates the range.
1343    const setStart = (rng, situ) => {
1344        situ.fold((e) => {
1345            rng.setStartBefore(e.dom);
1346        }, (e, o) => {
1347            rng.setStart(e.dom, o);
1348        }, (e) => {
1349            rng.setStartAfter(e.dom);
1350        });
1351    };
1352    const setFinish = (rng, situ) => {
1353        situ.fold((e) => {
1354            rng.setEndBefore(e.dom);
1355        }, (e, o) => {
1356            rng.setEnd(e.dom, o);
1357        }, (e) => {
1358            rng.setEndAfter(e.dom);
1359        });
1360    };
1361    const relativeToNative = (win, startSitu, finishSitu) => {
1362        const range = win.document.createRange();
1363        setStart(range, startSitu);
1364        setFinish(range, finishSitu);
1365        return range;
1366    };
1367    const exactToNative = (win, start, soffset, finish, foffset) => {
1368        const rng = win.document.createRange();
1369        rng.setStart(start.dom, soffset);
1370        rng.setEnd(finish.dom, foffset);
1371        return rng;
1372    };
1373    const toRect = (rect) => ({
1374        left: rect.left,
1375        top: rect.top,
1376        right: rect.right,
1377        bottom: rect.bottom,
1378        width: rect.width,
1379        height: rect.height
1380    });
1381    const getFirstRect$1 = (rng) => {
1382        const rects = rng.getClientRects();
1383        // ASSUMPTION: The first rectangle is the start of the selection
1384        const rect = rects.length > 0 ? rects[0] : rng.getBoundingClientRect();
1385        return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect) : Optional.none();
1386    };
1387    const getBounds$3 = (rng) => {
1388        const rect = rng.getBoundingClientRect();
1389        return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect) : Optional.none();
1390    };
1391
1392    const adt$a = Adt.generate([
1393        { ltr: ['start', 'soffset', 'finish', 'foffset'] },
1394        { rtl: ['start', 'soffset', 'finish', 'foffset'] }
1395    ]);
1396    const fromRange = (win, type, range) => type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);
1397    const getRanges = (win, selection) => selection.match({
1398        domRange: (rng) => {
1399            return {
1400                ltr: constant$1(rng),
1401                rtl: Optional.none
1402            };
1403        },
1404        relative: (startSitu, finishSitu) => {
1405            return {
1406                ltr: cached(() => relativeToNative(win, startSitu, finishSitu)),
1407                rtl: cached(() => Optional.some(relativeToNative(win, finishSitu, startSitu)))
1408            };
1409        },
1410        exact: (start, soffset, finish, foffset) => {
1411            return {
1412                ltr: cached(() => exactToNative(win, start, soffset, finish, foffset)),
1413                rtl: cached(() => Optional.some(exactToNative(win, finish, foffset, start, soffset)))
1414            };
1415        }
1416    });
1417    const doDiagnose = (win, ranges) => {
1418        // If we cannot create a ranged selection from start > finish, it could be RTL
1419        const rng = ranges.ltr();
1420        if (rng.collapsed) {
1421            // Let's check if it's RTL ... if it is, then reversing the direction will not be collapsed
1422            const reversed = ranges.rtl().filter((rev) => rev.collapsed === false);
1423            return reversed.map((rev) => 
1424            // We need to use "reversed" here, because the original only has one point (collapsed)
1425            adt$a.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset)).getOrThunk(() => fromRange(win, adt$a.ltr, rng));
1426        }
1427        else {
1428            return fromRange(win, adt$a.ltr, rng);
1429        }
1430    };
1431    const diagnose = (win, selection) => {
1432        const ranges = getRanges(win, selection);
1433        return doDiagnose(win, ranges);
1434    };
1435    const asLtrRange = (win, selection) => {
1436        const diagnosis = diagnose(win, selection);
1437        return diagnosis.match({
1438            ltr: (start, soffset, finish, foffset) => {
1439                const rng = win.document.createRange();
1440                rng.setStart(start.dom, soffset);
1441                rng.setEnd(finish.dom, foffset);
1442                return rng;
1443            },
1444            rtl: (start, soffset, finish, foffset) => {
1445                // NOTE: Reversing start and finish
1446                const rng = win.document.createRange();
1447                rng.setStart(finish.dom, foffset);
1448                rng.setEnd(start.dom, soffset);
1449                return rng;
1450            }
1451        });
1452    };
1453    adt$a.ltr;
1454    adt$a.rtl;
1455
1456    const DOCUMENT = 9;
1457    const DOCUMENT_FRAGMENT = 11;
1458    const ELEMENT = 1;
1459    const TEXT = 3;
1460
1461    const is = (element, selector) => {
1462        const dom = element.dom;
1463        if (dom.nodeType !== ELEMENT) {
1464            return false;
1465        }
1466        else {
1467            const elem = dom;
1468            if (elem.matches !== undefined) {
1469                return elem.matches(selector);
1470            }
1471            else if (elem.msMatchesSelector !== undefined) {
1472                return elem.msMatchesSelector(selector);
1473            }
1474            else if (elem.webkitMatchesSelector !== undefined) {
1475                return elem.webkitMatchesSelector(selector);
1476            }
1477            else if (elem.mozMatchesSelector !== undefined) {
1478                // cast to any as mozMatchesSelector doesn't exist in TS DOM lib
1479                return elem.mozMatchesSelector(selector);
1480            }
1481            else {
1482                throw new Error('Browser lacks native selectors');
1483            } // unfortunately we can't throw this on startup :(
1484        }
1485    };
1486    const bypassSelector = (dom) => 
1487    // Only elements, documents and shadow roots support querySelector
1488    // shadow root element type is DOCUMENT_FRAGMENT
1489    dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT ||
1490        // IE fix for complex queries on empty nodes: http://jsfiddle.net/spyder/fv9ptr5L/
1491        dom.childElementCount === 0;
1492    const all$3 = (selector, scope) => {
1493        const base = scope === undefined ? document : scope.dom;
1494        return bypassSelector(base) ? [] : map$2(base.querySelectorAll(selector), SugarElement.fromDom);
1495    };
1496    const one = (selector, scope) => {
1497        const base = scope === undefined ? document : scope.dom;
1498        return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom);
1499    };
1500
1501    const eq = (e1, e2) => e1.dom === e2.dom;
1502    // Returns: true if node e1 contains e2, otherwise false.
1503    // (returns false if e1===e2: A node does not contain itself).
1504    const contains = (e1, e2) => {
1505        const d1 = e1.dom;
1506        const d2 = e2.dom;
1507        return d1 === d2 ? false : d1.contains(d2);
1508    };
1509
1510    const DeviceType = (os, browser, userAgent, mediaMatch) => {
1511        const isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
1512        const isiPhone = os.isiOS() && !isiPad;
1513        const isMobile = os.isiOS() || os.isAndroid();
1514        const isTouch = isMobile || mediaMatch('(pointer:coarse)');
1515        const isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');
1516        const isPhone = isiPhone || isMobile && !isTablet;
1517        const iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
1518        const isDesktop = !isPhone && !isTablet && !iOSwebview;
1519        return {
1520            isiPad: constant$1(isiPad),
1521            isiPhone: constant$1(isiPhone),
1522            isTablet: constant$1(isTablet),
1523            isPhone: constant$1(isPhone),
1524            isTouch: constant$1(isTouch),
1525            isAndroid: os.isAndroid,
1526            isiOS: os.isiOS,
1527            isWebView: constant$1(iOSwebview),
1528            isDesktop: constant$1(isDesktop)
1529        };
1530    };
1531
1532    const firstMatch = (regexes, s) => {
1533        for (let i = 0; i < regexes.length; i++) {
1534            const x = regexes[i];
1535            if (x.test(s)) {
1536                return x;
1537            }
1538        }
1539        return undefined;
1540    };
1541    const find$3 = (regexes, agent) => {
1542        const r = firstMatch(regexes, agent);
1543        if (!r) {
1544            return { major: 0, minor: 0 };
1545        }
1546        const group = (i) => {
1547            return Number(agent.replace(r, '$' + i));
1548        };
1549        return nu$a(group(1), group(2));
1550    };
1551    const detect$4 = (versionRegexes, agent) => {
1552        const cleanedAgent = String(agent).toLowerCase();
1553        if (versionRegexes.length === 0) {
1554            return unknown$3();
1555        }
1556        return find$3(versionRegexes, cleanedAgent);
1557    };
1558    const unknown$3 = () => {
1559        return nu$a(0, 0);
1560    };
1561    const nu$a = (major, minor) => {
1562        return { major, minor };
1563    };
1564    const Version = {
1565        nu: nu$a,
1566        detect: detect$4,
1567        unknown: unknown$3
1568    };
1569
1570    const detectBrowser$1 = (browsers, userAgentData) => {
1571        return findMap(userAgentData.brands, (uaBrand) => {
1572            const lcBrand = uaBrand.brand.toLowerCase();
1573            return find$5(browsers, (browser) => lcBrand === browser.brand?.toLowerCase())
1574                .map((info) => ({
1575                current: info.name,
1576                version: Version.nu(parseInt(uaBrand.version, 10), 0)
1577            }));
1578        });
1579    };
1580
1581    const detect$3 = (candidates, userAgent) => {
1582        const agent = String(userAgent).toLowerCase();
1583        return find$5(candidates, (candidate) => {
1584            return candidate.search(agent);
1585        });
1586    };
1587    // They (browser and os) are the same at the moment, but they might
1588    // not stay that way.
1589    const detectBrowser = (browsers, userAgent) => {
1590        return detect$3(browsers, userAgent).map((browser) => {
1591            const version = Version.detect(browser.versionRegexes, userAgent);
1592            return {
1593                current: browser.name,
1594                version
1595            };
1596        });
1597    };
1598    const detectOs = (oses, userAgent) => {
1599        return detect$3(oses, userAgent).map((os) => {
1600            const version = Version.detect(os.versionRegexes, userAgent);
1601            return {
1602                current: os.name,
1603                version
1604            };
1605        });
1606    };
1607
1608    const normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
1609    const checkContains = (target) => {
1610        return (uastring) => {
1611            return contains$1(uastring, target);
1612        };
1613    };
1614    const browsers = [
1615        // This is legacy Edge
1616        {
1617            name: 'Edge',
1618            versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
1619            search: (uastring) => {
1620                return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
1621            }
1622        },
1623        // This is Google Chrome and Chromium Edge
1624        {
1625            name: 'Chromium',
1626            brand: 'Chromium',
1627            versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/, normalVersionRegex],
1628            search: (uastring) => {
1629                return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
1630            }
1631        },
1632        {
1633            name: 'IE',
1634            versionRegexes: [/.*?msie\ ?([0-9]+)\.([0-9]+).*/, /.*?rv:([0-9]+)\.([0-9]+).*/],
1635            search: (uastring) => {
1636                return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
1637            }
1638        },
1639        // INVESTIGATE: Is this still the Opera user agent?
1640        {
1641            name: 'Opera',
1642            versionRegexes: [normalVersionRegex, /.*?opera\/([0-9]+)\.([0-9]+).*/],
1643            search: checkContains('opera')
1644        },
1645        {
1646            name: 'Firefox',
1647            versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
1648            search: checkContains('firefox')
1649        },
1650        {
1651            name: 'Safari',
1652            versionRegexes: [normalVersionRegex, /.*?cpu os ([0-9]+)_([0-9]+).*/],
1653            search: (uastring) => {
1654                return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
1655            }
1656        }
1657    ];
1658    const oses = [
1659        {
1660            name: 'Windows',
1661            search: checkContains('win'),
1662            versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
1663        },
1664        {
1665            name: 'iOS',
1666            search: (uastring) => {
1667                return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
1668            },
1669            versionRegexes: [/.*?version\/\ ?([0-9]+)\.([0-9]+).*/, /.*cpu os ([0-9]+)_([0-9]+).*/, /.*cpu iphone os ([0-9]+)_([0-9]+).*/]
1670        },
1671        {
1672            name: 'Android',
1673            search: checkContains('android'),
1674            versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
1675        },
1676        {
1677            name: 'macOS',
1678            search: checkContains('mac os x'),
1679            versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
1680        },
1681        {
1682            name: 'Linux',
1683            search: checkContains('linux'),
1684            versionRegexes: []
1685        },
1686        { name: 'Solaris',
1687            search: checkContains('sunos'),
1688            versionRegexes: []
1689        },
1690        {
1691            name: 'FreeBSD',
1692            search: checkContains('freebsd'),
1693            versionRegexes: []
1694        },
1695        {
1696            name: 'ChromeOS',
1697            search: checkContains('cros'),
1698            versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
1699        }
1700    ];
1701    const PlatformInfo = {
1702        browsers: constant$1(browsers),
1703        oses: constant$1(oses)
1704    };
1705
1706    const edge = 'Edge';
1707    const chromium = 'Chromium';
1708    const ie = 'IE';
1709    const opera = 'Opera';
1710    const firefox = 'Firefox';
1711    const safari = 'Safari';
1712    const unknown$2 = () => {
1713        return nu$9({
1714            current: undefined,
1715            version: Version.unknown()
1716        });
1717    };
1718    const nu$9 = (info) => {
1719        const current = info.current;
1720        const version = info.version;
1721        const isBrowser = (name) => () => current === name;
1722        return {
1723            current,
1724            version,
1725            isEdge: isBrowser(edge),
1726            isChromium: isBrowser(chromium),
1727            // NOTE: isIe just looks too weird
1728            isIE: isBrowser(ie),
1729            isOpera: isBrowser(opera),
1730            isFirefox: isBrowser(firefox),
1731            isSafari: isBrowser(safari)
1732        };
1733    };
1734    const Browser = {
1735        unknown: unknown$2,
1736        nu: nu$9,
1737        edge: constant$1(edge),
1738        chromium: constant$1(chromium),
1739        ie: constant$1(ie),
1740        opera: constant$1(opera),
1741        firefox: constant$1(firefox),
1742        safari: constant$1(safari)
1743    };
1744
1745    const windows = 'Windows';
1746    const ios = 'iOS';
1747    const android = 'Android';
1748    const linux = 'Linux';
1749    const macos = 'macOS';
1750    const solaris = 'Solaris';
1751    const freebsd = 'FreeBSD';
1752    const chromeos = 'ChromeOS';
1753    // Though there is a bit of dupe with this and Browser, trying to
1754    // reuse code makes it much harder to follow and change.
1755    const unknown$1 = () => {
1756        return nu$8({
1757            current: undefined,
1758            version: Version.unknown()
1759        });
1760    };
1761    const nu$8 = (info) => {
1762        const current = info.current;
1763        const version = info.version;
1764        const isOS = (name) => () => current === name;
1765        return {
1766            current,
1767            version,
1768            isWindows: isOS(windows),
1769            // TODO: Fix capitalisation
1770            isiOS: isOS(ios),
1771            isAndroid: isOS(android),
1772            isMacOS: isOS(macos),
1773            isLinux: isOS(linux),
1774            isSolaris: isOS(solaris),
1775            isFreeBSD: isOS(freebsd),
1776            isChromeOS: isOS(chromeos)
1777        };
1778    };
1779    const OperatingSystem = {
1780        unknown: unknown$1,
1781        nu: nu$8,
1782        windows: constant$1(windows),
1783        ios: constant$1(ios),
1784        android: constant$1(android),
1785        linux: constant$1(linux),
1786        macos: constant$1(macos),
1787        solaris: constant$1(solaris),
1788        freebsd: constant$1(freebsd),
1789        chromeos: constant$1(chromeos)
1790    };
1791
1792    const detect$2 = (userAgent, userAgentDataOpt, mediaMatch) => {
1793        const browsers = PlatformInfo.browsers();
1794        const oses = PlatformInfo.oses();
1795        const browser = userAgentDataOpt.bind((userAgentData) => detectBrowser$1(browsers, userAgentData))
1796            .orThunk(() => detectBrowser(browsers, userAgent))
1797            .fold(Browser.unknown, Browser.nu);
1798        const os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
1799        const deviceType = DeviceType(os, browser, userAgent, mediaMatch);
1800        return {
1801            browser,
1802            os,
1803            deviceType
1804        };
1805    };
1806    const PlatformDetection = {
1807        detect: detect$2
1808    };
1809
1810    const mediaMatch = (query) => window.matchMedia(query).matches;
1811    // IMPORTANT: Must be in a thunk, otherwise rollup thinks calling this immediately
1812    // causes side effects and won't tree shake this away
1813    // Note: navigator.userAgentData is not part of the native typescript types yet
1814    let platform = cached(() => PlatformDetection.detect(window.navigator.userAgent, Optional.from((window.navigator.userAgentData)), mediaMatch));
1815    const detect$1 = () => platform();
1816
1817    const unsafe = (name, scope) => {
1818        return resolve(name, scope);
1819    };
1820    const getOrDie$1 = (name, scope) => {
1821        const actual = unsafe(name, scope);
1822        if (actual === undefined || actual === null) {
1823            throw new Error(name + ' not available on this browser');
1824        }
1825        return actual;
1826    };
1827
1828    const getPrototypeOf$1 = Object.getPrototypeOf;
1829    /*
1830     * IE9 and above
1831     *
1832     * MDN no use on this one, but here's the link anyway:
1833     * https://developer.mozilla.org/en/docs/Web/API/HTMLElement
1834     */
1835    const sandHTMLElement = (scope) => {
1836        return getOrDie$1('HTMLElement', scope);
1837    };
1838    const isPrototypeOf = (x) => {
1839        // use Resolve to get the window object for x and just return undefined if it can't find it.
1840        // undefined scope later triggers using the global window.
1841        const scope = resolve('ownerDocument.defaultView', x);
1842        // TINY-7374: We can't rely on looking at the owner window HTMLElement as the element may have
1843        // been constructed in a different window and then appended to the current window document.
1844        return isObject(x) && (sandHTMLElement(scope).prototype.isPrototypeOf(x) || /^HTML\w*Element$/.test(getPrototypeOf$1(x).constructor.name));
1845    };
1846
1847    const name$3 = (element) => {
1848        const r = element.dom.nodeName;
1849        return r.toLowerCase();
1850    };
1851    const type$1 = (element) => element.dom.nodeType;
1852    const isType = (t) => (element) => type$1(element) === t;
1853    const isHTMLElement = (element) => isElement$1(element) && isPrototypeOf(element.dom);
1854    const isElement$1 = isType(ELEMENT);
1855    const isText = isType(TEXT);
1856    const isDocument = isType(DOCUMENT);
1857    const isDocumentFragment = isType(DOCUMENT_FRAGMENT);
1858    const isTag = (tag) => (e) => isElement$1(e) && name$3(e) === tag;
1859
1860    /**
1861     * The document associated with the current element
1862     * NOTE: this will throw if the owner is null.
1863     */
1864    const owner$4 = (element) => SugarElement.fromDom(element.dom.ownerDocument);
1865    /**
1866     * If the element is a document, return it. Otherwise, return its ownerDocument.
1867     * @param dos
1868     */
1869    const documentOrOwner = (dos) => isDocument(dos) ? dos : owner$4(dos);
1870    const documentElement = (element) => SugarElement.fromDom(documentOrOwner(element).dom.documentElement);
1871    /**
1872     * The window element associated with the element
1873     * NOTE: this will throw if the defaultView is null.
1874     */
1875    const defaultView = (element) => SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
1876    const parent = (element) => Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
1877    // Cast down to just be SugarElement<Node>
1878    const parentNode = (element) => parent(element);
1879    const parentElement = (element) => Optional.from(element.dom.parentElement).map(SugarElement.fromDom);
1880    const parents = (element, isRoot) => {
1881        const stop = isFunction(isRoot) ? isRoot : never;
1882        // This is used a *lot* so it needs to be performant, not recursive
1883        let dom = element.dom;
1884        const ret = [];
1885        while (dom.parentNode !== null && dom.parentNode !== undefined) {
1886            const rawParent = dom.parentNode;
1887            const p = SugarElement.fromDom(rawParent);
1888            ret.push(p);
1889            if (stop(p) === true) {
1890                break;
1891            }
1892            else {
1893                dom = rawParent;
1894            }
1895        }
1896        return ret;
1897    };
1898    const offsetParent = (element) => Optional.from(element.dom.offsetParent).map(SugarElement.fromDom);
1899    const prevSibling = (element) => Optional.from(element.dom.previousSibling).map(SugarElement.fromDom);
1900    const nextSibling = (element) => Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
1901    const children = (element) => map$2(element.dom.childNodes, SugarElement.fromDom);
1902    const child$2 = (element, index) => {
1903        const cs = element.dom.childNodes;
1904        return Optional.from(cs[index]).map(SugarElement.fromDom);
1905    };
1906    const firstChild = (element) => child$2(element, 0);
1907    const spot = (element, offset) => ({
1908        element,
1909        offset
1910    });
1911    const leaf = (element, offset) => {
1912        const cs = children(element);
1913        return cs.length > 0 && offset < cs.length ? spot(cs[offset], 0) : spot(element, offset);
1914    };
1915
1916    const makeRange = (start, soffset, finish, foffset) => {
1917        const doc = owner$4(start);
1918        // TODO: We need to think about a better place to put native range creation code. Does it even belong in sugar?
1919        // Could the `Compare` checks (node.compareDocumentPosition) handle these situations better?
1920        const rng = doc.dom.createRange();
1921        rng.setStart(start.dom, soffset);
1922        rng.setEnd(finish.dom, foffset);
1923        return rng;
1924    };
1925    const after$2 = (start, soffset, finish, foffset) => {
1926        const r = makeRange(start, soffset, finish, foffset);
1927        const same = eq(start, finish) && soffset === foffset;
1928        return r.collapsed && !same;
1929    };
1930
1931    /**
1932     * Is the element a ShadowRoot?
1933     *
1934     * Note: this is insufficient to test if any element is a shadow root, but it is sufficient to differentiate between
1935     * a Document and a ShadowRoot.
1936     */
1937    const isShadowRoot = (dos) => isDocumentFragment(dos) && isNonNullable(dos.dom.host);
1938    const getRootNode = (e) => SugarElement.fromDom(e.dom.getRootNode());
1939    /** Where content needs to go. ShadowRoot or document body */
1940    const getContentContainer = (dos) => 
1941    // Can't use SugarBody.body without causing a circular module reference (since SugarBody.inBody uses SugarShadowDom)
1942    isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
1943    /** Is this element either a ShadowRoot or a descendent of a ShadowRoot. */
1944    const isInShadowRoot = (e) => getShadowRoot(e).isSome();
1945    /** If this element is in a ShadowRoot, return it. */
1946    const getShadowRoot = (e) => {
1947        const r = getRootNode(e);
1948        return isShadowRoot(r) ? Optional.some(r) : Optional.none();
1949    };
1950    /** Return the host of a ShadowRoot.
1951     *
1952     * This function will throw if Shadow DOM is unsupported in the browser, or if the host is null.
1953     * If you actually have a ShadowRoot, this shouldn't happen.
1954     */
1955    const getShadowHost = (e) => SugarElement.fromDom(e.dom.host);
1956    /**
1957     * When Events bubble up through a ShadowRoot, the browser changes the target to be the shadow host.
1958     * This function gets the "original" event target if possible.
1959     * This only works if the shadow tree is open - if the shadow tree is closed, event.target is returned.
1960     * See: https://developers.google.com/web/fundamentals/web-components/shadowdom#events
1961     */
1962    const getOriginalEventTarget = (event) => {
1963        if (isNonNullable(event.target)) {
1964            const el = SugarElement.fromDom(event.target);
1965            if (isElement$1(el) && isOpenShadowHost(el)) {
1966                // When target element is inside Shadow DOM we need to take first element from composedPath
1967                // otherwise we'll get Shadow Root parent, not actual target element.
1968                if (event.composed && event.composedPath) {
1969                    const composedPath = event.composedPath();
1970                    if (composedPath) {
1971                        return head(composedPath);
1972                    }
1973                }
1974            }
1975        }
1976        return Optional.from(event.target);
1977    };
1978    /** Return true if the element is a host of an open shadow root.
1979     *  Return false if the element is a host of a closed shadow root, or if the element is not a host.
1980     */
1981    const isOpenShadowHost = (element) => isNonNullable(element.dom.shadowRoot);
1982
1983    const mkEvent = (target, x, y, stop, prevent, kill, raw) => ({
1984        target,
1985        x,
1986        y,
1987        stop,
1988        prevent,
1989        kill,
1990        raw
1991    });
1992    /** Wraps an Event in an EventArgs structure.
1993     * The returned EventArgs structure has its target set to the "original" target if possible.
1994     * See SugarShadowDom.getOriginalEventTarget
1995     */
1996    const fromRawEvent$1 = (rawEvent) => {
1997        const target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target));
1998        const stop = () => rawEvent.stopPropagation();
1999        const prevent = () => rawEvent.preventDefault();
2000        const kill = compose(prevent, stop); // more of a sequence than a compose, but same effect
2001        // FIX: Don't just expose the raw event. Need to identify what needs standardisation.
2002        return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent);
2003    };
2004    const handle = (filter, handler) => (rawEvent) => {
2005        if (filter(rawEvent)) {
2006            handler(fromRawEvent$1(rawEvent));
2007        }
2008    };
2009    const binder = (element, event, filter, handler, useCapture) => {
2010        const wrapped = handle(filter, handler);
2011        // IE9 minimum
2012        element.dom.addEventListener(event, wrapped, useCapture);
2013        return {
2014            unbind: curry(unbind, element, event, wrapped, useCapture)
2015        };
2016    };
2017    const bind$2 = (element, event, filter, handler) => binder(element, event, filter, handler, false);
2018    const capture$1 = (element, event, filter, handler) => binder(element, event, filter, handler, true);
2019    const unbind = (element, event, handler, useCapture) => {
2020        // IE9 minimum
2021        element.dom.removeEventListener(event, handler, useCapture);
2022    };
2023
2024    const filter = always; // no filter on plain DomEvents
2025    const bind$1 = (element, event, handler) => bind$2(element, event, filter, handler);
2026    const capture = (element, event, handler) => capture$1(element, event, filter, handler);
2027    const fromRawEvent = fromRawEvent$1;
2028
2029    const getDocument = () => SugarElement.fromDom(document);
2030
2031    const focus$4 = (element, preventScroll = false) => element.dom.focus({ preventScroll });
2032    const blur$1 = (element) => element.dom.blur();
2033    const hasFocus = (element) => {
2034        const root = getRootNode(element).dom;
2035        return element.dom === root.activeElement;
2036    };
2037    // Note: assuming that activeElement will always be a HTMLElement (maybe we should add a runtime check?)
2038    const active$1 = (root = getDocument()) => Optional.from(root.dom.activeElement).map(SugarElement.fromDom);
2039    /**
2040     * Return the descendant element that has focus.
2041     * Use instead of SelectorFind.descendant(container, ':focus')
2042     *  because the :focus selector relies on keyboard focus.
2043     */
2044    const search = (element) => active$1(getRootNode(element))
2045        .filter((e) => element.dom.contains(e.dom));
2046
2047    const before$1 = (marker, element) => {
2048        const parent$1 = parent(marker);
2049        parent$1.each((v) => {
2050            v.dom.insertBefore(element.dom, marker.dom);
2051        });
2052    };
2053    const after$1 = (marker, element) => {
2054        const sibling = nextSibling(marker);
2055        sibling.fold(() => {
2056            const parent$1 = parent(marker);
2057            parent$1.each((v) => {
2058                append$2(v, element);
2059            });
2060        }, (v) => {
2061            before$1(v, element);
2062        });
2063    };
2064    const prepend$1 = (parent, element) => {
2065        const firstChild$1 = firstChild(parent);
2066        firstChild$1.fold(() => {
2067            append$2(parent, element);
2068        }, (v) => {
2069            parent.dom.insertBefore(element.dom, v.dom);
2070        });
2071    };
2072    const append$2 = (parent, element) => {
2073        parent.dom.appendChild(element.dom);
2074    };
2075    const appendAt = (parent, element, index) => {
2076        child$2(parent, index).fold(() => {
2077            append$2(parent, element);
2078        }, (v) => {
2079            before$1(v, element);
2080        });
2081    };
2082
2083    const append$1 = (parent, elements) => {
2084        each$1(elements, (x) => {
2085            append$2(parent, x);
2086        });
2087    };
2088
2089    const rawSet = (dom, key, value) => {
2090        /*
2091         * JQuery coerced everything to a string, and silently did nothing on text node/null/undefined.
2092         *
2093         * We fail on those invalid cases, only allowing numbers and booleans.
2094         */
2095        if (isString(value) || isBoolean(value) || isNumber(value)) {
2096            dom.setAttribute(key, value + '');
2097        }
2098        else {
2099            // eslint-disable-next-line no-console
2100            console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
2101            throw new Error('Attribute value was not simple');
2102        }
2103    };
2104    const set$9 = (element, key, value) => {
2105        rawSet(element.dom, key, value);
2106    };
2107    const setAll$1 = (element, attrs) => {
2108        const dom = element.dom;
2109        each(attrs, (v, k) => {
2110            rawSet(dom, k, v);
2111        });
2112    };
2113    const get$g = (element, key) => {
2114        const v = element.dom.getAttribute(key);
2115        // undefined is the more appropriate value for JS, and this matches JQuery
2116        return v === null ? undefined : v;
2117    };
2118    const getOpt = (element, key) => Optional.from(get$g(element, key));
2119    const has$1 = (element, key) => {
2120        const dom = element.dom;
2121        // return false for non-element nodes, no point in throwing an error
2122        return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
2123    };
2124    const remove$8 = (element, key) => {
2125        element.dom.removeAttribute(key);
2126    };
2127    const clone$2 = (element) => foldl(element.dom.attributes, (acc, attr) => {
2128        acc[attr.name] = attr.value;
2129        return acc;
2130    }, {});
2131
2132    const empty = (element) => {
2133        // shortcut "empty node" trick. Requires IE 9.
2134        element.dom.textContent = '';
2135        // If the contents was a single empty text node, the above doesn't remove it. But, it's still faster in general
2136        // than removing every child node manually.
2137        // The following is (probably) safe for performance as 99.9% of the time the trick works and
2138        // Traverse.children will return an empty array.
2139        each$1(children(element), (rogue) => {
2140            remove$7(rogue);
2141        });
2142    };
2143    const remove$7 = (element) => {
2144        const dom = element.dom;
2145        if (dom.parentNode !== null) {
2146            dom.parentNode.removeChild(dom);
2147        }
2148    };
2149
2150    const clone$1 = (original, isDeep) => SugarElement.fromDom(original.dom.cloneNode(isDeep));
2151    /** Shallow clone - just the tag, no children */
2152    const shallow = (original) => clone$1(original, false);
2153    /** Deep clone - everything copied including children */
2154    const deep = (original) => clone$1(original, true);
2155
2156    const fromHtml$1 = (html, scope) => {
2157        const doc = scope || document;
2158        const div = doc.createElement('div');
2159        div.innerHTML = html;
2160        return children(SugarElement.fromDom(div));
2161    };
2162
2163    const get$f = (element) => element.dom.innerHTML;
2164    const set$8 = (element, content) => {
2165        const owner = owner$4(element);
2166        const docDom = owner.dom;
2167        // FireFox has *terrible* performance when using innerHTML = x
2168        const fragment = SugarElement.fromDom(docDom.createDocumentFragment());
2169        const contentElements = fromHtml$1(content, docDom);
2170        append$1(fragment, contentElements);
2171        empty(element);
2172        append$2(element, fragment);
2173    };
2174    const getOuter$2 = (element) => {
2175        const container = SugarElement.fromTag('div');
2176        const clone = SugarElement.fromDom(element.dom.cloneNode(true));
2177        append$2(container, clone);
2178        return get$f(container);
2179    };
2180
2181    const getHtml = (element) => {
2182        if (isShadowRoot(element)) {
2183            return '#shadow-root';
2184        }
2185        else {
2186            const clone = shallow(element);
2187            return getOuter$2(clone);
2188        }
2189    };
2190
2191    const image = (image) => new Promise((resolve, reject) => {
2192        const loaded = () => {
2193            destroy();
2194            resolve(image);
2195        };
2196        const listeners = [
2197            bind$1(image, 'load', loaded),
2198            bind$1(image, 'error', () => {
2199                destroy();
2200                reject('Unable to load data from image: ' + image.dom.src);
2201            }),
2202        ];
2203        const destroy = () => each$1(listeners, (l) => l.unbind());
2204        if (image.dom.complete) {
2205            loaded();
2206        }
2207    });
2208
2209    // some elements, such as mathml, don't have style attributes
2210    // others, such as angular elements, have style attributes that aren't a CSSStyleDeclaration
2211    const isSupported = (dom) => dom.style !== undefined && isFunction(dom.style.getPropertyValue);
2212
2213    // Node.contains() is very, very, very good performance
2214    // http://jsperf.com/closest-vs-contains/5
2215    const inBody = (element) => {
2216        // Technically this is only required on IE, where contains() returns false for text nodes.
2217        // But it's cheap enough to run everywhere and Sugar doesn't have platform detection (yet).
2218        const dom = isText(element) ? element.dom.parentNode : element.dom;
2219        // use ownerDocument.body to ensure this works inside iframes.
2220        // Normally contains is bad because an element "contains" itself, but here we want that.
2221        if (dom === undefined || dom === null || dom.ownerDocument === null) {
2222            return false;
2223        }
2224        const doc = dom.ownerDocument;
2225        return getShadowRoot(SugarElement.fromDom(dom)).fold(() => doc.body.contains(dom), compose1(inBody, getShadowHost));
2226    };
2227    const body = () => getBody(SugarElement.fromDom(document));
2228    const getBody = (doc) => {
2229        const b = doc.dom.body;
2230        if (b === null || b === undefined) {
2231            throw new Error('Body is not available yet');
2232        }
2233        return SugarElement.fromDom(b);
2234    };
2235
2236    const internalSet = (dom, property, value) => {
2237        // This is going to hurt. Apologies.
2238        // JQuery coerces numbers to pixels for certain property names, and other times lets numbers through.
2239        // we're going to be explicit; strings only.
2240        if (!isString(value)) {
2241            // eslint-disable-next-line no-console
2242            console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
2243            throw new Error('CSS value must be a string: ' + value);
2244        }
2245        // removed: support for dom().style[property] where prop is camel case instead of normal property name
2246        if (isSupported(dom)) {
2247            dom.style.setProperty(property, value);
2248        }
2249    };
2250    const internalRemove = (dom, property) => {
2251        /*
2252         * IE9 and above - MDN doesn't have details, but here's a couple of random internet claims
2253         *
2254         * http://help.dottoro.com/ljopsjck.php
2255         * http://stackoverflow.com/a/7901886/7546
2256         */
2257        if (isSupported(dom)) {
2258            dom.style.removeProperty(property);
2259        }
2260    };
2261    const set$7 = (element, property, value) => {
2262        const dom = element.dom;
2263        internalSet(dom, property, value);
2264    };
2265    const setAll = (element, css) => {
2266        const dom = element.dom;
2267        each(css, (v, k) => {
2268            internalSet(dom, k, v);
2269        });
2270    };
2271    const setOptions = (element, css) => {
2272        const dom = element.dom;
2273        each(css, (v, k) => {
2274            v.fold(() => {
2275                internalRemove(dom, k);
2276            }, (value) => {
2277                internalSet(dom, k, value);
2278            });
2279        });
2280    };
2281    /*
2282     * NOTE: For certain properties, this returns the "used value" which is subtly different to the "computed value" (despite calling getComputedStyle).
2283     * Blame CSS 2.0.
2284     *
2285     * https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
2286     */
2287    const get$e = (element, property) => {
2288        const dom = element.dom;
2289        /*
2290         * IE9 and above per
2291         * https://developer.mozilla.org/en/docs/Web/API/window.getComputedStyle
2292         *
2293         * Not in numerosity, because it doesn't memoize and looking this up dynamically in performance critical code would be horrendous.
2294         *
2295         * JQuery has some magic here for IE popups, but we don't really need that.
2296         * It also uses element.ownerDocument.defaultView to handle iframes but that hasn't been required since FF 3.6.
2297         */
2298        const styles = window.getComputedStyle(dom);
2299        const r = styles.getPropertyValue(property);
2300        // 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.
2301        // Turns out we do this a lot.
2302        return (r === '' && !inBody(element)) ? getUnsafeProperty(dom, property) : r;
2303    };
2304    // removed: support for dom().style[property] where prop is camel case instead of normal property name
2305    // empty string is what the browsers (IE11 and Chrome) return when the propertyValue doesn't exists.
2306    const getUnsafeProperty = (dom, property) => isSupported(dom) ? dom.style.getPropertyValue(property) : '';
2307    /*
2308     * Gets the raw value from the style attribute. Useful for retrieving "used values" from the DOM:
2309     * https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
2310     *
2311     * Returns NONE if the property isn't set, or the value is an empty string.
2312     */
2313    const getRaw = (element, property) => {
2314        const dom = element.dom;
2315        const raw = getUnsafeProperty(dom, property);
2316        return Optional.from(raw).filter((r) => r.length > 0);
2317    };
2318    const getAllRaw = (element) => {
2319        const css = {};
2320        const dom = element.dom;
2321        if (isSupported(dom)) {
2322            for (let i = 0; i < dom.style.length; i++) {
2323                const ruleName = dom.style.item(i);
2324                css[ruleName] = dom.style[ruleName];
2325            }
2326        }
2327        return css;
2328    };
2329    const isValidValue$1 = (tag, property, value) => {
2330        const element = SugarElement.fromTag(tag);
2331        set$7(element, property, value);
2332        const style = getRaw(element, property);
2333        return style.isSome();
2334    };
2335    const remove$6 = (element, property) => {
2336        const dom = element.dom;
2337        internalRemove(dom, property);
2338        if (is$1(getOpt(element, 'style').map(trim$1), '')) {
2339            // No more styles left, remove the style attribute as well
2340            remove$8(element, 'style');
2341        }
2342    };
2343    /* NOTE: This function is here for the side effect it triggers.
2344    The value itself is not used.
2345    Be sure to not use the return value, and that it is not removed by a minifier.
2346     */
2347    const reflow = (e) => e.dom.offsetWidth;
2348
2349    const Dimension = (name, getOffset) => {
2350        const set = (element, h) => {
2351            if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
2352                throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
2353            }
2354            const dom = element.dom;
2355            if (isSupported(dom)) {
2356                dom.style[name] = h + 'px';
2357            }
2358        };
2359        /*
2360         * jQuery supports querying width and height on the document and window objects.
2361         *
2362         * TBIO doesn't do this, so the code is removed to save space, but left here just in case.
2363         */
2364        /*
2365        var getDocumentWidth = (element) => {
2366          var dom = element.dom;
2367          if (Node.isDocument(element)) {
2368            var body = dom.body;
2369            var doc = dom.documentElement;
2370            return Math.max(
2371              body.scrollHeight,
2372              doc.scrollHeight,
2373              body.offsetHeight,
2374              doc.offsetHeight,
2375              doc.clientHeight
2376            );
2377          }
2378        };
2379      
2380        var getWindowWidth = (element) => {
2381          var dom = element.dom;
2382          if (dom.window === dom) {
2383            // There is no offsetHeight on a window, so use the clientHeight of the document
2384            return dom.document.documentElement.clientHeight;
2385          }
2386        };
2387      */
2388        const get = (element) => {
2389            const r = getOffset(element);
2390            // zero or null means non-standard or disconnected, fall back to CSS
2391            if (r <= 0 || r === null) {
2392                const css = get$e(element, name);
2393                // ugh this feels dirty, but it saves cycles
2394                return parseFloat(css) || 0;
2395            }
2396            return r;
2397        };
2398        // in jQuery, getOuter replicates (or uses) box-sizing: border-box calculations
2399        // although these calculations only seem relevant for quirks mode, and edge cases TBIO doesn't rely on
2400        const getOuter = get;
2401        const aggregate = (element, properties) => foldl(properties, (acc, property) => {
2402            const val = get$e(element, property);
2403            const value = val === undefined ? 0 : parseInt(val, 10);
2404            return isNaN(value) ? acc : acc + value;
2405        }, 0);
2406        const max = (element, value, properties) => {
2407            const cumulativeInclusions = aggregate(element, properties);
2408            // if max-height is 100px and your cumulativeInclusions is 150px, there is no way max-height can be 100px, so we return 0.
2409            const absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
2410            return absoluteMax;
2411        };
2412        return {
2413            set,
2414            get,
2415            getOuter,
2416            aggregate,
2417            max
2418        };
2419    };
2420
2421    const api$2 = Dimension('height', (element) => {
2422        // getBoundingClientRect gives better results than offsetHeight for tables with captions on Firefox
2423        const dom = element.dom;
2424        return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
2425    });
2426    const get$d = (element) => api$2.get(element);
2427    const getOuter$1 = (element) => api$2.getOuter(element);
2428    const setMax$1 = (element, value) => {
2429        // These properties affect the absolute max-height, they are not counted natively, we want to include these properties.
2430        const inclusions = ['margin-top', 'border-top-width', 'padding-top', 'padding-bottom', 'border-bottom-width', 'margin-bottom'];
2431        const absMax = api$2.max(element, value, inclusions);
2432        set$7(element, 'max-height', absMax + 'px');
2433    };
2434
2435    const isHidden$1 = (dom) => dom.offsetWidth <= 0 && dom.offsetHeight <= 0;
2436    const isVisible = (element) => !isHidden$1(element.dom);
2437
2438    const api$1 = Dimension('width', (element) => {
2439        const dom = element.dom;
2440        return inBody(element) ? dom.getBoundingClientRect().width : dom.offsetWidth;
2441    });
2442    const set$6 = (element, h) => api$1.set(element, h);
2443    const get$c = (element) => api$1.get(element);
2444    const getOuter = (element) => api$1.getOuter(element);
2445    const setMax = (element, value) => {
2446        // These properties affect the absolute max-height, they are not counted natively, we want to include these properties.
2447        const inclusions = ['margin-left', 'border-left-width', 'padding-left', 'padding-right', 'border-right-width', 'margin-right'];
2448        const absMax = api$1.max(element, value, inclusions);
2449        set$7(element, 'max-width', absMax + 'px');
2450    };
2451
2452    const r$1 = (left, top) => {
2453        const translate = (x, y) => r$1(left + x, top + y);
2454        return {
2455            left,
2456            top,
2457            translate
2458        };
2459    };
2460    // tslint:disable-next-line:variable-name
2461    const SugarPosition = r$1;
2462
2463    const boxPosition = (dom) => {
2464        const box = dom.getBoundingClientRect();
2465        return SugarPosition(box.left, box.top);
2466    };
2467    // Avoids falsy false fallthrough
2468    const firstDefinedOrZero = (a, b) => {
2469        if (a !== undefined) {
2470            return a;
2471        }
2472        else {
2473            return b !== undefined ? b : 0;
2474        }
2475    };
2476    const absolute$3 = (element) => {
2477        const doc = element.dom.ownerDocument;
2478        const body = doc.body;
2479        const win = doc.defaultView;
2480        const html = doc.documentElement;
2481        if (body === element.dom) {
2482            return SugarPosition(body.offsetLeft, body.offsetTop);
2483        }
2484        const scrollTop = firstDefinedOrZero(win?.pageYOffset, html.scrollTop);
2485        const scrollLeft = firstDefinedOrZero(win?.pageXOffset, html.scrollLeft);
2486        const clientTop = firstDefinedOrZero(html.clientTop, body.clientTop);
2487        const clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft);
2488        return viewport$1(element).translate(scrollLeft - clientLeft, scrollTop - clientTop);
2489    };
2490    const viewport$1 = (element) => {
2491        const dom = element.dom;
2492        const doc = dom.ownerDocument;
2493        const body = doc.body;
2494        if (body === dom) {
2495            return SugarPosition(body.offsetLeft, body.offsetTop);
2496        }
2497        if (!inBody(element)) {
2498            return SugarPosition(0, 0);
2499        }
2500        return boxPosition(dom);
2501    };
2502
2503    // get scroll position (x,y) relative to document _doc (or global if not supplied)
2504    const get$b = (_DOC) => {
2505        const doc = _DOC !== undefined ? _DOC.dom : document;
2506        // ASSUMPTION: This is for cross-browser support, body works for Safari & EDGE, and when we have an iframe body scroller
2507        const x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
2508        const y = doc.body.scrollTop || doc.documentElement.scrollTop;
2509        return SugarPosition(x, y);
2510    };
2511    // Scroll content to (x,y) relative to document _doc (or global if not supplied)
2512    const to = (x, y, _DOC) => {
2513        const doc = _DOC !== undefined ? _DOC.dom : document;
2514        const win = doc.defaultView;
2515        if (win) {
2516            win.scrollTo(x, y);
2517        }
2518    };
2519
2520    const NodeValue = (is, name) => {
2521        const get = (element) => {
2522            if (!is(element)) {
2523                throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
2524            }
2525            return getOption(element).getOr('');
2526        };
2527        const getOption = (element) => is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();
2528        const set = (element, value) => {
2529            if (!is(element)) {
2530                throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
2531            }
2532            element.dom.nodeValue = value;
2533        };
2534        return {
2535            get,
2536            getOption,
2537            set
2538        };
2539    };
2540
2541    const api = NodeValue(isText, 'text');
2542    const get$a = (element) => api.get(element);
2543
2544    const onDirection = (isLtr, isRtl) => (element) => getDirection(element) === 'rtl' ? isRtl : isLtr;
2545    const getDirection = (element) => get$e(element, 'direction') === 'rtl' ? 'rtl' : 'ltr';
2546
2547    // Methods for handling attributes that contain a list of values <div foo="alpha beta theta">
2548    const read$2 = (element, attr) => {
2549        const value = get$g(element, attr);
2550        return value === undefined || value === '' ? [] : value.split(' ');
2551    };
2552    const add$4 = (element, attr, id) => {
2553        const old = read$2(element, attr);
2554        const nu = old.concat([id]);
2555        set$9(element, attr, nu.join(' '));
2556        return true;
2557    };
2558    const remove$5 = (element, attr, id) => {
2559        const nu = filter$2(read$2(element, attr), (v) => v !== id);
2560        if (nu.length > 0) {
2561            set$9(element, attr, nu.join(' '));
2562        }
2563        else {
2564            remove$8(element, attr);
2565        }
2566        return false;
2567    };
2568
2569    var ClosestOrAncestor = (is, ancestor, scope, a, isRoot) => {
2570        if (is(scope, a)) {
2571            return Optional.some(scope);
2572        }
2573        else if (isFunction(isRoot) && isRoot(scope)) {
2574            return Optional.none();
2575        }
2576        else {
2577            return ancestor(scope, a, isRoot);
2578        }
2579    };
2580
2581    const ancestor$2 = (scope, predicate, isRoot) => {
2582        let element = scope.dom;
2583        const stop = isFunction(isRoot) ? isRoot : never;
2584        while (element.parentNode) {
2585            element = element.parentNode;
2586            const el = SugarElement.fromDom(element);
2587            if (predicate(el)) {
2588                return Optional.some(el);
2589            }
2590            else if (stop(el)) {
2591                break;
2592            }
2593        }
2594        return Optional.none();
2595    };
2596    const closest$4 = (scope, predicate, isRoot) => {
2597        // This is required to avoid ClosestOrAncestor passing the predicate to itself
2598        const is = (s, test) => test(s);
2599        return ClosestOrAncestor(is, ancestor$2, scope, predicate, isRoot);
2600    };
2601    const sibling$1 = (scope, predicate) => {
2602        const element = scope.dom;
2603        if (!element.parentNode) {
2604            return Optional.none();
2605        }
2606        return child$1(SugarElement.fromDom(element.parentNode), (x) => !eq(scope, x) && predicate(x));
2607    };
2608    const child$1 = (scope, predicate) => {
2609        const pred = (node) => predicate(SugarElement.fromDom(node));
2610        const result = find$5(scope.dom.childNodes, pred);
2611        return result.map(SugarElement.fromDom);
2612    };
2613    const descendant$1 = (scope, predicate) => {
2614        const descend = (node) => {
2615            // tslint:disable-next-line:prefer-for-of
2616            for (let i = 0; i < node.childNodes.length; i++) {
2617                const child = SugarElement.fromDom(node.childNodes[i]);
2618                if (predicate(child)) {
2619                    return Optional.some(child);
2620                }
2621                const res = descend(node.childNodes[i]);
2622                if (res.isSome()) {
2623                    return res;
2624                }
2625            }
2626            return Optional.none();
2627        };
2628        return descend(scope.dom);
2629    };
2630
2631    // TODO: An internal SelectorFilter module that doesn't SugarElement.fromDom() everything
2632    const first = (selector) => one(selector);
2633    const ancestor$1 = (scope, selector, isRoot) => ancestor$2(scope, (e) => is(e, selector), isRoot);
2634    const sibling = (scope, selector) => sibling$1(scope, (e) => is(e, selector));
2635    const child = (scope, selector) => child$1(scope, (e) => is(e, selector));
2636    const descendant = (scope, selector) => one(selector, scope);
2637    // Returns Some(closest ancestor element (sugared)) matching 'selector' up to isRoot, or None() otherwise
2638    const closest$3 = (scope, selector, isRoot) => {
2639        const is$1 = (element, selector) => is(element, selector);
2640        return ClosestOrAncestor(is$1, ancestor$1, scope, selector, isRoot);
2641    };
2642
2643    const set$5 = (element, status) => {
2644        element.dom.checked = status;
2645    };
2646    const get$9 = (element) => element.dom.checked;
2647
2648    // 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.
2649    const supports = (element) => element.dom.classList !== undefined;
2650    const get$8 = (element) => read$2(element, 'class');
2651    const add$3 = (element, clazz) => add$4(element, 'class', clazz);
2652    const remove$4 = (element, clazz) => remove$5(element, 'class', clazz);
2653    const toggle$4 = (element, clazz) => {
2654        if (contains$2(get$8(element), clazz)) {
2655            return remove$4(element, clazz);
2656        }
2657        else {
2658            return add$3(element, clazz);
2659        }
2660    };
2661
2662    /*
2663     * ClassList is IE10 minimum:
2664     * https://developer.mozilla.org/en-US/docs/Web/API/Element.classList
2665     *
2666     * Note that IE doesn't support the second argument to toggle (at all).
2667     * If it did, the toggler could be better.
2668     */
2669    const add$2 = (element, clazz) => {
2670        if (supports(element)) {
2671            element.dom.classList.add(clazz);
2672        }
2673        else {
2674            add$3(element, clazz);
2675        }
2676    };
2677    const cleanClass = (element) => {
2678        const classList = supports(element) ? element.dom.classList : get$8(element);
2679        // classList is a "live list", so this is up to date already
2680        if (classList.length === 0) {
2681            // No more classes left, remove the class attribute as well
2682            remove$8(element, 'class');
2683        }
2684    };
2685    const remove$3 = (element, clazz) => {
2686        if (supports(element)) {
2687            const classList = element.dom.classList;
2688            classList.remove(clazz);
2689        }
2690        else {
2691            remove$4(element, clazz);
2692        }
2693        cleanClass(element);
2694    };
2695    const toggle$3 = (element, clazz) => {
2696        const result = supports(element) ? element.dom.classList.toggle(clazz) : toggle$4(element, clazz);
2697        cleanClass(element);
2698        return result;
2699    };
2700    const has = (element, clazz) => supports(element) && element.dom.classList.contains(clazz);
2701
2702    /*
2703     * ClassList is IE10 minimum:
2704     * https://developer.mozilla.org/en-US/docs/Web/API/Element.classList
2705     */
2706    const add$1 = (element, classes) => {
2707        each$1(classes, (x) => {
2708            add$2(element, x);
2709        });
2710    };
2711    const remove$2 = (element, classes) => {
2712        each$1(classes, (x) => {
2713            remove$3(element, x);
2714        });
2715    };
2716    const toggle$2 = (element, classes) => {
2717        each$1(classes, (x) => {
2718            toggle$3(element, x);
2719        });
2720    };
2721    const hasAll = (element, classes) => forall(classes, (clazz) => has(element, clazz));
2722    const getNative = (element) => {
2723        const classList = element.dom.classList;
2724        const r = new Array(classList.length);
2725        for (let i = 0; i < classList.length; i++) {
2726            const item = classList.item(i);
2727            if (item !== null) {
2728                r[i] = item;
2729            }
2730        }
2731        return r;
2732    };
2733    const get$7 = (element) => supports(element) ? getNative(element) : get$8(element);
2734
2735    const get$6 = (element) => element.dom.textContent;
2736
2737    const get$5 = (element) => element.dom.value;
2738    const set$4 = (element, value) => {
2739        if (value === undefined) {
2740            throw new Error('Value.set was undefined');
2741        }
2742        element.dom.value = value;
2743    };
2744
2745    const ancestors = (scope, predicate, isRoot) => filter$2(parents(scope, isRoot), predicate);
2746
2747    const descendants = (scope, selector) => all$3(selector, scope);
2748
2749    const closest$2 = (scope, predicate, isRoot) => closest$4(scope, predicate, isRoot).isSome();
2750
2751    const closest$1 = (scope, selector, isRoot) => closest$3(scope, selector, isRoot).isSome();
2752
2753    const ensureIsRoot = (isRoot) => isFunction(isRoot) ? isRoot : never;
2754    const ancestor = (scope, transform, isRoot) => {
2755        let element = scope.dom;
2756        const stop = ensureIsRoot(isRoot);
2757        while (element.parentNode) {
2758            element = element.parentNode;
2759            const el = SugarElement.fromDom(element);
2760            const transformed = transform(el);
2761            if (transformed.isSome()) {
2762                return transformed;
2763            }
2764            else if (stop(el)) {
2765                break;
2766            }
2767        }
2768        return Optional.none();
2769    };
2770    const closest = (scope, transform, isRoot) => {
2771        const current = transform(scope);
2772        const stop = ensureIsRoot(isRoot);
2773        return current.orThunk(() => stop(scope) ? Optional.none() : ancestor(scope, transform, stop));
2774    };
2775
2776    const create$5 = (start, soffset, finish, foffset) => ({
2777        start,
2778        soffset,
2779        finish,
2780        foffset
2781    });
2782    // tslint:disable-next-line:variable-name
2783    const SimRange = {
2784        create: create$5
2785    };
2786
2787    const adt$9 = Adt.generate([
2788        { before: ['element'] },
2789        { on: ['element', 'offset'] },
2790        { after: ['element'] }
2791    ]);
2792    // Probably don't need this given that we now have "match"
2793    const cata$2 = (subject, onBefore, onOn, onAfter) => subject.fold(onBefore, onOn, onAfter);
2794    const getStart$1 = (situ) => situ.fold(identity, identity, identity);
2795    const before = adt$9.before;
2796    const on$1 = adt$9.on;
2797    const after = adt$9.after;
2798    // tslint:disable-next-line:variable-name
2799    const Situ = {
2800        before,
2801        on: on$1,
2802        after,
2803        cata: cata$2,
2804        getStart: getStart$1
2805    };
2806
2807    // Consider adding a type for "element"
2808    const adt$8 = Adt.generate([
2809        { domRange: ['rng'] },
2810        { relative: ['startSitu', 'finishSitu'] },
2811        { exact: ['start', 'soffset', 'finish', 'foffset'] }
2812    ]);
2813    const exactFromRange = (simRange) => adt$8.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
2814    const getStart = (selection) => selection.match({
2815        domRange: (rng) => SugarElement.fromDom(rng.startContainer),
2816        relative: (startSitu, _finishSitu) => Situ.getStart(startSitu),
2817        exact: (start, _soffset, _finish, _foffset) => start
2818    });
2819    const domRange = adt$8.domRange;
2820    const relative$1 = adt$8.relative;
2821    const exact = adt$8.exact;
2822    const getWin = (selection) => {
2823        const start = getStart(selection);
2824        return defaultView(start);
2825    };
2826    // This is out of place but it's API so I can't remove it
2827    const range$1 = SimRange.create;
2828    // tslint:disable-next-line:variable-name
2829    const SimSelection = {
2830        domRange,
2831        relative: relative$1,
2832        exact,
2833        exactFromRange,
2834        getWin,
2835        range: range$1
2836    };
2837
2838    const beforeSpecial = (element, offset) => {
2839        // From memory, we don't want to use <br> directly on Firefox because it locks the keyboard input.
2840        // It turns out that <img> directly on IE locks the keyboard as well.
2841        // If the offset is 0, use before. If the offset is 1, use after.
2842        // TBIO-3889: Firefox Situ.on <input> results in a child of the <input>; Situ.before <input> results in platform inconsistencies
2843        const name = name$3(element);
2844        if ('input' === name) {
2845            return Situ.after(element);
2846        }
2847        else if (!contains$2(['br', 'img'], name)) {
2848            return Situ.on(element, offset);
2849        }
2850        else {
2851            return offset === 0 ? Situ.before(element) : Situ.after(element);
2852        }
2853    };
2854    const preprocessExact = (start, soffset, finish, foffset) => {
2855        const startSitu = beforeSpecial(start, soffset);
2856        const finishSitu = beforeSpecial(finish, foffset);
2857        return SimSelection.relative(startSitu, finishSitu);
2858    };
2859
2860    const getNativeSelection = (win) => Optional.from(win.getSelection());
2861    const doSetNativeRange = (win, rng) => {
2862        getNativeSelection(win).each((selection) => {
2863            selection.removeAllRanges();
2864            selection.addRange(rng);
2865        });
2866    };
2867    const doSetRange = (win, start, soffset, finish, foffset) => {
2868        const rng = exactToNative(win, start, soffset, finish, foffset);
2869        doSetNativeRange(win, rng);
2870    };
2871    const setLegacyRtlRange = (win, selection, start, soffset, finish, foffset) => {
2872        selection.collapse(start.dom, soffset);
2873        selection.extend(finish.dom, foffset);
2874    };
2875    const setRangeFromRelative = (win, relative) => diagnose(win, relative).match({
2876        ltr: (start, soffset, finish, foffset) => {
2877            doSetRange(win, start, soffset, finish, foffset);
2878        },
2879        rtl: (start, soffset, finish, foffset) => {
2880            getNativeSelection(win).each((selection) => {
2881                // If this selection is backwards, then we need to use extend.
2882                if (selection.setBaseAndExtent) {
2883                    selection.setBaseAndExtent(start.dom, soffset, finish.dom, foffset);
2884                }
2885                else if (selection.extend) {
2886                    // This try catch is for older browsers (Firefox 52) as they're sometimes unable to handle setting backwards selections using selection.extend and error out.
2887                    try {
2888                        setLegacyRtlRange(win, selection, start, soffset, finish, foffset);
2889                    }
2890                    catch {
2891                        // If it does fail, try again with ltr.
2892                        doSetRange(win, finish, foffset, start, soffset);
2893                    }
2894                }
2895                else {
2896                    doSetRange(win, finish, foffset, start, soffset);
2897                }
2898            });
2899        }
2900    });
2901    const setExact = (win, start, soffset, finish, foffset) => {
2902        const relative = preprocessExact(start, soffset, finish, foffset);
2903        setRangeFromRelative(win, relative);
2904    };
2905    // NOTE: We are still reading the range because it gives subtly different behaviour