https://www.nickhernbooks.co.uk/assets/260ee9aa/tinymce.js

2)
3 */
4
5(function () {
6    'use strict';
7
8    var typeOf$1 = function (x) {
9      if (x === null) {
10        return 'null';
11      }
12      if (x === undefined) {
13        return 'undefined';
14      }
15      var t = typeof x;
16      if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
17        return 'array';
18      }
19      if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
20        return 'string';
21      }
22      return t;
23    };
24    var isEquatableType = function (x) {
25      return [
26        'undefined',
27        'boolean',
28        'number',
29        'string',
30        'function',
31        'xml',
32        'null'
33      ].indexOf(x) !== -1;
34    };
35
36    var sort$1 = function (xs, compareFn) {
37      var clone = Array.prototype.slice.call(xs);
38      return clone.sort(compareFn);
39    };
40
41    var contramap = function (eqa, f) {
42      return eq$2(function (x, y) {
43        return eqa.eq(f(x), f(y));
44      });
45    };
46    var eq$2 = function (f) {
47      return { eq: f };
48    };
49    var tripleEq = eq$2(function (x, y) {
50      return x === y;
51    });
52    var eqString = tripleEq;
53    var eqArray = function (eqa) {
54      return eq$2(function (x, y) {
55        if (x.length !== y.length) {
56          return false;
57        }
58        var len = x.length;
59        for (var i = 0; i < len; i++) {
60          if (!eqa.eq(x[i], y[i])) {
61            return false;
62          }
63        }
64        return true;
65      });
66    };
67    var eqSortedArray = function (eqa, compareFn) {
68      return contramap(eqArray(eqa), function (xs) {
69        return sort$1(xs, compareFn);
70      });
71    };
72    var eqRecord = function (eqa) {
73      return eq$2(function (x, y) {
74        var kx = Object.keys(x);
75        var ky = Object.keys(y);
76        if (!eqSortedArray(eqString).eq(kx, ky)) {
77          return false;
78        }
79        var len = kx.length;
80        for (var i = 0; i < len; i++) {
81          var q = kx[i];
82          if (!eqa.eq(x[q], y[q])) {
83            return false;
84          }
85        }
86        return true;
87      });
88    };
89    var eqAny = eq$2(function (x, y) {
90      if (x === y) {
91        return true;
92      }
93      var tx = typeOf$1(x);
94      var ty = typeOf$1(y);
95      if (tx !== ty) {
96        return false;
97      }
98      if (isEquatableType(tx)) {
99        return x === y;
100      } else if (tx === 'array') {
101        return eqArray(eqAny).eq(x, y);
102      } else if (tx === 'object') {
103        return eqRecord(eqAny).eq(x, y);
104      }
105      return false;
106    });
107
108    const getPrototypeOf$2 = Object.getPrototypeOf;
109    const hasProto = (v, constructor, predicate) => {
110      var _a;
111      if (predicate(v, constructor.prototype)) {
112        return true;
113      } else {
114        return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
115      }
116    };
117    const typeOf = x => {
118      const t = typeof x;
119      if (x === null) {
120        return 'null';
121      } else if (t === 'object' && Array.isArray(x)) {
122        return 'array';
123      } else if (t === 'object' && hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))) {
124        return 'string';
125      } else {
126        return t;
127      }
128    };
129    const isType$1 = type => value => typeOf(value) === type;
130    const isSimpleType = type => value => typeof value === type;
131    const eq$1 = t => a => t === a;
132    const is$4 = (value, constructor) => isObject(value) && hasProto(value, constructor, (o, proto) => getPrototypeOf$2(o) === proto);
133    const isString = isType$1('string');
134    const isObject = isType$1('object');
135    const isPlainObject = value => is$4(value, Object);
136    const isArray$1 = isType$1('array');
137    const isNull = eq$1(null);
138    const isBoolean = isSimpleType('boolean');
139    const isUndefined = eq$1(undefined);
140    const isNullable = a => a === null || a === undefined;
141    const isNonNullable = a => !isNullable(a);
142    const isFunction = isSimpleType('function');
143    const isNumber = isSimpleType('number');
144    const isArrayOf = (value, pred) => {
145      if (isArray$1(value)) {
146        for (let i = 0, len = value.length; i < len; ++i) {
147          if (!pred(value[i])) {
148            return false;
149          }
150        }
151        return true;
152      }
153      return false;
154    };
155
156    const noop = () => {
157    };
158    const compose = (fa, fb) => {
159      return (...args) => {
160        return fa(fb.apply(null, args));
161      };
162    };
163    const compose1 = (fbc, fab) => a => fbc(fab(a));
164    const constant = value => {
165      return () => {
166        return value;
167      };
168    };
169    const identity = x => {
170      return x;
171    };
172    const tripleEquals = (a, b) => {
173      return a === b;
174    };
175    function curry(fn, ...initialArgs) {
176      return (...restArgs) => {
177        const all = initialArgs.concat(restArgs);
178        return fn.apply(null, all);
179      };
180    }
181    const not = f => t => !f(t);
182    const die = msg => {
183      return () => {
184        throw new Error(msg);
185      };
186    };
187    const apply$1 = f => {
188      return f();
189    };
190    const call = f => {
191      f();
192    };
193    const never = constant(false);
194    const always = constant(true);
195
196    class Optional {
197      constructor(tag, value) {
198        this.tag = tag;
199        this.value = value;
200      }
201      static some(value) {
202        return new Optional(true, value);
203      }
204      static none() {
205        return Optional.singletonNone;
206      }
207      fold(onNone, onSome) {
208        if (this.tag) {
209          return onSome(this.value);
210        } else {
211          return onNone();
212        }
213      }
214      isSome() {
215        return this.tag;
216      }
217      isNone() {
218        return !this.tag;
219      }
220      map(mapper) {
221        if (this.tag) {
222          return Optional.some(mapper(this.value));
223        } else {
224          return Optional.none();
225        }
226      }
227      bind(binder) {
228        if (this.tag) {
229          return binder(this.value);
230        } else {
231          return Optional.none();
232        }
233      }
234      exists(predicate) {
235        return this.tag && predicate(this.value);
236      }
237      forall(predicate) {
238        return !this.tag || predicate(this.value);
239      }
240      filter(predicate) {
241        if (!this.tag || predicate(this.value)) {
242          return this;
243        } else {
244          return Optional.none();
245        }
246      }
247      getOr(replacement) {
248        return this.tag ? this.value : replacement;
249      }
250      or(replacement) {
251        return this.tag ? this : replacement;
252      }
253      getOrThunk(thunk) {
254        return this.tag ? this.value : thunk();
255      }
256      orThunk(thunk) {
257        return this.tag ? this : thunk();
258      }
259      getOrDie(message) {
260        if (!this.tag) {
261          throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
262        } else {
263          return this.value;
264        }
265      }
266      static from(value) {
267        return isNonNullable(value) ? Optional.some(value) : Optional.none();
268      }
269      getOrNull() {
270        return this.tag ? this.value : null;
271      }
272      getOrUndefined() {
273        return this.value;
274      }
275      each(worker) {
276        if (this.tag) {
277          worker(this.value);
278        }
279      }
280      toArray() {
281        return this.tag ? [this.value] : [];
282      }
283      toString() {
284        return this.tag ? `some(${ this.value })` : 'none()';
285      }
286    }
287    Optional.singletonNone = new Optional(false);
288
289    const nativeSlice = Array.prototype.slice;
290    const nativeIndexOf = Array.prototype.indexOf;
291    const nativePush = Array.prototype.push;
292    const rawIndexOf = (ts, t) => nativeIndexOf.call(ts, t);
293    const indexOf$1 = (xs, x) => {
294      const r = rawIndexOf(xs, x);
295      return r === -1 ? Optional.none() : Optional.some(r);
296    };
297    const contains$2 = (xs, x) => rawIndexOf(xs, x) > -1;
298    const exists = (xs, pred) => {
299      for (let i = 0, len = xs.length; i < len; i++) {
300        const x = xs[i];
301        if (pred(x, i)) {
302          return true;
303        }
304      }
305      return false;
306    };
307    const map$3 = (xs, f) => {
308      const len = xs.length;
309      const r = new Array(len);
310      for (let i = 0; i < len; i++) {
311        const x = xs[i];
312        r[i] = f(x, i);
313      }
314      return r;
315    };
316    const each$e = (xs, f) => {
317      for (let i = 0, len = xs.length; i < len; i++) {
318        const x = xs[i];
319        f(x, i);
320      }
321    };
322    const eachr = (xs, f) => {
323      for (let i = xs.length - 1; i >= 0; i--) {
324        const x = xs[i];
325        f(x, i);
326      }
327    };
328    const partition$2 = (xs, pred) => {
329      const pass = [];
330      const fail = [];
331      for (let i = 0, len = xs.length; i < len; i++) {
332        const x = xs[i];
333        const arr = pred(x, i) ? pass : fail;
334        arr.push(x);
335      }
336      return {
337        pass,
338        fail
339      };
340    };
341    const filter$5 = (xs, pred) => {
342      const r = [];
343      for (let i = 0, len = xs.length; i < len; i++) {
344        const x = xs[i];
345        if (pred(x, i)) {
346          r.push(x);
347        }
348      }
349      return r;
350    };
351    const foldr = (xs, f, acc) => {
352      eachr(xs, (x, i) => {
353        acc = f(acc, x, i);
354      });
355      return acc;
356    };
357    const foldl = (xs, f, acc) => {
358      each$e(xs, (x, i) => {
359        acc = f(acc, x, i);
360      });
361      return acc;
362    };
363    const findUntil$1 = (xs, pred, until) => {
364      for (let i = 0, len = xs.length; i < len; i++) {
365        const x = xs[i];
366        if (pred(x, i)) {
367          return Optional.some(x);
368        } else if (until(x, i)) {
369          break;
370        }
371      }
372      return Optional.none();
373    };
374    const find$2 = (xs, pred) => {
375      return findUntil$1(xs, pred, never);
376    };
377    const findIndex$2 = (xs, pred) => {
378      for (let i = 0, len = xs.length; i < len; i++) {
379        const x = xs[i];
380        if (pred(x, i)) {
381          return Optional.some(i);
382        }
383      }
384      return Optional.none();
385    };
386    const flatten = xs => {
387      const r = [];
388      for (let i = 0, len = xs.length; i < len; ++i) {
389        if (!isArray$1(xs[i])) {
390          throw new Error('Arr.flatten item ' + i + ' was not an array, input

390: ' + xs);
391        }
392        nativePush.apply(r, xs[i]);
393      }
394      return r;
395    };
396    const bind$3 = (xs, f) => flatten(map$3(xs, f));
397    const forall = (xs, pred) => {
398      for (let i = 0, len = xs.length; i < len; ++i) {
399        const x = xs[i];
400        if (pred(x, i) !== true) {
401          return false;
402        }
403      }
404      return true;
405    };
406    const reverse = xs => {
407      const r = nativeSlice.call(xs, 0);
408      r.reverse();
409      return r;
410    };
411    const difference = (a1, a2) => filter$5(a1, x => !contains$2(a2, x));
412    const mapToObject = (xs, f) => {
413      const r = {};
414      for (let i = 0, len = xs.length; i < len; i++) {
415        const x = xs[i];
416        r[String(x)] = f(x, i);
417      }
418      return r;
419    };
420    const sort = (xs, comparator) => {
421      const copy = nativeSlice.call(xs, 0);
422      copy.sort(comparator);
423      return copy;
424    };
425    const get$b = (xs, i) => i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
426    const head = xs => get$b(xs, 0);
427    const last$2 = xs => get$b(xs, xs.length - 1);
428    const from = isFunction(Array.from) ? Array.from : x => nativeSlice.call(x);
429    const findMap = (arr, f) => {
430      for (let i = 0; i < arr.length; i++) {
431        const r = f(arr[i], i);
432        if (r.isSome()) {
433          return r;
434        }
435      }
436      return Optional.none();
437    };
438    const unique$1 = (xs, comparator) => {
439      const r = [];
440      const isDuplicated = isFunction(comparator) ? x => exists(r, i => comparator(i, x)) : x => contains$2(r, x);
441      for (let i = 0, len = xs.length; i < len; i++) {
442        const x = xs[i];
443        if (!isDuplicated(x)) {
444          r.push(x);
445        }
446      }
447      return r;
448    };
449
450    const keys = Object.keys;
451    const hasOwnProperty$1 = Object.hasOwnProperty;
452    const each$d = (obj, f) => {
453      const props = keys(obj);
454      for (let k = 0, len = props.length; k < len; k++) {
455        const i = props[k];
456        const x = obj[i];
457        f(x, i);
458      }
459    };
460    const map$2 = (obj, f) => {
461      return tupleMap(obj, (x, i) => ({
462        k: i,
463        v: f(x, i)
464      }));
465    };
466    const tupleMap = (obj, f) => {
467      const r = {};
468      each$d(obj, (x, i) => {
469        const tuple = f(x, i);
470        r[tuple.k] = tuple.v;
471      });
472      return r;
473    };
474    const objAcc = r => (x, i) => {
475      r[i] = x;
476    };
477    const internalFilter = (obj, pred, onTrue, onFalse) => {
478      each$d(obj, (x, i) => {
479        (pred(x, i) ? onTrue : onFalse)(x, i);
480      });
481    };
482    const bifilter = (obj, pred) => {
483      const t = {};
484      const f = {};
485      internalFilter(obj, pred, objAcc(t), objAcc(f));
486      return {
487        t,
488        f
489      };
490    };
491    const filter$4 = (obj, pred) => {
492      const t = {};
493      internalFilter(obj, pred, objAcc(t), noop);
494      return t;
495    };
496    const mapToArray = (obj, f) => {
497      const r = [];
498      each$d(obj, (value, name) => {
499        r.push(f(value, name));
500      });
501      return r;
502    };
503    const values = obj => {
504      return mapToArray(obj, identity);
505    };
506    const get$a = (obj, key) => {
507      return has$2(obj, key) ? Optional.from(obj[key]) : Optional.none();
508    };
509    const has$2 = (obj, key) => hasOwnProperty$1.call(obj, key);
510    const hasNonNullableKey = (obj, key) => has$2(obj, key) && obj[key] !== undefined && obj[key] !== null;
511    const equal$1 = (a1, a2, eq = eqAny) => eqRecord(eq).eq(a1, a2);
512
513    const stringArray = a => {
514      const all = {};
515      each$e(a, key => {
516        all[key] = {};
517      });
518      return keys(all);
519    };
520
521    const isArrayLike = o => o.length !== undefined;
522    const isArray = Array.isArray;
523    const toArray$1 = obj => {
524      if (!isArray(obj)) {
525        const array = [];
526        for (let i = 0, l = obj.length; i < l; i++) {
527          array[i] = obj[i];
528        }
529        return array;
530      } else {
531        return obj;
532      }
533    };
534    const each$c = (o, cb, s) => {
535      if (!o) {
536        return false;
537      }
538      s = s || o;
539      if (isArrayLike(o)) {
540        for (let n = 0, l = o.length; n < l; n++) {
541          if (cb.call(s, o[n], n, o) === false) {
542            return false;
543          }
544        }
545      } else {
546        for (const n in o) {
547          if (has$2(o, n)) {
548            if (cb.call(s, o[n], n, o) === false) {
549              return false;
550            }
551          }
552        }
553      }
554      return true;
555    };
556    const map$1 = (array, callback) => {
557      const out = [];
558      each$c(array, (item, index) => {
559        out.push(callback(item, index, array));
560      });
561      return out;
562    };
563    const filter$3 = (a, f) => {
564      const o = [];
565      each$c(a, (v, index) => {
566        if (!f || f(v, index, a)) {
567          o.push(v);
568        }
569      });
570      return o;
571    };
572    const indexOf = (a, v) => {
573      if (a) {
574        for (let i = 0, l = a.length; i < l; i++) {
575          if (a[i] === v) {
576            return i;
577          }
578        }
579      }
580      return -1;
581    };
582    const reduce = (collection, iteratee, accumulator, thisArg) => {
583      let acc = isUndefined(accumulator) ? collection[0] : accumulator;
584      for (let i = 0; i < collection.length; i++) {
585        acc = iteratee.call(thisArg, acc, collection[i], i);
586      }
587      return acc;
588    };
589    const findIndex$1 = (array, predicate, thisArg) => {
590      for (let i = 0, l = array.length; i < l; i++) {
591        if (predicate.call(thisArg, array[i], i, array)) {
592          return i;
593        }
594      }
595      return -1;
596    };
597    const last$1 = collection => collection[collection.length - 1];
598
599    const cached = f => {
600      let called = false;
601      let r;
602      return (...args) => {
603        if (!called) {
604          called = true;
605          r = f.apply(null, args);
606        }
607        return r;
608      };
609    };
610
611    const DeviceType = (os, browser, userAgent, mediaMatch) => {
612      const isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
613      const isiPhone = os.isiOS() && !isiPad;
614      const isMobile = os.isiOS() || os.isAndroid();
615      const isTouch = isMobile || mediaMatch('(pointer:coarse)');
616      const isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');
617      const isPhone = isiPhone || isMobile && !isTablet;
618      const iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
619      const isDesktop = !isPhone && !isTablet && !iOSwebview;
620      return {
621        isiPad: constant(isiPad),
622        isiPhone: constant(isiPhone),
623        isTablet: constant(isTablet),
624        isPhone: constant(isPhone),
625        isTouch: constant(isTouch),
626        isAndroid: os.isAndroid,
627        isiOS: os.isiOS,
628        isWebView: constant(iOSwebview),
629        isDesktop: constant(isDesktop)
630      };
631    };
632
633    const firstMatch = (regexes, s) => {
634      for (let i = 0; i < regexes.length; i++) {
635        const x = regexes[i];
636        if (x.test(s)) {
637          return x;
638        }
639      }
640      return undefined;
641    };
642    const find$1 = (regexes, agent) => {
643      const r = firstMatch(regexes, agent);
644      if (!r) {
645        return {
646          major: 0,
647          minor: 0
648        };
649      }
650      const group = i => {
651        return Number(agent.replace(r, '$' + i));
652      };
653      return nu$3(group(1), group(2));
654    };
655    const detect$4 = (versionRegexes, agent) => {
656      const cleanedAgent = String(agent).toLowerCase();
657      if (versionRegexes.length === 0) {
658        return unknown$2();
659      }
660      return find$1(versionRegexes, cleanedAgent);
661    };
662    const unknown$2 = () => {
663      return nu$3(0, 0);
664    };
665    const nu$3 = (major, minor) => {
666      return {
667        major,
668        minor
669      };
670    };
671    const Version = {
672      nu: nu$3,
673      detect: detect$4,
674      unknown: unknown$2
675    };
676
677    const detectBrowser$1 = (browsers, userAgentData) => {
678      return findMap(userAgentData.brands, uaBrand => {
679        const lcBrand = uaBrand.brand.toLowerCase();
680        return find$2(browsers, browser => {
681          var _a;
682          return lcBrand === ((_a = browser.brand) === null || _a === void 0 ? void 0 : _a.toLowerCase());
683        }).map(info => ({
684          current: info.name,
685          version: Version.nu(parseInt(uaBrand.version, 10), 0)
686        }));
687      });
688    };
689
690    const detect$3 = (candidates, userAgent) => {
691      const agent = String(userAgent).toLowerCase();
692      return find$2(candidates, candidate => {
693        return candidate.search(agent);
694      });
695    };
696    const detectBrowser = (browsers, userAgent) => {
697      return detect$3(browsers, userAgent).map(browser => {
698        const version = Version.detect(browser.versionRegexes, userAgent);
699        return {
700          current: browser.name,
701          version
702        };
703      });
704    };
705    const detectOs = (oses, userAgent) => {
706      return detect$3(oses, userAgent).map(os => {
707        const version = Version.detect(os.versionRegexes, userAgent);
708        return {
709          current: os.name,
710          version
711        };
712      });
713    };
714
715    const removeFromStart = (str, numChars) => {
716      return str.substring(numChars);
717    };
718
719    const checkRange = (str, substr, start) => substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
720    const removeLeading = (str, prefix) => {
721      return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
722    };
723    const contains$1 = (str, substr, start = 0, end) => {
724      const idx = str.indexOf(substr, start);
725      if (idx !== -1) {
726        return isUndefined(end) ? true : idx + substr.length <= end;
727      } else {
728        return false;
729      }
730    };
731    const startsWith = (str, prefix) => {
732      return checkRange(str, prefix, 0);
733    };
734    const endsWith = (str, suffix) => {
735      return checkRange(str, suffix, str.length - suffix.length);
736    };
737    const blank = r => s => s.replace(r, '');
738    const trim$4 = blank(/^\s+|\s+$/g);
739    const lTrim = blank(/^\s+/g);
740    const rTrim = blank(/\s+$/g);
741    const isNotEmpty = s => s.length > 0;
742    const isEmpty$3 = s => !isNotEmpty(s);
743    const repeat = (s, count) => count <= 0 ? '' : new Array(count + 1).join(s);
744    const toInt = (value, radix = 10) => {
745      const num = parseInt(value, radix);
746      return isNaN(num) ? Optional.none() : Optional.some(num);
747    };
748
749    const normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
750    const checkContains = target => {
751      return uastring => {
752        return contains$1(uastring, target);
753      };
754    };
755    const browsers = [
756      {
757        name: 'Edge',
758        versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
759        search: uastring => {
760          return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
761        }
762      },
763      {
764        name: 'Chromium',
765        brand: 'Chromium',
766        versionRegexes: [
767          /.*?chrome\/([0-9]+)\.([0-9]+).*/,
768          normalVersionRegex
769        ],
770        search: uastring => {
771          return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
772        }
773      },
774      {
775        name: 'IE',
776        versionRegexes: [
777          /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
778          /.*?rv:([0-9]+)\.([0-9]+).*/
779        ],
780        search: uastring => {
781          return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
782        }
783      },
784      {
785        name: 'Opera',
786        versionRegexes: [
787          normalVersionRegex,
788          /.*?opera\/([0-9]+)\.([0-9]+).*/
789        ],
790        search: checkContains('opera')
791      },
792      {
793        name: 'Firefox',
794        versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
795        search: checkContains('firefox')
796      },
797      {
798        name: 'Safari',
799        versionRegexes: [
800          normalVersionRegex,
801          /.*?cpu os ([0-9]+)_([0-9]+).*/
802        ],
803        search: uastring => {
804          return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
805        }
806      }
807    ];
808    const oses = [
809      {
810        name: 'Windows',
811        search: checkContains('win'),
812        versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
813      },
814      {
815        name: 'iOS',
816        search: uastring => {
817          return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
818        },
819        versionRegexes: [
820          /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
821          /.*cpu os ([0-9]+)_([0-9]+).*/,
822          /.*cpu iphone os ([0-9]+)_([0-9]+).*/
823        ]
824      },
825      {
826        name: 'Android',
827        search: checkContains('android'),
828        versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
829      },
830      {
831        name: 'macOS',
832        search: checkContains('mac os x'),
833        versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
834      },
835      {
836        name: 'Linux',
837        search: checkContains('linux'),
838        versionRegexes: []
839      },
840      {
841        name: 'Solaris',
842        search: checkContains('sunos'),
843        versionRegexes: []
844      },
845      {
846        name: 'FreeBSD',
847        search: checkContains('freebsd'),
848        versionRegexes: []
849      },
850      {
851        name: 'ChromeOS',
852        search: checkContains('cros'),
853        versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
854      }
855    ];
856    const PlatformInfo = {
857      browsers: constant(browsers),
858      oses: constant(oses)
859    };
860
861    const edge = 'Edge';
862    const chromium = 'Chromium';
863    const ie = 'IE';
864    const opera = 'Opera';
865    const firefox = 'Firefox';
866    const safari = 'Safari';
867    const unknown$1 = () => {
868      return nu$2({
869        current: undefined,
870        version: Version.unknown()
871      });
872    };
873    const nu$2 = info => {
874      const current = info.current;
875      const version = info.version;
876      const isBrowser = name => () => current === name;
877      return {
878        current,
879        version,
880        isEdge: isBrowser(edge),
881        isChromium: isBrowser(chromium),
882        isIE: isBrowser(ie),
883        isOpera: isBrowser(opera),
884        isFirefox: isBrowser(firefox),
885        isSafari: isBrowser(safari)
886      };
887    };
888    const Browser = {
889      unknown: unknown$1,
890      nu: nu$2,
891      edge: constant(edge),
892      chromium: constant(chromium),
893      ie: constant(ie),
894      opera: constant(opera),
895      firefox: constant(firefox),
896      safari: constant(safari)
897    };
898
899    const windows = 'Windows';
900    const ios = 'iOS';
901    const android = 'Android';
902    const linux = 'Linux';
903    const macos = 'macOS';
904    const solaris = 'Solaris';
905    const freebsd = 'FreeBSD';
906    const chromeos = 'ChromeOS';
907    const unknown = () => {
908      return nu$1({
909        current: undefined,
910        version: Version.unknown()
911      });
912    };
913    const nu$1 = info => {
914      const current = info.current;
915      const version = info.version;
916      const isOS = name => () => current === name;
917      return {
918        current,
919        version,
920        isWindows: isOS(windows),
921        isiOS: isOS(ios),
922        isAndroid: isOS(android),
923        isMacOS: isOS(macos),
924        isLinux: isOS(linux),
925        isSolaris: isOS(solaris),
926        isFreeBSD: isOS(freebsd),
927        isChromeOS: isOS(chromeos)
928      };
929    };
930    const OperatingSystem = {
931      unknown,
932      nu: nu$1,
933      windows: constant(windows),
934      ios: constant(ios),
935      android: constant(android),
936      linux: constant(linux),
937      macos: constant(macos),
938      solaris: constant(solaris),
939      freebsd: constant(freebsd),
940      chromeos: constant(chromeos)
941    };
942
943    const detect$2 = (userAgent, userAgentDataOpt, mediaMatch) => {
944      const browsers = PlatformInfo.browsers();
945      const oses = PlatformInfo.oses();
946      const browser = userAgentDataOpt.bind(userAgentData => detectBrowser$1(browsers, userAgentData)).orThunk(() => detectBrowser(browsers, userAgent)).fold(Browser.unknown, Browser.nu);
947      const os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
948      const deviceType = DeviceType(os, browser, userAgent, mediaMatch);
949      return {
950        browser,
951        os,
952        deviceType
953      };
954    };
955    const PlatformDetection = { detect: detect$2 };
956
957    const mediaMatch = query => window.matchMedia(query).matches;
958    let platform$4 = cached(() => PlatformDetection.detect(

958window.navigator.userAgent, Optional.from(window.navigator.userAgentData), mediaMatch));
959    const detect$1 = () => platform$4();
960
961    const userAgent = window.navigator.userAgent;
962    const platform$3 = detect$1();
963    const browser$3 = platform$3.browser;
964    const os$1 = platform$3.os;
965    const deviceType = platform$3.deviceType;
966    const windowsPhone = userAgent.indexOf('Windows Phone') !== -1;
967    const Env = {
968      transparentSrc: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
969      documentMode: browser$3.isIE() ? document.documentMode || 7 : 10,
970      cacheSuffix: null,
971      container: null,
972      canHaveCSP: !browser$3.isIE(),
973      windowsPhone,
974      browser: {
975        current: browser$3.current,
976        version: browser$3.version,
977        isChromium: browser$3.isChromium,
978        isEdge: browser$3.isEdge,
979        isFirefox: browser$3.isFirefox,
980        isIE: browser$3.isIE,
981        isOpera: browser$3.isOpera,
982        isSafari: browser$3.isSafari
983      },
984      os: {
985        current: os$1.current,
986        version: os$1.version,
987        isAndroid: os$1.isAndroid,
988        isChromeOS: os$1.isChromeOS,
989        isFreeBSD: os$1.isFreeBSD,
990        isiOS: os$1.isiOS,
991        isLinux: os$1.isLinux,
992        isMacOS: os$1.isMacOS,
993        isSolaris: os$1.isSolaris,
994        isWindows: os$1.isWindows
995      },
996      deviceType: {
997        isDesktop: deviceType.isDesktop,
998        isiPad: deviceType.isiPad,
999        isiPhone: deviceType.isiPhone,
1000        isPhone: deviceType.isPhone,
1001        isTablet: deviceType.isTablet,
1002        isTouch: deviceType.isTouch,
1003        isWebView: deviceType.isWebView
1004      }
1005    };
1006
1007    const whiteSpaceRegExp$1 = /^\s*|\s*$/g;
1008    const trim$3 = str => {
1009      return isNullable(str) ? '' : ('' + str).replace(whiteSpaceRegExp$1, '');
1010    };
1011    const is$3 = (obj, type) => {
1012      if (!type) {
1013        return obj !== undefined;
1014      }
1015      if (type === 'array' && isArray(obj)) {
1016        return true;
1017      }
1018      return typeof obj === type;
1019    };
1020    const makeMap$4 = (items, delim, map = {}) => {
1021      const resolvedItems = isString(items) ? items.split(delim || ',') : items || [];
1022      let i = resolvedItems.length;
1023      while (i--) {
1024        map[resolvedItems[i]] = {};
1025      }
1026      return map;
1027    };
1028    const hasOwnProperty = has$2;
1029    const extend$3 = (obj, ...exts) => {
1030      for (let i = 0; i < exts.length; i++) {
1031        const ext = exts[i];
1032        for (const name in ext) {
1033          if (has$2(ext, name)) {
1034            const value = ext[name];
1035            if (value !== undefined) {
1036              obj[name] = value;
1037            }
1038          }
1039        }
1040      }
1041      return obj;
1042    };
1043    const walk$4 = function (o, f, n, s) {
1044      s = s || this;
1045      if (o) {
1046        if (n) {
1047          o = o[n];
1048        }
1049        each$c(o, (o, i) => {
1050          if (f.call(s, o, i, n) === false) {
1051            return false;

1052          } else {
1053            walk$4(o, f, n, s);
1054            return true;
1055          }
1056        });
1057      }
1058    };
1059    const resolve$3 = (n, o = window) => {
1060      const path = n.split('.');
1061      for (let i = 0, l = path.length; i < l; i++) {
1062        o = o[path[i]];
1063        if (!o) {
1064          break;
1065        }
1066      }
1067      return o;
1068    };
1069    const explode$3 = (s, d) => {
1070      if (isArray$1(s)) {
1071        return s;
1072      } else if (s === '') {
1073        return [];
1074      } else {
1075        return map$1(s.split(d || ','), trim$3);
1076      }
1077    };
1078    const _addCacheSuffix = url => {
1079      const cacheSuffix = Env.cacheSuffix;
1080      if (cacheSuffix) {
1081        url += (url.indexOf('?') === -1 ? '?' : '&') + cacheSuffix;
1082      }
1083      return url;
1084    };
1085    const Tools = {
1086      trim: trim$3,
1087      isArray: isArray,
1088      is: is$3,
1089      toArray: toArray$1,
1090      makeMap: makeMap$4,
1091      each: each$c,
1092      map: map$1,
1093      grep: filter$3,
1094      inArray: indexOf,
1095      hasOwn: hasOwnProperty,
1096      extend: extend$3,
1097      walk: walk$4,
1098      resolve: resolve$3,
1099      explode: explode$3,
1100      _addCacheSuffix
1101    };
1102
1103    const is$2 = (lhs, rhs, comparator = tripleEquals) => lhs.exists(left => comparator(left, rhs));
1104    const equals = (lhs, rhs, comparator = tripleEquals) => lift2(lhs, rhs, comparator).getOr(lhs.isNone() && rhs.isNone());
1105    const cat = arr => {
1106      const r = [];
1107      const push = x => {
1108        r.push(x);
1109      };
1110      for (let i = 0; i < arr.length; i++) {
1111        arr[i].each(push);
1112      }
1113      return r;
1114    };
1115    const lift2 = (oa, ob, f) => oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none();
1116    const lift3 = (oa, ob, oc, f) => oa.isSome() && ob.isSome() && oc.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie(), oc.getOrDie())) : Optional.none();
1117    const someIf = (b, a) => b ? Optional.some(a) : Optional.none();
1118
1119    const Global = typeof window !== 'undefined' ? window : Function('return this;')();
1120
1121    const path = (parts, scope) => {
1122      let o = scope !== undefined && scope !== null ? scope : Global;
1123      for (let i = 0; i < parts.length && o !== undefined && o !== null; ++i) {
1124        o = o[parts[i]];
1125      }
1126      return o;
1127    };
1128    const resolve$2 = (p, scope) => {
1129      const parts = p.split('.');
1130      return path(parts, scope);
1131    };
1132
1133    const unsafe = (name, scope) => {
1134      return resolve$2(name, scope);
1135    };
1136    const getOrDie = (name, scope) => {
1137      const actual = unsafe(name, scope);
1138      if (actual === undefined || actual === null) {
1139        throw new Error(name + ' not available on this browser');
1140      }
1141      return actual;
1142    };
1143
1144    const getPrototypeOf$1 = Object.getPrototypeOf;
1145    const sandHTMLElement = scope => {
1146      return getOrDie('HTMLElement', scope);
1147    };
1148    const isPrototypeOf = x => {
1149      const scope = resolve$2('ownerDocument.defaultView', x);
1150      return isObject(x) && (sandHTMLElement(scope).prototype.isPrototypeOf(x) || /^HTML\w*Element$/.test(getPrototypeOf$1(x).constructor.name));
1151    };
1152
1153    const COMMENT = 8;
1154    const DOCUMENT = 9;
1155    const DOCUMENT_FRAGMENT = 11;
1156    const ELEMENT = 1;
1157    const TEXT = 3;
1158
1159    const name = element => {
1160      const r = element.dom.nodeName;
1161      return r.toLowerCase();
1162    };
1163    const type$1 = element => element.dom.nodeType;
1164    const isType = t => element => type$1(element) === t;
1165    const isComment$1 = element => type$1(element) === COMMENT || name(element) === '#comment';
1166    const isHTMLElement$1 = element => isElement$7(element) && isPrototypeOf(element.dom);
1167    const isElement$7 = isType(ELEMENT);
1168    const isText$c = isType(TEXT);
1169    const isDocument$2 = isType(DOCUMENT);
1170    const isDocumentFragment$1 = isType(DOCUMENT_FRAGMENT);
1171    const isTag = tag => e => isElement$7(e) && name(e) === tag;
1172
1173    const rawSet = (dom, key, value) => {
1174      if (isString(value) || isBoolean(value) || isNumber(value)) {
1175        dom.setAttribute(key, value + '');
1176      } else {
1177        console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
1178        throw new Error('Attribute value was not simple');
1179      }
1180    };
1181    const set$4 = (element, key, value) => {
1182      rawSet(element.dom, key, value);
1183    };
1184    const setAll$1 = (element, attrs) => {
1185      const dom = element.dom;
1186      each$d(attrs, (v, k) => {
1187        rawSet(dom, k, v);
1188      });
1189    };
1190    const get$9 = (element, key) => {
1191      const v = element.dom.getAttribute(key);
1192      return v === null ? undefined : v;
1193    };
1194    const getOpt = (element, key) => Optional.from(get$9(element, key));
1195    const has$1 = (element, key) => {
1196      const dom = element.dom;
1197      return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
1198    };
1199    const remove$9 = (element, key) => {
1200      element.dom.removeAttribute(key);
1201    };
1202    const hasNone = element => {
1203      const attrs = element.dom.attributes;
1204      return attrs === undefined || attrs === null || attrs.length === 0;
1205    };
1206    const clone$4 = element => foldl(element.dom.attributes, (acc, attr) => {
1207      acc[attr.name] = attr.value;
1208      return acc;
1209    }, {});
1210
1211    const read$4 = (element, attr) => {
1212      const value = get$9(element, attr);
1213      return value === undefined || value === '' ? [] : value.split(' ');
1214    };
1215    const add$4 = (element, attr, id) => {
1216      const old = read$4(element, attr);
1217      const nu = old.concat([id]);
1218      set$4(element, attr, nu.join(' '));
1219      return true;
1220    };
1221    const remove$8 = (element, attr, id) => {
1222      const nu = filter$5(read$4(element, attr), v => v !== id);
1223      if (nu.length > 0) {
1224        set$4(element, attr, nu.join(' '));
1225      } else {
1226        remove$9(element, attr);
1227      }
1228      return false;
1229    };
1230
1231    const supports = element => element.dom.classList !== undefined;
1232    const get$8 = element => read$4(element, 'class');
1233    const add$3 = (element, clazz) => add$4(element, 'class', clazz);
1234    const remove$7 = (element, clazz) => remove$8(element, 'class', clazz);
1235    const toggle$2 = (element, clazz) => {
1236      if (contains$2(get$8(element), clazz)) {
1237        return remove$7(element, clazz);
1238      } else {
1239        return add$3(element, clazz);
1240      }
1241    };
1242
1243    const add$2 = (element, clazz) => {
1244      if (supports(element)) {
1245        element.dom.classList.add(clazz);
1246      } else {
1247        add$3(element, clazz);
1248      }
1249    };
1250    const cleanClass = element => {
1251      const classList = supports(element) ? element.dom.classList : get$8(element);
1252      if (classList.length === 0) {
1253        remove$9(element, 'class');
1254      }
1255    };
1256    const remove$6 = (element, clazz) => {
1257      if (supports(element)) {
1258        const classList = element.dom.classList;
1259        classList.remove(clazz);
1260      } else {
1261        remove$7(element, clazz);
1262      }
1263      cleanClass(element);
1264    };
1265    const toggle$1 = (element, clazz) => {
1266      const result = supports(element) ? element.dom.classList.toggle(clazz) : toggle$2(element, clazz);
1267      cleanClass(element);
1268      return result;
1269    };
1270    const has = (element, clazz) => supports(element) && element.dom.classList.contains(clazz);
1271
1272    const fromHtml$1 = (html, scope) => {
1273      const doc = scope || document;
1274      const div = doc.createElement('div');
1275      div.innerHTML = html;
1276      if (!div.hasChildNodes() || div.childNodes.length > 1) {
1277        const message = 'HTML does not have a single root node';
1278        console.error(message, html);
1279        throw new Error(message);
1280      }
1281      return fromDom$2(div.childNodes[0]);
1282    };
1283    const fromTag = (tag, scope) => {
1284      const doc = scope || document;
1285      const node = doc.createElement(tag);
1286      return fromDom$2(node);
1287    };
1288    const fromText = (text, scope) => {
1289      const doc = scope || document;
1290      const node = doc.createTextNode(text);
1291      return fromDom$2(node);
1292    };
1293    const fromDom$2 = node => {
1294      if (node === null || node === undefined) {
1295        throw new Error('Node cannot be null or undefined');
1296      }
1297      return { dom: node };
1298    };
1299    const fromPoint$2 = (docElm, x, y) => Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom$2);
1300    const SugarElement = {
1301      fromHtml: fromHtml$1,
1302      fromTag,
1303      fromText,
1304      fromDom: fromDom$2,
1305      fromPoint: fromPoint$2
1306    };
1307
1308    const toArray = (target, f) => {
1309      const r = [];
1310      const recurse = e => {
1311        r.push(e);
1312        return f(e);
1313      };
1314      let cur = f(target);
1315      do {
1316        cur = cur.bind(recurse);
1317      } while (cur.isSome());
1318      return r;
1319    };
1320
1321    const is$1 = (element, selector) => {
1322      const dom = element.dom;
1323      if (dom.nodeType !== ELEMENT) {
1324        return false;
1325      } else {
1326        const elem = dom;
1327        if (elem.matches !== undefined) {
1328          return elem.matches(selector);
1329        } else if (elem.msMatchesSelector !== undefined) {
1330          return elem.msMatchesSelector(selector);
1331        } else if (elem.webkitMatchesSelector !== undefined) {
1332          return elem.webkitMatchesSelector(selector);
1333        } else if (elem.mozMatchesSelector !== undefined) {
1334          return elem.mozMatchesSelector(selector);
1335        } else {
1336          throw new Error('Browser lacks native selectors');
1337        }
1338      }
1339    };
1340    const bypassSelector = dom => dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT || dom.childElementCount === 0;
1341    const all = (selector, scope) => {
1342      const base = scope === undefined ? document : scope.dom;
1343      return bypassSelector(base) ? [] : map$3(base.querySelectorAll(selector), SugarElement.fromDom);
1344    };
1345    const one = (selector, scope) => {
1346      const base = scope === undefined ? document : scope.dom;
1347      return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom);
1348    };
1349
1350    const eq = (e1, e2) => e1.dom === e2.dom;
1351    const contains = (e1, e2) => {
1352      const d1 = e1.dom;
1353      const d2 = e2.dom;
1354      return d1 === d2 ? false : d1.contains(d2);
1355    };
1356
1357    const owner$1 = element => SugarElement.fromDom(element.dom.ownerDocument);
1358    const documentOrOwner = dos => isDocument$2(dos) ? dos : owner$1(dos);
1359    const documentElement = element => SugarElement.fromDom(documentOrOwner(element).dom.documentElement);
1360    const defaultView = element => SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
1361    const parent = element => Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
1362    const parentElement = element => Optional.from(element.dom.parentElement).map(SugarElement.fromDom);
1363    const parents$1 = (element, isRoot) => {
1364      const stop = isFunction(isRoot) ? isRoot : never;
1365      let dom = element.dom;
1366      const ret = [];
1367      while (dom.parentNode !== null && dom.parentNode !== undefined) {
1368        const rawParent = dom.parentNode;
1369        const p = SugarElement.fromDom(rawParent);
1370        ret.push(p);
1371        if (stop(p) === true) {
1372          break;
1373        } else {
1374          dom = rawParent;
1375        }
1376      }
1377      return ret;
1378    };
1379    const siblings = element => {
1380      const filterSelf = elements => filter$5(elements, x => !eq(element, x));
1381      return parent(element).map(children$1).map(filterSelf).getOr([]);
1382    };
1383    const prevSibling = element => Optional.from(element.dom.previousSibling).map(SugarElement.fromDom);
1384    const nextSibling = element => Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
1385    const prevSiblings = element => reverse(toArray(element, prevSibling));
1386    const nextSiblings = element => toArray(element, nextSibling);
1387    const children$1 = element => map$3(element.dom.childNodes, SugarElement.fromDom);
1388    const child$1 = (element, index) => {
1389      const cs = element.dom.childNodes;
1390      return Optional.from(cs[index]).map(SugarElement.fromDom);
1391    };
1392    const firstChild = element => child$1(element, 0);
1393    const lastChild = element => child$1(element, element.dom.childNodes.length - 1);
1394    const childNodesCount = element => element.dom.childNodes.length;
1395
1396    const getHead = doc => {
1397      const b = doc.dom.head;
1398      if (b === null || b === undefined) {
1399        throw new Error('Head is not available yet');
1400      }
1401      return SugarElement.fromDom(b);
1402    };
1403
1404    const isShadowRoot = dos => isDocumentFragment$1(dos) && isNonNullable(dos.dom.host);
1405    const getRootNode = e => SugarElement.fromDom(e.dom.getRootNode());
1406    const getStyleContainer = dos => isShadowRoot(dos) ? dos : getHead(documentOrOwner(dos));
1407    const getContentContainer = dos => isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body);
1408    const getShadowRoot = e => {
1409      const r = getRootNode(e);
1410      return isShadowRoot(r) ? Optional.some(r) : Optional.none();
1411    };
1412    const getShadowHost = e => SugarElement.fromDom(e.dom.host);
1413    const getOriginalEventTarget = event => {
1414      if (isNonNullable(event.target)) {
1415        const el = SugarElement.fromDom(event.target);
1416        if (isElement$7(el) && isOpenShadowHost(el)) {
1417          if (event.composed && event.composedPath) {
1418            const composedPath = event.composedPath();
1419            if (composedPath) {
1420              return head(composedPath);
1421            }
1422          }
1423        }
1424      }
1425      return Optional.from(event.target);
1426    };
1427    const isOpenShadowHost = element => isNonNullable(element.dom.shadowRoot);
1428
1429    const inBody = element => {
1430      const dom = isText$c(element) ? element.dom.parentNode : element.dom;
1431      if (dom === undefined || dom === null || dom.ownerDocument === null) {
1432        return false;
1433      }
1434      const doc = dom.ownerDocument;
1435      return getShadowRoot(SugarElement.fromDom(dom)).fold(() => doc.body.contains(dom), compose1(inBody, getShadowHost));
1436    };
1437
1438    var ClosestOrAncestor = (is, ancestor, scope, a, isRoot) => {
1439      if (is(scope, a)) {
1440        return Optional.some(scope);
1441      } else if (isFunction(isRoot) && isRoot(scope)) {
1442        return Optional.none();
1443      } else {
1444        return ancestor(scope, a, isRoot);
1445      }
1446    };
1447
1448    const ancestor$4 = (scope, predicate, isRoot) => {
1449      let element = scope.dom;
1450      const stop = isFunction(isRoot) ? isRoot : never;
1451      while (element.parentNode) {
1452        element = element.parentNode;
1453        const el = SugarElement.fromDom(element);
1454        if (predicate(el)) {
1455          return Optional.some(el);
1456        } else if (stop(el)) {
1457          break;
1458        }
1459      }
1460      return Optional.none();
1461    };
1462    const closest$4 = (scope, predicate, isRoot) => {
1463      const is = (s, test) => test(s);
1464      return ClosestOrAncestor(is, ancestor$4, scope, predicate, isRoot);
1465    };
1466    const sibling$1 = (scope, predicate) => {
1467      const element = scope.dom;
1468      if (!element.parentNode) {
1469        return Optional.none();
1470      }
1471      return child(SugarElement.fromDom(element.parentNode), x => !eq(scope, x) && predicate(x));
1472    };
1473    const child = (scope, predicate) => {
1474      const pred = node => predicate(SugarElement.fromDom(node));
1475      const result = find$2(scope.dom.childNodes, pred);
1476      return result.map(SugarElement.fromDom);
1477    };
1478    const descendant$2 = (scope, predicate) => {
1479      const descend = node => {
1480        for (let i = 0; i < node.childNodes.length; i++) {
1481          const child = SugarElement.fromDom(node.childNodes[i]);
1482          if (predicate(child)) {
1483            return Optional.some(child);
1484          }
1485          const res = descend(node.childNodes[i]);
1486          if (res.isSome()) {
1487            return res;
1488          }
1489        }
1490        return Optional.none();
1491      };
1492      return descend(scope.dom);
1493    };
1494
1495    const ancestor$3 = (scope, selector, isRoot) => ancestor$4(scope, e => is$1(e, selector), isRoot);
1496    const descendant$1 = (scope, selector) => one(selector, scope);
1497    const closest$3 = (scope, selector, isRoot) => {
1498      const is = (element, selector) => is$1(element, selector);
1499      return ClosestOrAncestor(is, ancestor$3, scope, selector, isRoot);
1500    };
1501
1502    const closest$2 = target => closest$3(target, '[contenteditable]');
1503    const isEditable$2 = (element, assumeEditable = false) => {
1504      if (inBody(element)) {
1505        return element.dom.isContentEditable;
1506      } else {
1507        return closest$2(element).fold(constant(assumeEditable), editable => getRaw$1(editable) === 'true');
1508      }
1509    };
1510    const getRaw$1 = element => element.dom.contentEditable;
1511    const set$3 = (element, editable) => {
1512      element.dom.contentEditable = editable ? 'true' : 'false';
1513    }

1513;
1514
1515    const isSupported = dom => dom.style !== undefined && isFunction(dom.style.getPropertyValue);
1516
1517    const internalSet = (dom, property, value) => {
1518      if (!isString(value)) {
1519        console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
1520        throw new Error('CSS value must be a string: ' + value);
1521      }
1522      if (isSupported(dom)) {
1523        dom.style.setProperty(property, value);
1524      }
1525    };
1526    const internalRemove = (dom, property) => {
1527      if (isSupported(dom)) {
1528        dom.style.removeProperty(property);
1529      }
1530    };
1531    const set$2 = (element, property, value) => {
1532      const dom = element.dom;
1533      internalSet(dom, property, value);
1534    };
1535    const setAll = (element, css) => {
1536      const dom = element.dom;
1537      each$d(css, (v, k) => {
1538        internalSet(dom, k, v);
1539      });
1540    };
1541    const get$7 = (element, property) => {
1542      const dom = element.dom;
1543      const styles = window.getComputedStyle(dom);
1544      const r = styles.getPropertyValue(property);
1545      return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r;
1546    };
1547    const getUnsafeProperty = (dom, property) => isSupported(dom) ? dom.style.getPropertyValue(property) : '';
1548    const getRaw = (element, property) => {
1549      const dom = element.dom;
1550      const raw = getUnsafeProperty(dom, property);
1551      return Optional.from(raw).filter(r => r.length > 0);
1552    };
1553    const getAllRaw = element => {
1554      const css = {};
1555      const dom = element.dom;
1556      if (isSupported(dom)) {
1557        for (let i = 0; i < dom.style.length; i++) {
1558          const ruleName = dom.style.item(i);
1559          css[ruleName] = dom.style[ruleName];
1560        }
1561      }
1562      return css;
1563    };
1564    const remove$5 = (element, property) => {
1565      const dom = element.dom;
1566      internalRemove(dom, property);
1567      if (is$2(getOpt(element, 'style').map(trim$4), '')) {
1568        remove$9(element, 'style');
1569      }
1570    };
1571    const reflow = e => e.dom.offsetWidth;
1572
1573    const before$3 = (marker, element) => {
1574      const parent$1 = parent(marker);
1575      parent$1.each(v => {
1576        v.dom.insertBefore(element.dom, marker.dom);
1577      });
1578    };
1579    const after$4 = (marker, element) => {
1580      const sibling = nextSibling(marker);
1581      sibling.fold(() => {
1582        const parent$1 = parent(marker);
1583        parent$1.each(v => {
1584          append$1(v, element);
1585        });
1586      }, v => {
1587        before$3(v, element);
1588      });
1589    };
1590    const prepend = (parent, element) => {
1591      const firstChild$1 = firstChild(parent);
1592      firstChild$1.fold(() => {
1593        append$1(parent, element);
1594      }, v => {
1595        parent.dom.insertBefore(element.dom, v.dom);
1596      });
1597    };
1598    const append$1 = (parent, element) => {
1599      parent.dom.appendChild(element.dom);
1600    };
1601    const wrap$2 = (element, wrapper) => {
1602      before$3(element, wrapper);
1603      append$1(wrapper, element);
1604    };
1605
1606    const after$3 = (marker, elements) => {
1607      each$e(elements, (x, i) => {
1608        const e = i === 0 ? marker : elements[i - 1];
1609        after$4(e, x);
1610      });
1611    };
1612    const append = (parent, elements) => {
1613      each$e(elements, x => {
1614        append$1(parent, x);
1615      });
1616    };
1617
1618    const empty = element => {
1619      element.dom.textContent = '';
1620      each$e(children$1(element), rogue => {
1621        remove$4(rogue);
1622      });
1623    };
1624    const remove$4 = element => {
1625      const dom = element.dom;
1626      if (dom.parentNode !== null) {
1627        dom.parentNode.removeChild(dom);
1628      }
1629    };
1630    const unwrap = wrapper => {
1631      const children = children$1(wrapper);
1632      if (children.length > 0) {
1633        after$3(wrapper, children);
1634      }
1635      remove$4(wrapper);
1636    };
1637
1638    const fromHtml = (html, scope) => {
1639      const doc = scope || document;
1640      const div = doc.createElement('div');
1641      div.innerHTML = html;
1642      return children$1(SugarElement.fromDom(div));
1643    };
1644    const fromDom$1 = nodes => map$3(nodes, SugarElement.fromDom);
1645
1646    const get$6 = element => element.dom.innerHTML;
1647    const set$1 = (element, content) => {
1648      const owner = owner$1(element);
1649      const docDom = owner.dom;
1650      const fragment = SugarElement.fromDom(docDom.createDocumentFragment());
1651      const contentElements = fromHtml(content, docDom);
1652      append(fragment, contentElements);
1653      empty(element);
1654      append$1(element, fragment);
1655    };
1656    const getOuter = element => {
1657      const container = SugarElement.fromTag('div');
1658      const clone = SugarElement.fromDom(element.dom.cloneNode(true));
1659      append$1(container, clone);
1660      return get$6(container);
1661    };
1662
1663    const mkEvent = (target, x, y, stop, prevent, kill, raw) => ({
1664      target,
1665      x,
1666      y,
1667      stop,
1668      prevent,
1669      kill,
1670      raw
1671    });
1672    const fromRawEvent = rawEvent => {
1673      const target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target));
1674      const stop = () => rawEvent.stopPropagation();
1675      const prevent = () => rawEvent.preventDefault();
1676      const kill = compose(prevent, stop);
1677      return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent);
1678    };
1679    const handle$1 = (filter, handler) => rawEvent => {
1680      if (filter(rawEvent)) {
1681        handler(fromRawEvent(rawEvent));
1682      }
1683    };
1684    const binder = (element, event, filter, handler, useCapture) => {
1685      const wrapped = handle$1(filter, handler);
1686      element.dom.addEventListener(event, wrapped, useCapture);
1687      return { unbind: curry(unbind, element, event, wrapped, useCapture) };
1688    };
1689    const bind$2 = (element, event, filter, handler) => binder(element, event, filter, handler, false);
1690    const unbind = (element, event, handler, useCapture) => {
1691      element.dom.removeEventListener(event, handler, useCapture);
1692    };
1693
1694    const r = (left, top) => {
1695      const translate = (x, y) => r(left + x, top + y);
1696      return {
1697        left,
1698        top,
1699        translate
1700      };
1701    };
1702    const SugarPosition = r;
1703
1704    const boxPosition = dom => {
1705      const box = dom.getBoundingClientRect();
1706      return SugarPosition(box.left, box.top);
1707    };
1708    const firstDefinedOrZero = (a, b) => {
1709      if (a !== undefined) {
1710        return a;
1711      } else {
1712        return b !== undefined ? b : 0;
1713      }
1714    };
1715    const absolute = element => {
1716      const doc = element.dom.ownerDocument;
1717      const body = doc.body;
1718      const win = doc.defaultView;
1719      const html = doc.documentElement;
1720      if (body === element.dom) {
1721        return SugarPosition(body.offsetLeft, body.offsetTop);
1722      }
1723      const scrollTop = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageYOffset, html.scrollTop);
1724      const scrollLeft = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageXOffset, html.scrollLeft);
1725      const clientTop = firstDefinedOrZero(html.clientTop, body.clientTop);
1726      const clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft);
1727      return viewport(element).translate(scrollLeft - clientLeft, scrollTop - clientTop);
1728    };
1729    const viewport = element => {
1730      const dom = element.dom;
1731      const doc = dom.ownerDocument;
1732      const body = doc.body;
1733      if (body === dom) {
1734        return SugarPosition(body.offsetLeft, body.offsetTop);
1735      }
1736      if (!inBody(element)) {
1737        return SugarPosition(0, 0);
1738      }
1739      return boxPosition(dom);
1740    };
1741
1742    const get$5 = _DOC => {
1743      const doc = _DOC !== undefined ? _DOC.dom : document;
1744      const x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
1745      const y = doc.body.scrollTop || doc.documentElement.scrollTop;
1746      return SugarPosition(x, y);
1747    };
1748    const to = (x, y, _DOC) => {
1749      const doc = _DOC !== undefined ? _DOC.dom : document;
1750      const win = doc.defaultView;
1751      if (win) {
1752        win.scrollTo(x, y);
1753      }
1754    };
1755    const intoView = (element, alignToTop) => {
1756      const isSafari = detect$1().browser.isSafari();
1757      if (isSafari && isFunction(element.dom.scrollIntoViewIfNeeded)) {
1758        element.dom.scrollIntoViewIfNeeded(false);
1759      } else {
1760        element.dom.scrollIntoView(alignToTop);
1761      }
1762    };
1763
1764    const get$4 = _win => {
1765      const win = _win === undefined ? window : _win;
1766      if (detect$1().browser.isFirefox()) {
1767        return Optional.none();
1768      } else {
1769        return Optional.from(win.visualViewport);
1770      }
1771    };
1772    const bounds = (x, y, width, height) => ({
1773      x,
1774      y,
1775      width,
1776      height,
1777      right: x + width,
1778      bottom: y + height
1779    });
1780    const getBounds = _win => {
1781      const win = _win === undefined ? window : _win;
1782      const doc = win.document;
1783      const scroll = get$5(SugarElement.fromDom(doc));
1784      return get$4(win).fold(() => {
1785        const html = win.document.documentElement;
1786        const width = html.clientWidth;
1787        const height = html.clientHeight;
1788        return bounds(scroll.left, scroll.top, width, height);
1789      }, visualViewport => bounds(Math.max(visualViewport.pageLeft, scroll.left), Math.max(visualViewport.pageTop, scroll.top), visualViewport.width, visualViewport.height));
1790    };
1791
1792    const children = (scope, predicate) => filter$5(children$1(scope), predicate);
1793    const descendants$1 = (scope, predicate) => {
1794      let result = [];
1795      each$e(children$1(scope), x => {
1796        if (predicate(x)) {
1797          result = result.concat([x]);
1798        }
1799        result = result.concat(descendants$1(x, predicate));
1800      });
1801      return result;
1802    };
1803
1804    const descendants = (scope, selector) => all(selector, scope);
1805
1806    const ancestor$2 = (scope, predicate, isRoot) => ancestor$4(scope, predicate, isRoot).isSome();
1807    const sibling = (scope, predicate) => sibling$1(scope, predicate).isSome();
1808    const descendant = (scope, predicate) => descendant$2(scope, predicate).isSome();
1809
1810    class DomTreeWalker {
1811      constructor(startNode, rootNode) {
1812        this.node = startNode;
1813        this.rootNode = rootNode;
1814        this.current = this.current.bind(this);
1815        this.next = this.next.bind(this);
1816        this.prev = this.prev.bind(this);
1817        this.prev2 = this.prev2.bind(this);
1818      }
1819      current() {
1820        return this.node;
1821      }
1822      next(shallow) {
1823        this.node = this.findSibling(this.node, 'firstChild', 'nextSibling', shallow);
1824        return this.node;
1825      }
1826      prev(shallow) {
1827        this.node = this.findSibling(this.node, 'lastChild', 'previousSibling', shallow);
1828        return this.node;
1829      }
1830      prev2(shallow) {
1831        this.node = this.findPreviousNode(this.node, shallow);
1832        return this.node;
1833      }
1834      findSibling(node, startName, siblingName, shallow) {
1835        if (node) {
1836          if (!shallow && node[startName]) {
1837            return node[startName];
1838          }
1839          if (node !== this.rootNode) {
1840            let sibling = node[siblingName];
1841            if (sibling) {
1842              return sibling;
1843            }
1844            for (let parent = node.parentNode; parent && parent !== this.rootNode; parent = parent.parentNode) {
1845              sibling = parent[siblingName];
1846              if (sibling) {
1847                return sibling;
1848              }
1849            }
1850          }
1851        }
1852        return undefined;
1853      }
1854      findPreviousNode(node, shallow) {
1855        if (node) {
1856          const sibling = node.previousSibling;
1857          if (this.rootNode && sibling === this.rootNode) {
1858            return;
1859          }
1860          if (sibling) {
1861            if (!shallow) {
1862              for (let child = sibling.lastChild; child; child = child.lastChild) {
1863                if (!child.lastChild) {
1864                  return child;
1865                }
1866              }
1867            }
1868            return sibling;
1869          }
1870          const parent = node.parentNode;
1871          if (parent && parent !== this.rootNode) {
1872            return parent;
1873          }
1874        }
1875        return undefined;
1876      }
1877    }
1878
1879    const zeroWidth = '\uFEFF';
1880    const nbsp = '\xA0';
1881    const isZwsp$2 = char => char === zeroWidth;
1882    const removeZwsp = s => s.replace(/\uFEFF/g, '');
1883
1884    const whiteSpaceRegExp = /^[ \t\r\n]*$/;
1885    const isWhitespaceText = text => whiteSpaceRegExp.test(text);
1886    const isZwsp$1 = text => {
1887      for (const c of text) {
1888        if (!isZwsp$2(c)) {
1889          return false;
1890        }
1891      }
1892      return true;
1893    };
1894    const isCollapsibleWhitespace$1 = c => ' \f\t\x0B'.indexOf(c) !== -1;
1895    const isNewLineChar = c => c === '\n' || c === '\r';
1896    const isNewline = (text, idx) => idx < text.length && idx >= 0 ? isNewLineChar(text[idx]) : false;
1897    const normalize$4 = (text, tabSpaces = 4, isStartOfContent = true, isEndOfContent = true) => {
1898      const tabSpace = repeat(' ', tabSpaces);
1899      const normalizedText = text.replace(/\t/g, tabSpace);
1900      const result = foldl(normalizedText, (acc, c) => {
1901        if (isCollapsibleWhitespace$1(c) || c === nbsp) {
1902          if (acc.pcIsSpace || acc.str === '' && isStartOfContent || acc.str.length === normalizedText.length - 1 && isEndOfContent || isNewline(normalizedText, acc.str.length + 1)) {
1903            return {
1904              pcIsSpace: false,
1905              str: acc.str + nbsp
1906            };
1907          } else {
1908            return {
1909              pcIsSpace: true,
1910              str: acc.str + ' '
1911            };
1912          }
1913        } else {
1914          return {
1915            pcIsSpace: isNewLineChar(c),
1916            str: acc.str + c
1917          };
1918        }
1919      }, {
1920        pcIsSpace: false,
1921        str: ''
1922      });
1923      return result.str;
1924    };
1925
1926    const isNodeType = type => {
1927      return node => {
1928        return !!node && node.nodeType === type;
1929      };
1930    };
1931    const isRestrictedNode = node => !!node && !Object.getPrototypeOf(node);
1932    const isElement$6 = isNodeType(1);
1933    const isHTMLElement = node => isElement$6(node) && isHTMLElement$1(SugarElement.fromDom(node));
1934    const isSVGElement = node => isElement$6(node) && node.namespaceURI === 'http://www.w3.org/2000/svg';
1935    const matchNodeName = name => {
1936      const lowerCasedName = name.toLowerCase();
1937      return node => isNonNullable(node) && node.nodeName.toLowerCase() === lowerCasedName;
1938    };
1939    const matchNodeNames = names => {
1940      const lowerCasedNames = names.map(s => s.toLowerCase());
1941      return node => {
1942        if (node && node.nodeName) {
1943          const nodeName = node.nodeName.toLowerCase();
1944          return contains$2(lowerCasedNames, nodeName);
1945        }
1946        return false;
1947      };
1948    };
1949    const matchStyleValues = (name, values) => {
1950      const items = values.toLowerCase().split(' ');
1951      return node => {
1952        if (isElement$6(node)) {
1953          const win = node.ownerDocument.defaultView;
1954          if (win) {
1955            for (let i = 0; i < items.length; i++) {
1956              const computed = win.getComputedStyle(node, null);
1957              const cssValue = computed ? computed.getPropertyValue(name) : null;
1958              if (cssValue === items[i]) {
1959                return true;
1960              }
1961            }
1962          }
1963        }
1964        return false;
1965      };
1966    };
1967    const hasAttribute = attrName => {
1968      return node => {
1969        return isElement$6(node) && node.hasAttribute(attrName);
1970      };
1971    };
1972    const isBogus$1 = node => isElement$6(node) && node.hasAttribute('data-mce-bogus');
1973    const isBogusAll = node => isElement$6(node) && node.getAttribute('data-mce-bogus') === 'all';
1974    const isTable$2 = node => isElement$6(node) && node.tagName === 'TABLE';
1975    const hasContentEditableState = value => {
1976      return node => {
1977        if (isHTMLElement(node)) {
1978          if (node.contentEditable === value) {
1979            return true;
1980          }
1981          if (node.getAttribute('data-mce-contenteditable') === value) {
1982            return true;
1983          }
1984        }
1985        return false;
1986      };
1987    };
1988    const isTextareaOrInput = matchNodeNames([
1989      'textarea',
1990      'input'
1991    ]);
1992    const isText$b = isNodeType(3);
1993    const isCData = isNodeType(4);
1994    const isPi = isNodeType(7);
1995    const isComment = isNodeType(8);
1996    const isDocument$1 = isNodeType(9);
1997    const isDocumentFragment = isNodeType(11);
1998    const isBr$6 = matchNodeName('br');
1999    const isImg = matchNodeName('img');
2000    const isContentEditableTrue$3 = hasContentEditableState('true');
2001    const isContentEditableFalse$b = hasContentEditableState('false');
2002    const is

2002EditingHost = node => isHTMLElement(node) && node.isContentEditable && isNonNullable(node.parentElement) && !node.parentElement.isContentEditable;
2003    const isTableCell$3 = matchNodeNames([
2004      'td',
2005      'th'
2006    ]);
2007    const isTableCellOrCaption = matchNodeNames([
2008      'td',
2009      'th',
2010      'caption'
2011    ]);
2012    const isMedia$2 = matchNodeNames([
2013      'video',
2014      'audio',
2015      'object',
2016      'embed'
2017    ]);
2018    const isListItem$2 = matchNodeName('li');
2019    const isDetails = matchNodeName('details');
2020    const isSummary$1 = matchNodeName('summary');
2021
2022    const defaultOptionValues = {
2023      skipBogus: true,
2024      includeZwsp: false,
2025      checkRootAsContent: false
2026    };
2027    const hasWhitespacePreserveParent = (node, rootNode, schema) => {
2028      const rootElement = SugarElement.fromDom(rootNode);
2029      const startNode = SugarElement.fromDom(node);
2030      const whitespaceElements = schema.getWhitespaceElements();
2031      const predicate = node => has$2(whitespaceElements, name(node));
2032      return ancestor$2(startNode, predicate, curry(eq, rootElement));
2033    };
2034    const isNamedAnchor = node => {
2035      return isElement$6(node) && node.nodeName === 'A' && !node.hasAttribute('href') && (node.hasAttribute('name') || node.hasAttribute('id'));
2036    };
2037    const isNonEmptyElement$1 = (node, schema) => {
2038      return isElement$6(node) && has$2(schema.getNonEmptyElements(), node.nodeName);
2039    };
2040    const isBookmark = hasAttribute('data-mce-bookmark');
2041    const hasNonEditableParent = node => parentElement(SugarElement.fromDom(node)).exists(parent => !isEditable$2(parent));
2042    const isWhitespace$1 = (node, rootNode, schema) => isWhitespaceText(node.data) && !hasWhitespacePreserveParent(node, rootNode, schema);
2043    const isText$a = (node, rootNode, schema, options) => isText$b(node) && !isWhitespace$1(node, rootNode, schema) && (!options.includeZwsp || !isZwsp$1(node.data));
2044    const isContentNode = (schema, node, rootNode, options) => {
2045      return isFunction(options.isContent) && options.isContent(node) || isNonEmptyElement$1(node, schema) || isBookmark(node) || isNamedAnchor(node) || isText$a(node, rootNode, schema, options) || isContentEditableFalse$b(node) || isContentEditableTrue$3(node) && hasNonEditableParent(node);
2046    };
2047    const isEmptyNode = (schema, targetNode, opts) => {
2048      const options = {
2049        ...defaultOptionValues,
2050        ...opts
2051      };
2052      if (options.checkRootAsContent) {
2053        if (isContentNode(schema, targetNode, targetNode, options)) {
2054          return false;
2055        }
2056      }
2057      let node = targetNode.firstChild;
2058      let brCount = 0;
2059      if (!node) {
2060        return true;
2061      }
2062      const walker = new DomTreeWalker(node, targetNode);
2063      do {
2064        if (options.skipBogus && isElement$6(node)) {
2065          const bogusValue = node.getAttribute('data-mce-bogus');
2066          if (bogusValue) {
2067            node = walker.next(bogusValue === 'all');
2068            continue;
2069          }
2070        }
2071        if (isComment(node)) {
2072          node = walker.next(true);
2073          continue;
2074        }
2075        if (isBr$6(node)) {
2076          brCount++;
2077          node = walker.next();
2078          continue;
2079        }
2080        if (isContentNode(schema, node, targetNode, options)) {
2081          return false;
2082        }
2083        node = walker.next();
2084      } while (node);
2085      return brCount <= 1;
2086    };
2087    const isEmpty$2 = (schema, elm, options) => {
2088      return isEmptyNode(schema, elm.dom, {
2089        checkRootAsContent: true,
2090        ...options
2091      });
2092    };
2093    const isContent$1 = (schema, node, options) => {
2094      return isContentNode(schema, node, node, {
2095        includeZwsp: defaultOptionValues.includeZwsp,
2096        ...options
2097      });
2098    };
2099
2100    const Cell = initial => {
2101      let value = initial;
2102      const get = () => {
2103        return value;
2104      };
2105      const set = v => {
2106        value = v;
2107      };
2108      return {
2109        get,
2110        set
2111      };
2112    };
2113
2114    const singleton = doRevoke => {
2115      const subject = Cell(Optional.none());
2116      const revoke = () => subject.get().each(doRevoke);
2117      const clear = () => {
2118        revoke();
2119        subject.set(Optional.none());
2120      };
2121      const isSet = () => subject.get().isSome();
2122      const get = () => subject.get();
2123      const set = s => {
2124        revoke();
2125        subject.set(Optional.some(s));
2126      };
2127      return {
2128        clear,
2129        isSet,
2130        get,
2131        set
2132      };
2133    };
2134    const repeatable = delay => {
2135      const intervalId = Cell(Optional.none());
2136      const revoke = () => intervalId.get().each(id => clearInterval(id));
2137      const clear = () => {
2138        revoke();
2139        intervalId.set(Optional.none());
2140      };
2141      const isSet = () => intervalId.get().isSome();
2142      const get = () => intervalId.get();
2143      const set = functionToRepeat => {
2144        revoke();
2145        intervalId.set(Optional.some(setInterval(functionToRepeat, delay)));
2146      };
2147      return {
2148        clear,
2149        isSet,
2150        get,
2151        set
2152      };
2153    };
2154    const value$2 = () => {
2155      const subject = singleton(noop);
2156      const on = f => subject.get().each(f);
2157      return {
2158        ...subject,
2159        on
2160      };
2161    };
2162
2163    const nodeNameToNamespaceType = name => {
2164      const lowerCaseName = name.toLowerCase();
2165      if (lowerCaseName === 'svg') {
2166        return 'svg';
2167      } else if (lowerCaseName === 'math') {
2168        return 'math';
2169      } else {
2170        return 'html';
2171      }
2172    };
2173    const isNonHtmlElementRootName = name => nodeNameToNamespaceType(name) !== 'html';
2174    const isNonHtmlElementRoot = node => isNonHtmlElementRootName(node.nodeName);
2175    const toScopeType = node => nodeNameToNamespaceType(node.nodeName);
2176    const namespaceElements = [
2177      'svg',
2178      'math'
2179    ];
2180    const createNamespaceTracker = () => {
2181      const currentScope = value$2();
2182      const current = () => currentScope.get().map(toScopeType).getOr('html');
2183      const track = node => {
2184        if (isNonHtmlElementRoot(node)) {
2185          currentScope.set(node);
2186        } else if (currentScope.get().exists(scopeNode => !scopeNode.contains(node))) {
2187          currentScope.clear();
2188        }
2189        return current();
2190      };
2191      const reset = () => {
2192        currentScope.clear();
2193      };
2194      return {
2195        track,
2196        current,
2197        reset
2198      };
2199    };
2200
2201    const transparentBlockAttr = 'data-mce-block';
2202    const elementNames = map => filter$5(keys(map), key => !/[A-Z]/.test(key));
2203    const makeSelectorFromSchemaMap = map => map$3(elementNames(map), name => {
2204      const escapedName = CSS.escape(name);
2205      return `${ escapedName }:` + map$3(namespaceElements, ns => `not(${ ns } ${ escapedName })`).join(':');
2206    }).join(',');
2207    const updateTransparent = (blocksSelector, transparent) => {
2208      if (isNonNullable(transparent.querySelector(blocksSelector))) {
2209        transparent.setAttribute(transparentBlockAttr, 'true');
2210        if (transparent.getAttribute('data-mce-selected') === 'inline-boundary') {
2211          transparent.removeAttribute('data-mce-selected');
2212        }
2213        return true;
2214      } else {
2215        transparent.removeAttribute(transparentBlockAttr);
2216        return false;
2217      }
2218    };
2219    const updateBlockStateOnChildren = (schema, scope) => {
2220      const transparentSelector = makeSelectorFromSchemaMap(schema.getTransparentElements());
2221      const blocksSelector = makeSelectorFromSchemaMap(schema.getBlockElements());
2222      return filter$5(scope.querySelectorAll(transparentSelector), transparent => updateTransparent(blocksSelector, transparent));
2223    };
2224    const trimEdge = (schema, el, leftSide) => {
2225      var _a;
2226      const childPropertyName = leftSide ? 'lastChild' : 'firstChild';
2227      for (let child = el[childPropertyName]; child; child = child[childPropertyName]) {
2228        if (isEmptyNode(schema, child, { checkRootAsContent: true })) {
2229          (_a = child.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(child);
2230          return;
2231        }
2232      }
2233    };
2234    const split$2 = (schema, parentElm, splitElm) => {
2235      const range = document.createRange();
2236      const parentNode = parentElm.parentNode;
2237      if (parentNode) {
2238        range.setStartBefore(parentElm);
2239        range.setEndBefore(splitElm);
2240        const beforeFragment = range.extractContents();
2241        trimEdge(schema, beforeFragment, true);
2242        range.setStartAfter(splitElm);
2243        range.setEndAfter(parentElm);
2244        const afterFragment = range.extractContents();
2245        trimEdge(schema, afterFragment, false);
2246        if (!isEmptyNode(schema, beforeFragment, { checkRootAsContent: true })) {
2247          parentNode.insertBefore(beforeFragment, parentElm);
2248        }
2249        if (!isEmptyNode(schema, splitElm, { checkRootAsContent: true })) {
2250          parentNode.insertBefore(splitElm, parentElm);
2251        }
2252        if (!isEmptyNode(schema, afterFragment, { checkRootAsContent: true })) {
2253          parentNode.insertBefore(afterFragment, parentElm);
2254        }
2255        parentNode.removeChild(parentElm);
2256      }
2257    };
2258    const splitInvalidChildren = (schema, scope, transparentBlocks) => {
2259      const blocksElements = schema.getBlockElements();
2260      const rootNode = SugarElement.fromDom(scope);
2261      const isBlock = el => name(el) in blocksElements;
2262      const isRoot = el => eq(el, rootNode);
2263      each$e(fromDom$1(transparentBlocks), transparentBlock => {
2264        ancestor$4(transparentBlock, isBlock, isRoot).each(parentBlock => {
2265          const invalidChildren = children(transparentBlock, el => isBlock(el) && !schema.isValidChild(name(parentBlock), name(el)));
2266          if (invalidChildren.length > 0) {
2267            const stateScope = parentElement(parentBlock);
2268            each$e(invalidChildren, child => {
2269              ancestor$4(child, isBlock, isRoot).each(parentBlock => {
2270                split$2(schema, parentBlock.dom, child.dom);
2271              });
2272            });
2273            stateScope.each(scope => updateBlockStateOnChildren(schema, scope.dom));
2274          }
2275        });
2276      });
2277    };
2278    const unwrapInvalidChildren = (schema, scope, transparentBlocks) => {
2279      each$e([
2280        ...transparentBlocks,
2281        ...isTransparentBlock(schema, scope) ? [scope] : []
2282      ], block => each$e(descendants(SugarElement.fromDom(block), block.nodeName.toLowerCase()), elm => {
2283        if (isTransparentInline(schema, elm.dom)) {
2284          unwrap(elm);
2285        }
2286      }));
2287    };
2288    const updateChildren = (schema, scope) => {
2289      const transparentBlocks = updateBlockStateOnChildren(schema, scope);
2290      splitInvalidChildren(schema, scope, transparentBlocks);
2291      unwrapInvalidChildren(schema, scope, transparentBlocks);
2292    };
2293    const updateElement = (schema, target) => {
2294      if (isTransparentElement(schema, target)) {
2295        const blocksSelector = makeSelectorFromSchemaMap(schema.getBlockElements());
2296        updateTransparent(blocksSelector, target);
2297      }
2298    };
2299    const updateCaret = (schema, root, caretParent) => {
2300      const isRoot = el => eq(el, SugarElement.fromDom(root));
2301      const parents = parents$1(SugarElement.fromDom(caretParent), isRoot);
2302      get$b(parents, parents.length - 2).filter(isElement$7).fold(() => updateChildren(schema, root), scope => updateChildren(schema, scope.dom));
2303    };
2304    const hasBlockAttr = el => el.hasAttribute(transparentBlockAttr);
2305    const isTransparentElementName = (schema, name) => has$2(schema.getTransparentElements(), name);
2306    const isTransparentElement = (schema, node) => isElement$6(node) && isTransparentElementName(schema, node.nodeName);
2307    const isTransparentBlock = (schema, node) => isTransparentElement(schema, node) && hasBlockAttr(node);
2308    const isTransparentInline = (schema, node) => isTransparentElement(schema, node) && !hasBlockAttr(node);
2309    const isTransparentAstBlock = (schema, node) => node.type === 1 && isTransparentElementName(schema, node.name) && isString(node.attr(transparentBlockAttr));
2310
2311    const browser$2 = detect$1().browser;
2312    const firstElement = nodes => find$2(nodes, isElement$7);
2313    const getTableCaptionDeltaY = elm => {
2314      if (browser$2.isFirefox() && name(elm) === 'table') {
2315        return firstElement(children$1(elm)).filter(elm => {
2316          return name(elm) === 'caption';
2317        }).bind(caption => {
2318          return firstElement(nextSiblings(caption)).map(body => {
2319            const bodyTop = body.dom.offsetTop;
2320            const captionTop = caption.dom.offsetTop;
2321            const captionHeight = caption.dom.offsetHeight;
2322            return bodyTop <= captionTop ? -captionHeight : 0;
2323          });
2324        }).getOr(0);
2325      } else {
2326        return 0;
2327      }
2328    };
2329    const hasChild = (elm, child) => elm.children && contains$2(elm.children, child);
2330    const getPos = (body, elm, rootElm) => {
2331      let x = 0, y = 0;
2332      const doc = body.ownerDocument;
2333      rootElm = rootElm ? rootElm : body;
2334      if (elm) {
2335        if (rootElm === body && elm.getBoundingClientRect && get$7(SugarElement.fromDom(body), 'position') === 'static') {
2336          const pos = elm.getBoundingClientRect();
2337          x = pos.left + (doc.documentElement.scrollLeft || body.scrollLeft) - doc.documentElement.clientLeft;
2338          y = pos.top + (doc.documentElement.scrollTop || body.scrollTop) - doc.documentElement.clientTop;
2339          return {
2340            x,
2341            y
2342          };
2343        }
2344        let offsetParent = elm;
2345        while (offsetParent && offsetParent !== rootElm && offsetParent.nodeType && !hasChild(offsetParent, rootElm)) {
2346          const castOffsetParent = offsetParent;
2347          x += castOffsetParent.offsetLeft || 0;
2348          y += castOffsetParent.offsetTop || 0;
2349          offsetParent = castOffsetParent.offsetParent;
2350        }
2351        offsetParent = elm.parentNode;
2352        while (offsetParent && offsetParent !== rootElm && offsetParent.nodeType && !hasChild(offsetParent, rootElm)) {
2353          x -= offsetParent.scrollLeft || 0;
2354          y -= offsetParent.scrollTop || 0;
2355          offsetParent = offsetParent.parentNode;
2356        }
2357        y += getTableCaptionDeltaY(SugarElement.fromDom(elm));
2358      }
2359      return {
2360        x,
2361        y
2362      };
2363    };
2364
2365    const StyleSheetLoader = (documentOrShadowRoot, settings = {}) => {
2366      let idCount = 0;
2367      const loadedStates = {};
2368      const edos = SugarElement.fromDom(documentOrShadowRoot);
2369      const doc = documentOrOwner(edos);
2370      const _setReferrerPolicy = referrerPolicy => {
2371        settings.referrerPolicy = referrerPolicy;
2372      };
2373      const _setContentCssCors = contentCssCors => {
2374        settings.contentCssCors = contentCssCors;
2375      };
2376      const addStyle = element => {
2377        append$1(getStyleContainer(edos), element);
2378      };
2379      const removeStyle = id => {
2380        const styleContainer = getStyleContainer(edos);
2381        descendant$1(styleContainer, '#' + id).each(remove$4);
2382      };
2383      const getOrCreateState = url => get$a(loadedStates, url).getOrThunk(() => ({
2384        id: 'mce-u' + idCount++,
2385        passed: [],
2386        failed: [],
2387        count: 0
2388      }));
2389      const load = url => new Promise((success, failure) => {
2390        let link;
2391        const urlWithSuffix = Tools._addCacheSuffix(url);
2392        const state = getOrCreateState(urlWithSuffix);
2393        loadedStates[urlWithSuffix] = state;
2394        state.count++;
2395        const resolve = (callbacks, status) => {
2396          each$e(callbacks, call);
2397          state.status = status;
2398          state.passed = [];
2399          state.failed = [];
2400          if (link) {
2401            link.onload = null;
2402            link.onerror = null;
2403            link = null;
2404          }
2405        };
2406        const passed = () => resolve(state.passed, 2);
2407        const failed = () => resolve(state.failed, 3);
2408        if (success) {
2409          state.passed.push(success);
2410        }
2411        if (failure) {
2412          state.failed.push(failure);
2413        }
2414        if (state.status === 1) {
2415          return;
2416        }
2417        if (state.status === 2) {
2418          passed();
2419          return;
2420        }
2421        if (state.status === 3) {
2422          failed();
2423          return;
2424        }
2425        state.status = 1;
2426        const linkElem = SugarElement.fromTag('link', doc.dom);
2427        setAll$1(linkElem, {
2428          rel: 'stylesheet',
2429          type: 'text/css',
2430          id: state.id
2431        });
2432        if (settings.contentCssCors) {
2433          set$4(linkElem, 'crossOrigin', 'anonymous');
2434        }
2435        if (settings.referrerPolicy) {
2436          set$4(linkElem, 'referrerpolicy', settings.referrerPolicy);
2437        }
2438        link = linkElem.dom;
2439        link.onload = passed;
2440        link.onerror = failed;
2441        addStyle(linkElem);
2442        set$4(linkElem, 'href', urlWithSuffix);
2443      });
2444      const loadRawCss = (key, css) => {
2445        const state = getOrCreateState(key);
2446        loadedStates[key] = state;
2447        state.count++;
2448        const styleElem = SugarElement.fromTag('style', doc.dom);
2449        setAll$1(styleElem, {
2450          'rel': 'stylesheet',
2451          'type': 'text/css',
2452          'id': state.id,
2453          'data-mce-key': key

2453
2454        });
2455        styleElem.dom.innerHTML = css;
2456        addStyle(styleElem);
2457      };
2458      const loadAll = urls => {
2459        const loadedUrls = Promise.allSettled(map$3(urls, url => load(url).then(constant(url))));
2460        return loadedUrls.then(results => {
2461          const parts = partition$2(results, r => r.status === 'fulfilled');
2462          if (parts.fail.length > 0) {
2463            return Promise.reject(map$3(parts.fail, result => result.reason));
2464          } else {
2465            return map$3(parts.pass, result => result.value);
2466          }
2467        });
2468      };
2469      const unload = url => {
2470        const urlWithSuffix = Tools._addCacheSuffix(url);
2471        get$a(loadedStates, urlWithSuffix).each(state => {
2472          const count = --state.count;
2473          if (count === 0) {
2474            delete loadedStates[urlWithSuffix];
2475            removeStyle(state.id);
2476          }
2477        });
2478      };
2479      const unloadRawCss = key => {
2480        get$a(loadedStates, key).each(state => {
2481          const count = --state.count;
2482          if (count === 0) {
2483            delete loadedStates[key];
2484            removeStyle(state.id);
2485          }
2486        });
2487      };
2488      const unloadAll = urls => {
2489        each$e(urls, url => {
2490          unload(url);
2491        });
2492      };
2493      return {
2494        load,
2495        loadRawCss,
2496        loadAll,
2497        unload,
2498        unloadRawCss,
2499        unloadAll,
2500        _setReferrerPolicy,
2501        _setContentCssCors
2502      };
2503    };
2504
2505    const create$c = () => {
2506      const map = new WeakMap();
2507      const forElement = (referenceElement, settings) => {
2508        const root = getRootNode(referenceElement);
2509        const rootDom = root.dom;
2510        return Optional.from(map.get(rootDom)).getOrThunk(() => {
2511          const sl = StyleSheetLoader(rootDom, settings);
2512          map.set(rootDom, sl);
2513          return sl;
2514        });
2515      };
2516      return { forElement };
2517    };
2518    const instance = create$c();
2519
2520    const isSpan = node => node.nodeName.toLowerCase() === 'span';
2521    const isInlineContent = (node, schema) => isNonNullable(node) && (isContent$1(schema, node) || schema.isInline(node.nodeName.toLowerCase()));
2522    const surroundedByInlineContent = (node, root, schema) => {
2523      const prev = new DomTreeWalker(node, root).prev(false);
2524      const next = new DomTreeWalker(node, root).next(false);
2525      const prevIsInline = isUndefined(prev) || isInlineContent(prev, schema);
2526      const nextIsInline = isUndefined(next) || isInlineContent(next, schema);
2527      return prevIsInline && nextIsInline;
2528    };
2529    const isBookmarkNode$2 = node => isSpan(node) && node.getAttribute('data-mce-type') === 'bookmark';
2530    const isKeepTextNode = (node, root, schema) => isText$b(node) && node.data.length > 0 && surroundedByInlineContent(node, root, schema);
2531    const isKeepElement = node => isElement$6(node) ? node.childNodes.length > 0 : false;
2532    const isDocument = node => isDocumentFragment(node) || isDocument$1(node);
2533    const trimNode = (dom, node, schema, root) => {
2534      var _a;
2535      const rootNode = root || node;
2536      if (isElement$6(node) && isBookmarkNode$2(node)) {
2537        return node;
2538      }
2539      const children = node.childNodes;
2540      for (let i = children.length - 1; i >= 0; i--) {
2541        trimNode(dom, children[i], schema, rootNode);
2542      }
2543      if (isElement$6(node)) {
2544        const currentChildren = node.childNodes;
2545        if (currentChildren.length === 1 && isBookmarkNode$2(currentChildren[0])) {
2546          (_a = node.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(currentChildren[0], node);
2547        }
2548      }
2549      if (!isDocument(node) && !isContent$1(schema, node) && !isKeepElement(node) && !isKeepTextNode(node, rootNode, schema)) {
2550        dom.remove(node);
2551      }
2552      return node;
2553    };
2554
2555    const makeMap$3 = Tools.makeMap;
2556    const attrsCharsRegExp = /[&<>\"\u0060\u007E-\uD7FF\uE000-\uFFEF]|[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
2557    const textCharsRegExp = /[<>&\u007E-\uD7FF\uE000-\uFFEF]|[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
2558    const rawCharsRegExp = /[<>&\"\']/g;
2559    const entityRegExp = /&#([a-z0-9]+);?|&([a-z0-9]+);/gi;
2560    const asciiMap = {
2561      128: '\u20AC',
2562      130: '\u201A',
2563      131: '\u0192',
2564      132: '\u201E',
2565      133: '\u2026',
2566      134: '\u2020',
2567      135: '\u2021',
2568      136: '\u02c6',
2569      137: '\u2030',
2570      138: '\u0160',
2571      139: '\u2039',
2572      140: '\u0152',
2573      142: '\u017d',
2574      145: '\u2018',
2575      146: '\u2019',
2576      147: '\u201C',
2577      148: '\u201D',
2578      149: '\u2022',
2579      150: '\u2013',
2580      151: '\u2014',
2581      152: '\u02DC',
2582      153: '\u2122',
2583      154: '\u0161',
2584      155: '\u203A',
2585      156: '\u0153',
2586      158: '\u017e',
2587      159: '\u0178'
2588    };
2589    const baseEntities = {
2590      '"': '&quot;',
2591      '\'': '&#39;',
2592      '<': '&lt;',
2593      '>': '&gt;',
2594      '&': '&amp;',
2595      '`': '&#96;'
2596    };
2597    const reverseEntities = {
2598      '&lt;': '<',
2599      '&gt;': '>',
2600      '&amp;': '&',
2601      '&quot;': '"',
2602      '&apos;': `'`
2603    };
2604    const nativeDecode = text => {
2605      const elm = SugarElement.fromTag('div').dom;
2606      elm.innerHTML = text;
2607      return elm.textContent || elm.innerText || text;
2608    };
2609    const buildEntitiesLookup = (items, radix) => {
2610      const lookup = {};
2611      if (items) {
2612        const itemList = items.split(',');
2613        radix = radix || 10;
2614        for (let i = 0; i < itemList.length; i += 2) {
2615          const chr = String.fromCharCode(parseInt(itemList[i], radix));
2616          if (!baseEntities[chr]) {
2617            const entity = '&' + itemList[i + 1] + ';';
2618            lookup[chr] = entity;
2619            lookup[entity] = chr;
2620          }
2621        }
2622        return lookup;
2623      } else {
2624        return undefined;
2625      }
2626    };
2627    const namedEntities = buildEntitiesLookup('50,nbsp,51,iexcl,52,cent,53,pound,54,curren,55,yen,56,brvbar,57,sect,58,uml,59,copy,' + '5a,ordf,5b,laquo,5c,not,5d,shy,5e,reg,5f,macr,5g,deg,5h,plusmn,5i,sup2,5j,sup3,5k,acute,' + '5l,micro,5m,para,5n,middot,5o,cedil,5p,sup1,5q,ordm,5r,raquo,5s,frac14,5t,frac12,5u,frac34,' + '5v,iquest,60,Agrave,61,Aacute,62,Acirc,63,Atilde,64,Auml,65,Aring,66,AElig,67,Ccedil,' + '68,Egrave,69,Eacute,6a,Ecirc,6b,Euml,6c,Igrave,6d,Iacute,6e,Icirc,6f,Iuml,6g,ETH,6h,Ntilde,' + '6i,Ograve,6j,Oacute,6k,Ocirc,6l,Otilde,6m,Ouml,6n,times,6o,Oslash,6p,Ugrave,6q,Uacute,' + '6r,Ucirc,6s,Uuml,6t,Yacute,6u,THORN,6v,szlig,70,agrave,71,aacute,72,acirc,73,atilde,74,auml,' + '75,aring,76,aelig,77,ccedil,78,egrave,79,eacute,7a,ecirc,7b,euml,7c,igrave,7d,iacute,7e,icirc,' + '7f,iuml,7g,eth,7h,ntilde,7i,ograve,7j,oacute,7k,ocirc,7l,otilde,7m,ouml,7n,divide,7o,oslash,' + '7p,ugrave,7q,uacute,7r,ucirc,7s,uuml,7t,yacute,7u,thorn,7v,yuml,ci,fnof,sh,Alpha,si,Beta,' + 'sj,Gamma,sk,Delta,sl,Epsilon,sm,Zeta,sn,Eta,so,Theta,sp,Iota,sq,Kappa,sr,Lambda,ss,Mu,' + 'st,Nu,su,Xi,sv,Omicron,t0,Pi,t1,Rho,t3,Sigma,t4,Tau,t5,Upsilon,t6,Phi,t7,Chi,t8,Psi,' + 't9,Omega,th,alpha,ti,beta,tj,gamma,tk,delta,tl,epsilon,tm,zeta,tn,eta,to,theta,tp,iota,' + 'tq,kappa,tr,lambda,ts,mu,tt,nu,tu,xi,tv,omicron,u0,pi,u1,rho,u2,sigmaf,u3,sigma,u4,tau,' + 'u5,upsilon,u6,phi,u7,chi,u8,psi,u9,omega,uh,thetasym,ui,upsih,um,piv,812,bull,816,hellip,' + '81i,prime,81j,Prime,81u,oline,824,frasl,88o,weierp,88h,image,88s,real,892,trade,89l,alefsym,' + '8cg,larr,8ch,uarr,8ci,rarr,8cj,darr,8ck,harr,8dl,crarr,8eg,lArr,8eh,uArr,8ei,rArr,8ej,dArr,' + '8ek,hArr,8g0,forall,8g2,part,8g3,exist,8g5,empty,8g7,nabla,8g8,isin,8g9,notin,8gb,ni,8gf,prod,' + '8gh,sum,8gi,minus,8gn,lowast,8gq,radic,8gt,prop,8gu,infin,8h0,ang,8h7,and,8h8,or,8h9,cap,8ha,cup,' + '8hb,int,8hk,there4,8hs,sim,8i5,cong,8i8,asymp,8j0,ne,8j1,equiv,8j4,le,8j5,ge,8k2,sub,8k3,sup,8k4,' + 'nsub,8k6,sube,8k7,supe,8kl,oplus,8kn,otimes,8l5,perp,8m5,sdot,8o8,lceil,8o9,rceil,8oa,lfloor,8ob,' + 'rfloor,8p9,lang,8pa,rang,9ea,loz,9j0,spades,9j3,clubs,9j5,hearts,9j6,diams,ai,OElig,aj,oelig,b0,' + 'Scaron,b1,scaron,bo,Yuml,m6,circ,ms,tilde,802,ensp,803,emsp,809,thinsp,80c,zwnj,80d,zwj,80e,lrm,' + '80f,rlm,80j,ndash,80k,mdash,80o,lsquo,80p,rsquo,80q,sbquo,80s,ldquo,80t,rdquo,80u,bdquo,810,dagger,' + '811,Dagger,81g,permil,81p,lsaquo,81q,rsaquo,85c,euro', 32);
2628    const encodeRaw = (text, attr) => text.replace(attr ? attrsCharsRegExp : textCharsRegExp, chr => {
2629      return baseEntities[chr] || chr;
2630    });
2631    const encodeAllRaw = text => ('' + text).replace(rawCharsRegExp, chr => {
2632      return baseEntities[chr] || chr;
2633    });
2634    const encodeNumeric = (text, attr) => text.replace(attr ? attrsCharsRegExp : textCharsRegExp, chr => {
2635      if (chr.length > 1) {
2636        return '&#' + ((chr.charCodeAt(0) - 55296) * 1024 + (chr.charCodeAt(1) - 56320) + 65536) + ';';
2637      }
2638      return baseEntities[chr] || '&#' + chr.charCodeAt(0) + ';';
2639    });
2640    const encodeNamed = (text, attr, entities) => {
2641      const resolveEntities = entities || namedEntities;
2642      return text.replace(attr ? attrsCharsRegExp : textCharsRegExp, chr => {
2643        return baseEntities[chr] || resolveEntities[chr] || chr;
2644      });
2645    };
2646    const getEncodeFunc = (name, entities) => {
2647      const entitiesMap = buildEntitiesLookup(entities) || namedEntities;
2648      const encodeNamedAndNumeric = (text, attr) => text.replace(attr ? attrsCharsRegExp : textCharsRegExp, chr => {
2649        if (baseEntities[chr] !== undefined) {
2650          return baseEntities[chr];
2651        }
2652        if (entitiesMap[chr] !== undefined) {
2653          return entitiesMap[chr];
2654        }
2655        if (chr.length > 1) {
2656          return '&#' + ((chr.charCodeAt(0) - 55296) * 1024 + (chr.charCodeAt(1) - 56320) + 65536) + ';';
2657        }
2658        return '&#' + chr.charCodeAt(0) + ';';
2659      });
2660      const encodeCustomNamed = (text, attr) => {
2661        return encodeNamed(text, attr, entitiesMap);
2662      };
2663      const nameMap = makeMap$3(name.replace(/\+/g, ','));
2664      if (nameMap.named && nameMap.numeric) {
2665        return encodeNamedAndNumeric;
2666      }
2667      if (nameMap.named) {
2668        if (entities) {
2669          return encodeCustomNamed;
2670        }
2671        return encodeNamed;
2672      }
2673      if (nameMap.numeric) {
2674        return encodeNumeric;
2675      }
2676      return encodeRaw;
2677    };
2678    const decode = text => text.replace(entityRegExp, (all, numeric) => {
2679      if (numeric) {
2680        if (numeric.charAt(0).toLowerCase() === 'x') {
2681          numeric = parseInt(numeric.substr(1), 16);
2682        } else {
2683          numeric = parseInt(numeric, 10);
2684        }
2685        if (numeric > 65535) {
2686          numeric -= 65536;
2687          return String.fromCharCode(55296 + (numeric >> 10), 56320 + (numeric & 1023));
2688        }
2689        return asciiMap[numeric] || String.fromCharCode(numeric);
2690      }
2691      return reverseEntities[all] || namedEntities[all] || nativeDecode(all);
2692    });
2693    const Entities = {
2694      encodeRaw,
2695      encodeAllRaw,
2696      encodeNumeric,
2697      encodeNamed,
2698      getEncodeFunc,
2699      decode
2700    };
2701
2702    const split$1 = (items, delim) => {
2703      items = Tools.trim(items);
2704      return items ? items.split(delim || ' ') : [];
2705    };
2706    const patternToRegExp = str => new RegExp('^' + str.replace(/([?+*])/g, '.$1') + '$');
2707    const isRegExp$1 = obj => isObject(obj) && obj.source && Object.prototype.toString.call(obj) === '[object RegExp]';
2708    const deepCloneElementRule = obj => {
2709      const helper = value => {
2710        if (isArray$1(value)) {
2711          return map$3(value, helper);
2712        } else if (isRegExp$1(value)) {
2713          return new RegExp(value.source, value.flags);
2714        } else if (isObject(value)) {
2715          return map$2(value, helper);
2716        } else {
2717          return value;
2718        }
2719      };
2720      return helper(obj);
2721    };
2722
2723    const parseCustomElementsRules = value => {
2724      const customElementRegExp = /^(~)?(.+)$/;
2725      return bind$3(split$1(value, ','), rule => {
2726        const matches = customElementRegExp.exec(rule);
2727        if (matches) {
2728          const inline = matches[1] === '~';
2729          const cloneName = inline ? 'span' : 'div';
2730          const name = matches[2];
2731          return [{
2732              cloneName,
2733              name
2734            }];
2735        } else {
2736          return [];
2737        }
2738      });
2739    };
2740
2741    const getGlobalAttributeSet = type => {
2742      return Object.freeze([
2743        'id',
2744        'accesskey',
2745        'class',
2746        'dir',
2747        'lang',
2748        'style',
2749        'tabindex',
2750        'title',
2751        'role',
2752        ...type !== 'html4' ? [
2753          'contenteditable',
2754          'contextmenu',
2755          'draggable',
2756          'dropzone',
2757          'hidden',
2758          'spellcheck',
2759          'translate'