[Summary view] [Print] [Text view]

   1  /**
   2   * Copyright (c) Tiny Technologies, Inc. All rights reserved.
   3   * Licensed under the LGPL or a commercial license.
   4   * For LGPL see License.txt in the project root for license information.
   5   * For commercial licenses see https://www.tiny.cloud/
   6   *
   7   * Version: 5.10.5 (2022-05-25)
   8   */
   9  (function () {
  10      'use strict';
  11  
  12      var typeOf = function (x) {
  13        var t = typeof x;
  14        if (x === null) {
  15          return 'null';
  16        } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
  17          return 'array';
  18        } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
  19          return 'string';
  20        } else {
  21          return t;
  22        }
  23      };
  24      var isType$1 = function (type) {
  25        return function (value) {
  26          return typeOf(value) === type;
  27        };
  28      };
  29      var isSimpleType = function (type) {
  30        return function (value) {
  31          return typeof value === type;
  32        };
  33      };
  34      var eq$2 = function (t) {
  35        return function (a) {
  36          return t === a;
  37        };
  38      };
  39      var isString = isType$1('string');
  40      var isObject = isType$1('object');
  41      var isArray = isType$1('array');
  42      var isNull = eq$2(null);
  43      var isBoolean = isSimpleType('boolean');
  44      var isUndefined = eq$2(undefined);
  45      var isNullable = function (a) {
  46        return a === null || a === undefined;
  47      };
  48      var isNonNullable = function (a) {
  49        return !isNullable(a);
  50      };
  51      var isFunction = isSimpleType('function');
  52      var isNumber = isSimpleType('number');
  53  
  54      var noop = function () {
  55      };
  56      var compose = function (fa, fb) {
  57        return function () {
  58          var args = [];
  59          for (var _i = 0; _i < arguments.length; _i++) {
  60            args[_i] = arguments[_i];
  61          }
  62          return fa(fb.apply(null, args));
  63        };
  64      };
  65      var compose1 = function (fbc, fab) {
  66        return function (a) {
  67          return fbc(fab(a));
  68        };
  69      };
  70      var constant = function (value) {
  71        return function () {
  72          return value;
  73        };
  74      };
  75      var identity = function (x) {
  76        return x;
  77      };
  78      var tripleEquals = function (a, b) {
  79        return a === b;
  80      };
  81      function curry(fn) {
  82        var initialArgs = [];
  83        for (var _i = 1; _i < arguments.length; _i++) {
  84          initialArgs[_i - 1] = arguments[_i];
  85        }
  86        return function () {
  87          var restArgs = [];
  88          for (var _i = 0; _i < arguments.length; _i++) {
  89            restArgs[_i] = arguments[_i];
  90          }
  91          var all = initialArgs.concat(restArgs);
  92          return fn.apply(null, all);
  93        };
  94      }
  95      var not = function (f) {
  96        return function (t) {
  97          return !f(t);
  98        };
  99      };
 100      var die = function (msg) {
 101        return function () {
 102          throw new Error(msg);
 103        };
 104      };
 105      var never = constant(false);
 106      var always = constant(true);
 107  
 108      var none$2 = function () {
 109        return NONE;
 110      };
 111      var NONE = function () {
 112        var call = function (thunk) {
 113          return thunk();
 114        };
 115        var id = identity;
 116        var me = {
 117          fold: function (n, _s) {
 118            return n();
 119          },
 120          isSome: never,
 121          isNone: always,
 122          getOr: id,
 123          getOrThunk: call,
 124          getOrDie: function (msg) {
 125            throw new Error(msg || 'error: getOrDie called on none.');
 126          },
 127          getOrNull: constant(null),
 128          getOrUndefined: constant(undefined),
 129          or: id,
 130          orThunk: call,
 131          map: none$2,
 132          each: noop,
 133          bind: none$2,
 134          exists: never,
 135          forall: always,
 136          filter: function () {
 137            return none$2();
 138          },
 139          toArray: function () {
 140            return [];
 141          },
 142          toString: constant('none()')
 143        };
 144        return me;
 145      }();
 146      var some = function (a) {
 147        var constant_a = constant(a);
 148        var self = function () {
 149          return me;
 150        };
 151        var bind = function (f) {
 152          return f(a);
 153        };
 154        var me = {
 155          fold: function (n, s) {
 156            return s(a);
 157          },
 158          isSome: always,
 159          isNone: never,
 160          getOr: constant_a,
 161          getOrThunk: constant_a,
 162          getOrDie: constant_a,
 163          getOrNull: constant_a,
 164          getOrUndefined: constant_a,
 165          or: self,
 166          orThunk: self,
 167          map: function (f) {
 168            return some(f(a));
 169          },
 170          each: function (f) {
 171            f(a);
 172          },
 173          bind: bind,
 174          exists: bind,
 175          forall: bind,
 176          filter: function (f) {
 177            return f(a) ? me : NONE;
 178          },
 179          toArray: function () {
 180            return [a];
 181          },
 182          toString: function () {
 183            return 'some(' + a + ')';
 184          }
 185        };
 186        return me;
 187      };
 188      var from$1 = function (value) {
 189        return value === null || value === undefined ? NONE : some(value);
 190      };
 191      var Optional = {
 192        some: some,
 193        none: none$2,
 194        from: from$1
 195      };
 196  
 197      var nativeSlice = Array.prototype.slice;
 198      var nativeIndexOf = Array.prototype.indexOf;
 199      var nativePush = Array.prototype.push;
 200      var rawIndexOf = function (ts, t) {
 201        return nativeIndexOf.call(ts, t);
 202      };
 203      var contains$2 = function (xs, x) {
 204        return rawIndexOf(xs, x) > -1;
 205      };
 206      var exists = function (xs, pred) {
 207        for (var i = 0, len = xs.length; i < len; i++) {
 208          var x = xs[i];
 209          if (pred(x, i)) {
 210            return true;
 211          }
 212        }
 213        return false;
 214      };
 215      var range$1 = function (num, f) {
 216        var r = [];
 217        for (var i = 0; i < num; i++) {
 218          r.push(f(i));
 219        }
 220        return r;
 221      };
 222      var map$1 = function (xs, f) {
 223        var len = xs.length;
 224        var r = new Array(len);
 225        for (var i = 0; i < len; i++) {
 226          var x = xs[i];
 227          r[i] = f(x, i);
 228        }
 229        return r;
 230      };
 231      var each$2 = function (xs, f) {
 232        for (var i = 0, len = xs.length; i < len; i++) {
 233          var x = xs[i];
 234          f(x, i);
 235        }
 236      };
 237      var eachr = function (xs, f) {
 238        for (var i = xs.length - 1; i >= 0; i--) {
 239          var x = xs[i];
 240          f(x, i);
 241        }
 242      };
 243      var partition = function (xs, pred) {
 244        var pass = [];
 245        var fail = [];
 246        for (var i = 0, len = xs.length; i < len; i++) {
 247          var x = xs[i];
 248          var arr = pred(x, i) ? pass : fail;
 249          arr.push(x);
 250        }
 251        return {
 252          pass: pass,
 253          fail: fail
 254        };
 255      };
 256      var filter$2 = function (xs, pred) {
 257        var r = [];
 258        for (var i = 0, len = xs.length; i < len; i++) {
 259          var x = xs[i];
 260          if (pred(x, i)) {
 261            r.push(x);
 262          }
 263        }
 264        return r;
 265      };
 266      var foldr = function (xs, f, acc) {
 267        eachr(xs, function (x, i) {
 268          acc = f(acc, x, i);
 269        });
 270        return acc;
 271      };
 272      var foldl = function (xs, f, acc) {
 273        each$2(xs, function (x, i) {
 274          acc = f(acc, x, i);
 275        });
 276        return acc;
 277      };
 278      var findUntil = function (xs, pred, until) {
 279        for (var i = 0, len = xs.length; i < len; i++) {
 280          var x = xs[i];
 281          if (pred(x, i)) {
 282            return Optional.some(x);
 283          } else if (until(x, i)) {
 284            break;
 285          }
 286        }
 287        return Optional.none();
 288      };
 289      var find$1 = function (xs, pred) {
 290        return findUntil(xs, pred, never);
 291      };
 292      var findIndex = function (xs, pred) {
 293        for (var i = 0, len = xs.length; i < len; i++) {
 294          var x = xs[i];
 295          if (pred(x, i)) {
 296            return Optional.some(i);
 297          }
 298        }
 299        return Optional.none();
 300      };
 301      var flatten$1 = function (xs) {
 302        var r = [];
 303        for (var i = 0, len = xs.length; i < len; ++i) {
 304          if (!isArray(xs[i])) {
 305            throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
 306          }
 307          nativePush.apply(r, xs[i]);
 308        }
 309        return r;
 310      };
 311      var bind$2 = function (xs, f) {
 312        return flatten$1(map$1(xs, f));
 313      };
 314      var forall = function (xs, pred) {
 315        for (var i = 0, len = xs.length; i < len; ++i) {
 316          var x = xs[i];
 317          if (pred(x, i) !== true) {
 318            return false;
 319          }
 320        }
 321        return true;
 322      };
 323      var reverse = function (xs) {
 324        var r = nativeSlice.call(xs, 0);
 325        r.reverse();
 326        return r;
 327      };
 328      var mapToObject = function (xs, f) {
 329        var r = {};
 330        for (var i = 0, len = xs.length; i < len; i++) {
 331          var x = xs[i];
 332          r[String(x)] = f(x, i);
 333        }
 334        return r;
 335      };
 336      var pure = function (x) {
 337        return [x];
 338      };
 339      var sort$1 = function (xs, comparator) {
 340        var copy = nativeSlice.call(xs, 0);
 341        copy.sort(comparator);
 342        return copy;
 343      };
 344      var get$d = function (xs, i) {
 345        return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
 346      };
 347      var head = function (xs) {
 348        return get$d(xs, 0);
 349      };
 350      var last$2 = function (xs) {
 351        return get$d(xs, xs.length - 1);
 352      };
 353      var findMap = function (arr, f) {
 354        for (var i = 0; i < arr.length; i++) {
 355          var r = f(arr[i], i);
 356          if (r.isSome()) {
 357            return r;
 358          }
 359        }
 360        return Optional.none();
 361      };
 362  
 363      var __assign = function () {
 364        __assign = Object.assign || function __assign(t) {
 365          for (var s, i = 1, n = arguments.length; i < n; i++) {
 366            s = arguments[i];
 367            for (var p in s)
 368              if (Object.prototype.hasOwnProperty.call(s, p))
 369                t[p] = s[p];
 370          }
 371          return t;
 372        };
 373        return __assign.apply(this, arguments);
 374      };
 375      function __spreadArray(to, from, pack) {
 376        if (pack || arguments.length === 2)
 377          for (var i = 0, l = from.length, ar; i < l; i++) {
 378            if (ar || !(i in from)) {
 379              if (!ar)
 380                ar = Array.prototype.slice.call(from, 0, i);
 381              ar[i] = from[i];
 382            }
 383          }
 384        return to.concat(ar || Array.prototype.slice.call(from));
 385      }
 386  
 387      var cached = function (f) {
 388        var called = false;
 389        var r;
 390        return function () {
 391          var args = [];
 392          for (var _i = 0; _i < arguments.length; _i++) {
 393            args[_i] = arguments[_i];
 394          }
 395          if (!called) {
 396            called = true;
 397            r = f.apply(null, args);
 398          }
 399          return r;
 400        };
 401      };
 402  
 403      var DeviceType = function (os, browser, userAgent, mediaMatch) {
 404        var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true;
 405        var isiPhone = os.isiOS() && !isiPad;
 406        var isMobile = os.isiOS() || os.isAndroid();
 407        var isTouch = isMobile || mediaMatch('(pointer:coarse)');
 408        var isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)');
 409        var isPhone = isiPhone || isMobile && !isTablet;
 410        var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false;
 411        var isDesktop = !isPhone && !isTablet && !iOSwebview;
 412        return {
 413          isiPad: constant(isiPad),
 414          isiPhone: constant(isiPhone),
 415          isTablet: constant(isTablet),
 416          isPhone: constant(isPhone),
 417          isTouch: constant(isTouch),
 418          isAndroid: os.isAndroid,
 419          isiOS: os.isiOS,
 420          isWebView: constant(iOSwebview),
 421          isDesktop: constant(isDesktop)
 422        };
 423      };
 424  
 425      var firstMatch = function (regexes, s) {
 426        for (var i = 0; i < regexes.length; i++) {
 427          var x = regexes[i];
 428          if (x.test(s)) {
 429            return x;
 430          }
 431        }
 432        return undefined;
 433      };
 434      var find = function (regexes, agent) {
 435        var r = firstMatch(regexes, agent);
 436        if (!r) {
 437          return {
 438            major: 0,
 439            minor: 0
 440          };
 441        }
 442        var group = function (i) {
 443          return Number(agent.replace(r, '$' + i));
 444        };
 445        return nu$2(group(1), group(2));
 446      };
 447      var detect$6 = function (versionRegexes, agent) {
 448        var cleanedAgent = String(agent).toLowerCase();
 449        if (versionRegexes.length === 0) {
 450          return unknown$2();
 451        }
 452        return find(versionRegexes, cleanedAgent);
 453      };
 454      var unknown$2 = function () {
 455        return nu$2(0, 0);
 456      };
 457      var nu$2 = function (major, minor) {
 458        return {
 459          major: major,
 460          minor: minor
 461        };
 462      };
 463      var Version = {
 464        nu: nu$2,
 465        detect: detect$6,
 466        unknown: unknown$2
 467      };
 468  
 469      var detectBrowser$1 = function (browsers, userAgentData) {
 470        return findMap(userAgentData.brands, function (uaBrand) {
 471          var lcBrand = uaBrand.brand.toLowerCase();
 472          return find$1(browsers, function (browser) {
 473            var _a;
 474            return lcBrand === ((_a = browser.brand) === null || _a === void 0 ? void 0 : _a.toLowerCase());
 475          }).map(function (info) {
 476            return {
 477              current: info.name,
 478              version: Version.nu(parseInt(uaBrand.version, 10), 0)
 479            };
 480          });
 481        });
 482      };
 483  
 484      var detect$5 = function (candidates, userAgent) {
 485        var agent = String(userAgent).toLowerCase();
 486        return find$1(candidates, function (candidate) {
 487          return candidate.search(agent);
 488        });
 489      };
 490      var detectBrowser = function (browsers, userAgent) {
 491        return detect$5(browsers, userAgent).map(function (browser) {
 492          var version = Version.detect(browser.versionRegexes, userAgent);
 493          return {
 494            current: browser.name,
 495            version: version
 496          };
 497        });
 498      };
 499      var detectOs = function (oses, userAgent) {
 500        return detect$5(oses, userAgent).map(function (os) {
 501          var version = Version.detect(os.versionRegexes, userAgent);
 502          return {
 503            current: os.name,
 504            version: version
 505          };
 506        });
 507      };
 508  
 509      var removeFromStart = function (str, numChars) {
 510        return str.substring(numChars);
 511      };
 512  
 513      var checkRange = function (str, substr, start) {
 514        return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
 515      };
 516      var removeLeading = function (str, prefix) {
 517        return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str;
 518      };
 519      var contains$1 = function (str, substr) {
 520        return str.indexOf(substr) !== -1;
 521      };
 522      var startsWith = function (str, prefix) {
 523        return checkRange(str, prefix, 0);
 524      };
 525      var endsWith = function (str, suffix) {
 526        return checkRange(str, suffix, str.length - suffix.length);
 527      };
 528      var blank = function (r) {
 529        return function (s) {
 530          return s.replace(r, '');
 531        };
 532      };
 533      var trim = blank(/^\s+|\s+$/g);
 534      var isNotEmpty = function (s) {
 535        return s.length > 0;
 536      };
 537      var isEmpty$1 = function (s) {
 538        return !isNotEmpty(s);
 539      };
 540      var toFloat = function (value) {
 541        var num = parseFloat(value);
 542        return isNaN(num) ? Optional.none() : Optional.some(num);
 543      };
 544  
 545      var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/;
 546      var checkContains = function (target) {
 547        return function (uastring) {
 548          return contains$1(uastring, target);
 549        };
 550      };
 551      var browsers = [
 552        {
 553          name: 'Edge',
 554          versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/],
 555          search: function (uastring) {
 556            return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit');
 557          }
 558        },
 559        {
 560          name: 'Chrome',
 561          brand: 'Chromium',
 562          versionRegexes: [
 563            /.*?chrome\/([0-9]+)\.([0-9]+).*/,
 564            normalVersionRegex
 565          ],
 566          search: function (uastring) {
 567            return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe');
 568          }
 569        },
 570        {
 571          name: 'IE',
 572          versionRegexes: [
 573            /.*?msie\ ?([0-9]+)\.([0-9]+).*/,
 574            /.*?rv:([0-9]+)\.([0-9]+).*/
 575          ],
 576          search: function (uastring) {
 577            return contains$1(uastring, 'msie') || contains$1(uastring, 'trident');
 578          }
 579        },
 580        {
 581          name: 'Opera',
 582          versionRegexes: [
 583            normalVersionRegex,
 584            /.*?opera\/([0-9]+)\.([0-9]+).*/
 585          ],
 586          search: checkContains('opera')
 587        },
 588        {
 589          name: 'Firefox',
 590          versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/],
 591          search: checkContains('firefox')
 592        },
 593        {
 594          name: 'Safari',
 595          versionRegexes: [
 596            normalVersionRegex,
 597            /.*?cpu os ([0-9]+)_([0-9]+).*/
 598          ],
 599          search: function (uastring) {
 600            return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit');
 601          }
 602        }
 603      ];
 604      var oses = [
 605        {
 606          name: 'Windows',
 607          search: checkContains('win'),
 608          versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/]
 609        },
 610        {
 611          name: 'iOS',
 612          search: function (uastring) {
 613            return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad');
 614          },
 615          versionRegexes: [
 616            /.*?version\/\ ?([0-9]+)\.([0-9]+).*/,
 617            /.*cpu os ([0-9]+)_([0-9]+).*/,
 618            /.*cpu iphone os ([0-9]+)_([0-9]+).*/
 619          ]
 620        },
 621        {
 622          name: 'Android',
 623          search: checkContains('android'),
 624          versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/]
 625        },
 626        {
 627          name: 'OSX',
 628          search: checkContains('mac os x'),
 629          versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/]
 630        },
 631        {
 632          name: 'Linux',
 633          search: checkContains('linux'),
 634          versionRegexes: []
 635        },
 636        {
 637          name: 'Solaris',
 638          search: checkContains('sunos'),
 639          versionRegexes: []
 640        },
 641        {
 642          name: 'FreeBSD',
 643          search: checkContains('freebsd'),
 644          versionRegexes: []
 645        },
 646        {
 647          name: 'ChromeOS',
 648          search: checkContains('cros'),
 649          versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/]
 650        }
 651      ];
 652      var PlatformInfo = {
 653        browsers: constant(browsers),
 654        oses: constant(oses)
 655      };
 656  
 657      var edge = 'Edge';
 658      var chrome = 'Chrome';
 659      var ie = 'IE';
 660      var opera = 'Opera';
 661      var firefox = 'Firefox';
 662      var safari = 'Safari';
 663      var unknown$1 = function () {
 664        return nu$1({
 665          current: undefined,
 666          version: Version.unknown()
 667        });
 668      };
 669      var nu$1 = function (info) {
 670        var current = info.current;
 671        var version = info.version;
 672        var isBrowser = function (name) {
 673          return function () {
 674            return current === name;
 675          };
 676        };
 677        return {
 678          current: current,
 679          version: version,
 680          isEdge: isBrowser(edge),
 681          isChrome: isBrowser(chrome),
 682          isIE: isBrowser(ie),
 683          isOpera: isBrowser(opera),
 684          isFirefox: isBrowser(firefox),
 685          isSafari: isBrowser(safari)
 686        };
 687      };
 688      var Browser = {
 689        unknown: unknown$1,
 690        nu: nu$1,
 691        edge: constant(edge),
 692        chrome: constant(chrome),
 693        ie: constant(ie),
 694        opera: constant(opera),
 695        firefox: constant(firefox),
 696        safari: constant(safari)
 697      };
 698  
 699      var windows = 'Windows';
 700      var ios = 'iOS';
 701      var android = 'Android';
 702      var linux = 'Linux';
 703      var osx = 'OSX';
 704      var solaris = 'Solaris';
 705      var freebsd = 'FreeBSD';
 706      var chromeos = 'ChromeOS';
 707      var unknown = function () {
 708        return nu({
 709          current: undefined,
 710          version: Version.unknown()
 711        });
 712      };
 713      var nu = function (info) {
 714        var current = info.current;
 715        var version = info.version;
 716        var isOS = function (name) {
 717          return function () {
 718            return current === name;
 719          };
 720        };
 721        return {
 722          current: current,
 723          version: version,
 724          isWindows: isOS(windows),
 725          isiOS: isOS(ios),
 726          isAndroid: isOS(android),
 727          isOSX: isOS(osx),
 728          isLinux: isOS(linux),
 729          isSolaris: isOS(solaris),
 730          isFreeBSD: isOS(freebsd),
 731          isChromeOS: isOS(chromeos)
 732        };
 733      };
 734      var OperatingSystem = {
 735        unknown: unknown,
 736        nu: nu,
 737        windows: constant(windows),
 738        ios: constant(ios),
 739        android: constant(android),
 740        linux: constant(linux),
 741        osx: constant(osx),
 742        solaris: constant(solaris),
 743        freebsd: constant(freebsd),
 744        chromeos: constant(chromeos)
 745      };
 746  
 747      var detect$4 = function (userAgent, userAgentDataOpt, mediaMatch) {
 748        var browsers = PlatformInfo.browsers();
 749        var oses = PlatformInfo.oses();
 750        var browser = userAgentDataOpt.bind(function (userAgentData) {
 751          return detectBrowser$1(browsers, userAgentData);
 752        }).orThunk(function () {
 753          return detectBrowser(browsers, userAgent);
 754        }).fold(Browser.unknown, Browser.nu);
 755        var os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu);
 756        var deviceType = DeviceType(os, browser, userAgent, mediaMatch);
 757        return {
 758          browser: browser,
 759          os: os,
 760          deviceType: deviceType
 761        };
 762      };
 763      var PlatformDetection = { detect: detect$4 };
 764  
 765      var mediaMatch = function (query) {
 766        return window.matchMedia(query).matches;
 767      };
 768      var platform = cached(function () {
 769        return PlatformDetection.detect(navigator.userAgent, Optional.from(navigator.userAgentData), mediaMatch);
 770      });
 771      var detect$3 = function () {
 772        return platform();
 773      };
 774  
 775      var compareDocumentPosition = function (a, b, match) {
 776        return (a.compareDocumentPosition(b) & match) !== 0;
 777      };
 778      var documentPositionContainedBy = function (a, b) {
 779        return compareDocumentPosition(a, b, Node.DOCUMENT_POSITION_CONTAINED_BY);
 780      };
 781  
 782      var COMMENT = 8;
 783      var DOCUMENT = 9;
 784      var DOCUMENT_FRAGMENT = 11;
 785      var ELEMENT = 1;
 786      var TEXT = 3;
 787  
 788      var fromHtml$1 = function (html, scope) {
 789        var doc = scope || document;
 790        var div = doc.createElement('div');
 791        div.innerHTML = html;
 792        if (!div.hasChildNodes() || div.childNodes.length > 1) {
 793          console.error('HTML does not have a single root node', html);
 794          throw new Error('HTML must have a single root node');
 795        }
 796        return fromDom$1(div.childNodes[0]);
 797      };
 798      var fromTag = function (tag, scope) {
 799        var doc = scope || document;
 800        var node = doc.createElement(tag);
 801        return fromDom$1(node);
 802      };
 803      var fromText = function (text, scope) {
 804        var doc = scope || document;
 805        var node = doc.createTextNode(text);
 806        return fromDom$1(node);
 807      };
 808      var fromDom$1 = function (node) {
 809        if (node === null || node === undefined) {
 810          throw new Error('Node cannot be null or undefined');
 811        }
 812        return { dom: node };
 813      };
 814      var fromPoint$1 = function (docElm, x, y) {
 815        return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom$1);
 816      };
 817      var SugarElement = {
 818        fromHtml: fromHtml$1,
 819        fromTag: fromTag,
 820        fromText: fromText,
 821        fromDom: fromDom$1,
 822        fromPoint: fromPoint$1
 823      };
 824  
 825      var is$2 = function (element, selector) {
 826        var dom = element.dom;
 827        if (dom.nodeType !== ELEMENT) {
 828          return false;
 829        } else {
 830          var elem = dom;
 831          if (elem.matches !== undefined) {
 832            return elem.matches(selector);
 833          } else if (elem.msMatchesSelector !== undefined) {
 834            return elem.msMatchesSelector(selector);
 835          } else if (elem.webkitMatchesSelector !== undefined) {
 836            return elem.webkitMatchesSelector(selector);
 837          } else if (elem.mozMatchesSelector !== undefined) {
 838            return elem.mozMatchesSelector(selector);
 839          } else {
 840            throw new Error('Browser lacks native selectors');
 841          }
 842        }
 843      };
 844      var bypassSelector = function (dom) {
 845        return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT || dom.childElementCount === 0;
 846      };
 847      var all$1 = function (selector, scope) {
 848        var base = scope === undefined ? document : scope.dom;
 849        return bypassSelector(base) ? [] : map$1(base.querySelectorAll(selector), SugarElement.fromDom);
 850      };
 851      var one = function (selector, scope) {
 852        var base = scope === undefined ? document : scope.dom;
 853        return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom);
 854      };
 855  
 856      var eq$1 = function (e1, e2) {
 857        return e1.dom === e2.dom;
 858      };
 859      var regularContains = function (e1, e2) {
 860        var d1 = e1.dom;
 861        var d2 = e2.dom;
 862        return d1 === d2 ? false : d1.contains(d2);
 863      };
 864      var ieContains = function (e1, e2) {
 865        return documentPositionContainedBy(e1.dom, e2.dom);
 866      };
 867      var contains = function (e1, e2) {
 868        return detect$3().browser.isIE() ? ieContains(e1, e2) : regularContains(e1, e2);
 869      };
 870      var is$1 = is$2;
 871  
 872      var keys = Object.keys;
 873      var hasOwnProperty = Object.hasOwnProperty;
 874      var each$1 = function (obj, f) {
 875        var props = keys(obj);
 876        for (var k = 0, len = props.length; k < len; k++) {
 877          var i = props[k];
 878          var x = obj[i];
 879          f(x, i);
 880        }
 881      };
 882      var map = function (obj, f) {
 883        return tupleMap(obj, function (x, i) {
 884          return {
 885            k: i,
 886            v: f(x, i)
 887          };
 888        });
 889      };
 890      var tupleMap = function (obj, f) {
 891        var r = {};
 892        each$1(obj, function (x, i) {
 893          var tuple = f(x, i);
 894          r[tuple.k] = tuple.v;
 895        });
 896        return r;
 897      };
 898      var objAcc = function (r) {
 899        return function (x, i) {
 900          r[i] = x;
 901        };
 902      };
 903      var internalFilter = function (obj, pred, onTrue, onFalse) {
 904        var r = {};
 905        each$1(obj, function (x, i) {
 906          (pred(x, i) ? onTrue : onFalse)(x, i);
 907        });
 908        return r;
 909      };
 910      var filter$1 = function (obj, pred) {
 911        var t = {};
 912        internalFilter(obj, pred, objAcc(t), noop);
 913        return t;
 914      };
 915      var mapToArray = function (obj, f) {
 916        var r = [];
 917        each$1(obj, function (value, name) {
 918          r.push(f(value, name));
 919        });
 920        return r;
 921      };
 922      var values = function (obj) {
 923        return mapToArray(obj, identity);
 924      };
 925      var size = function (obj) {
 926        return keys(obj).length;
 927      };
 928      var get$c = function (obj, key) {
 929        return has$1(obj, key) ? Optional.from(obj[key]) : Optional.none();
 930      };
 931      var has$1 = function (obj, key) {
 932        return hasOwnProperty.call(obj, key);
 933      };
 934      var hasNonNullableKey = function (obj, key) {
 935        return has$1(obj, key) && obj[key] !== undefined && obj[key] !== null;
 936      };
 937      var isEmpty = function (r) {
 938        for (var x in r) {
 939          if (hasOwnProperty.call(r, x)) {
 940            return false;
 941          }
 942        }
 943        return true;
 944      };
 945  
 946      var validSectionList = [
 947        'tfoot',
 948        'thead',
 949        'tbody',
 950        'colgroup'
 951      ];
 952      var isValidSection = function (parentName) {
 953        return contains$2(validSectionList, parentName);
 954      };
 955      var grid = function (rows, columns) {
 956        return {
 957          rows: rows,
 958          columns: columns
 959        };
 960      };
 961      var address = function (row, column) {
 962        return {
 963          row: row,
 964          column: column
 965        };
 966      };
 967      var detail = function (element, rowspan, colspan) {
 968        return {
 969          element: element,
 970          rowspan: rowspan,
 971          colspan: colspan
 972        };
 973      };
 974      var detailnew = function (element, rowspan, colspan, isNew) {
 975        return {
 976          element: element,
 977          rowspan: rowspan,
 978          colspan: colspan,
 979          isNew: isNew
 980        };
 981      };
 982      var extended = function (element, rowspan, colspan, row, column, isLocked) {
 983        return {
 984          element: element,
 985          rowspan: rowspan,
 986          colspan: colspan,
 987          row: row,
 988          column: column,
 989          isLocked: isLocked
 990        };
 991      };
 992      var rowdetail = function (element, cells, section) {
 993        return {
 994          element: element,
 995          cells: cells,
 996          section: section
 997        };
 998      };
 999      var rowdetailnew = function (element, cells, section, isNew) {
1000        return {
1001          element: element,
1002          cells: cells,
1003          section: section,
1004          isNew: isNew
1005        };
1006      };
1007      var elementnew = function (element, isNew, isLocked) {
1008        return {
1009          element: element,
1010          isNew: isNew,
1011          isLocked: isLocked
1012        };
1013      };
1014      var rowcells = function (element, cells, section, isNew) {
1015        return {
1016          element: element,
1017          cells: cells,
1018          section: section,
1019          isNew: isNew
1020        };
1021      };
1022      var bounds = function (startRow, startCol, finishRow, finishCol) {
1023        return {
1024          startRow: startRow,
1025          startCol: startCol,
1026          finishRow: finishRow,
1027          finishCol: finishCol
1028        };
1029      };
1030      var columnext = function (element, colspan, column) {
1031        return {
1032          element: element,
1033          colspan: colspan,
1034          column: column
1035        };
1036      };
1037      var colgroup = function (element, columns) {
1038        return {
1039          element: element,
1040          columns: columns
1041        };
1042      };
1043  
1044      typeof window !== 'undefined' ? window : Function('return this;')();
1045  
1046      var name = function (element) {
1047        var r = element.dom.nodeName;
1048        return r.toLowerCase();
1049      };
1050      var type$1 = function (element) {
1051        return element.dom.nodeType;
1052      };
1053      var isType = function (t) {
1054        return function (element) {
1055          return type$1(element) === t;
1056        };
1057      };
1058      var isComment = function (element) {
1059        return type$1(element) === COMMENT || name(element) === '#comment';
1060      };
1061      var isElement = isType(ELEMENT);
1062      var isText = isType(TEXT);
1063      var isDocument = isType(DOCUMENT);
1064      var isDocumentFragment = isType(DOCUMENT_FRAGMENT);
1065      var isTag = function (tag) {
1066        return function (e) {
1067          return isElement(e) && name(e) === tag;
1068        };
1069      };
1070  
1071      var owner = function (element) {
1072        return SugarElement.fromDom(element.dom.ownerDocument);
1073      };
1074      var documentOrOwner = function (dos) {
1075        return isDocument(dos) ? dos : owner(dos);
1076      };
1077      var defaultView = function (element) {
1078        return SugarElement.fromDom(documentOrOwner(element).dom.defaultView);
1079      };
1080      var parent = function (element) {
1081        return Optional.from(element.dom.parentNode).map(SugarElement.fromDom);
1082      };
1083      var parentElement = function (element) {
1084        return Optional.from(element.dom.parentElement).map(SugarElement.fromDom);
1085      };
1086      var parents = function (element, isRoot) {
1087        var stop = isFunction(isRoot) ? isRoot : never;
1088        var dom = element.dom;
1089        var ret = [];
1090        while (dom.parentNode !== null && dom.parentNode !== undefined) {
1091          var rawParent = dom.parentNode;
1092          var p = SugarElement.fromDom(rawParent);
1093          ret.push(p);
1094          if (stop(p) === true) {
1095            break;
1096          } else {
1097            dom = rawParent;
1098          }
1099        }
1100        return ret;
1101      };
1102      var prevSibling = function (element) {
1103        return Optional.from(element.dom.previousSibling).map(SugarElement.fromDom);
1104      };
1105      var nextSibling = function (element) {
1106        return Optional.from(element.dom.nextSibling).map(SugarElement.fromDom);
1107      };
1108      var children$3 = function (element) {
1109        return map$1(element.dom.childNodes, SugarElement.fromDom);
1110      };
1111      var child$3 = function (element, index) {
1112        var cs = element.dom.childNodes;
1113        return Optional.from(cs[index]).map(SugarElement.fromDom);
1114      };
1115      var firstChild = function (element) {
1116        return child$3(element, 0);
1117      };
1118  
1119      var isShadowRoot = function (dos) {
1120        return isDocumentFragment(dos) && isNonNullable(dos.dom.host);
1121      };
1122      var supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode);
1123      var isSupported$1 = constant(supported);
1124      var getRootNode = supported ? function (e) {
1125        return SugarElement.fromDom(e.dom.getRootNode());
1126      } : documentOrOwner;
1127      var getShadowRoot = function (e) {
1128        var r = getRootNode(e);
1129        return isShadowRoot(r) ? Optional.some(r) : Optional.none();
1130      };
1131      var getShadowHost = function (e) {
1132        return SugarElement.fromDom(e.dom.host);
1133      };
1134      var getOriginalEventTarget = function (event) {
1135        if (isSupported$1() && isNonNullable(event.target)) {
1136          var el = SugarElement.fromDom(event.target);
1137          if (isElement(el) && isOpenShadowHost(el)) {
1138            if (event.composed && event.composedPath) {
1139              var composedPath = event.composedPath();
1140              if (composedPath) {
1141                return head(composedPath);
1142              }
1143            }
1144          }
1145        }
1146        return Optional.from(event.target);
1147      };
1148      var isOpenShadowHost = function (element) {
1149        return isNonNullable(element.dom.shadowRoot);
1150      };
1151  
1152      var inBody = function (element) {
1153        var dom = isText(element) ? element.dom.parentNode : element.dom;
1154        if (dom === undefined || dom === null || dom.ownerDocument === null) {
1155          return false;
1156        }
1157        var doc = dom.ownerDocument;
1158        return getShadowRoot(SugarElement.fromDom(dom)).fold(function () {
1159          return doc.body.contains(dom);
1160        }, compose1(inBody, getShadowHost));
1161      };
1162      var body$1 = function () {
1163        return getBody$1(SugarElement.fromDom(document));
1164      };
1165      var getBody$1 = function (doc) {
1166        var b = doc.dom.body;
1167        if (b === null || b === undefined) {
1168          throw new Error('Body is not available yet');
1169        }
1170        return SugarElement.fromDom(b);
1171      };
1172  
1173      var ancestors$4 = function (scope, predicate, isRoot) {
1174        return filter$2(parents(scope, isRoot), predicate);
1175      };
1176      var children$2 = function (scope, predicate) {
1177        return filter$2(children$3(scope), predicate);
1178      };
1179      var descendants$1 = function (scope, predicate) {
1180        var result = [];
1181        each$2(children$3(scope), function (x) {
1182          if (predicate(x)) {
1183            result = result.concat([x]);
1184          }
1185          result = result.concat(descendants$1(x, predicate));
1186        });
1187        return result;
1188      };
1189  
1190      var ancestors$3 = function (scope, selector, isRoot) {
1191        return ancestors$4(scope, function (e) {
1192          return is$2(e, selector);
1193        }, isRoot);
1194      };
1195      var children$1 = function (scope, selector) {
1196        return children$2(scope, function (e) {
1197          return is$2(e, selector);
1198        });
1199      };
1200      var descendants = function (scope, selector) {
1201        return all$1(selector, scope);
1202      };
1203  
1204      function ClosestOrAncestor (is, ancestor, scope, a, isRoot) {
1205        if (is(scope, a)) {
1206          return Optional.some(scope);
1207        } else if (isFunction(isRoot) && isRoot(scope)) {
1208          return Optional.none();
1209        } else {
1210          return ancestor(scope, a, isRoot);
1211        }
1212      }
1213  
1214      var ancestor$2 = function (scope, predicate, isRoot) {
1215        var element = scope.dom;
1216        var stop = isFunction(isRoot) ? isRoot : never;
1217        while (element.parentNode) {
1218          element = element.parentNode;
1219          var el = SugarElement.fromDom(element);
1220          if (predicate(el)) {
1221            return Optional.some(el);
1222          } else if (stop(el)) {
1223            break;
1224          }
1225        }
1226        return Optional.none();
1227      };
1228      var closest$2 = function (scope, predicate, isRoot) {
1229        var is = function (s, test) {
1230          return test(s);
1231        };
1232        return ClosestOrAncestor(is, ancestor$2, scope, predicate, isRoot);
1233      };
1234      var child$2 = function (scope, predicate) {
1235        var pred = function (node) {
1236          return predicate(SugarElement.fromDom(node));
1237        };
1238        var result = find$1(scope.dom.childNodes, pred);
1239        return result.map(SugarElement.fromDom);
1240      };
1241      var descendant$1 = function (scope, predicate) {
1242        var descend = function (node) {
1243          for (var i = 0; i < node.childNodes.length; i++) {
1244            var child_1 = SugarElement.fromDom(node.childNodes[i]);
1245            if (predicate(child_1)) {
1246              return Optional.some(child_1);
1247            }
1248            var res = descend(node.childNodes[i]);
1249            if (res.isSome()) {
1250              return res;
1251            }
1252          }
1253          return Optional.none();
1254        };
1255        return descend(scope.dom);
1256      };
1257  
1258      var ancestor$1 = function (scope, selector, isRoot) {
1259        return ancestor$2(scope, function (e) {
1260          return is$2(e, selector);
1261        }, isRoot);
1262      };
1263      var child$1 = function (scope, selector) {
1264        return child$2(scope, function (e) {
1265          return is$2(e, selector);
1266        });
1267      };
1268      var descendant = function (scope, selector) {
1269        return one(selector, scope);
1270      };
1271      var closest$1 = function (scope, selector, isRoot) {
1272        var is = function (element, selector) {
1273          return is$2(element, selector);
1274        };
1275        return ClosestOrAncestor(is, ancestor$1, scope, selector, isRoot);
1276      };
1277  
1278      var rawSet = function (dom, key, value) {
1279        if (isString(value) || isBoolean(value) || isNumber(value)) {
1280          dom.setAttribute(key, value + '');
1281        } else {
1282          console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
1283          throw new Error('Attribute value was not simple');
1284        }
1285      };
1286      var set$2 = function (element, key, value) {
1287        rawSet(element.dom, key, value);
1288      };
1289      var setAll$1 = function (element, attrs) {
1290        var dom = element.dom;
1291        each$1(attrs, function (v, k) {
1292          rawSet(dom, k, v);
1293        });
1294      };
1295      var setOptions = function (element, attrs) {
1296        each$1(attrs, function (v, k) {
1297          v.fold(function () {
1298            remove$7(element, k);
1299          }, function (value) {
1300            rawSet(element.dom, k, value);
1301          });
1302        });
1303      };
1304      var get$b = function (element, key) {
1305        var v = element.dom.getAttribute(key);
1306        return v === null ? undefined : v;
1307      };
1308      var getOpt = function (element, key) {
1309        return Optional.from(get$b(element, key));
1310      };
1311      var remove$7 = function (element, key) {
1312        element.dom.removeAttribute(key);
1313      };
1314      var clone$2 = function (element) {
1315        return foldl(element.dom.attributes, function (acc, attr) {
1316          acc[attr.name] = attr.value;
1317          return acc;
1318        }, {});
1319      };
1320  
1321      var is = function (lhs, rhs, comparator) {
1322        if (comparator === void 0) {
1323          comparator = tripleEquals;
1324        }
1325        return lhs.exists(function (left) {
1326          return comparator(left, rhs);
1327        });
1328      };
1329      var cat = function (arr) {
1330        var r = [];
1331        var push = function (x) {
1332          r.push(x);
1333        };
1334        for (var i = 0; i < arr.length; i++) {
1335          arr[i].each(push);
1336        }
1337        return r;
1338      };
1339      var lift2 = function (oa, ob, f) {
1340        return oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none();
1341      };
1342      var bindFrom = function (a, f) {
1343        return a !== undefined && a !== null ? f(a) : Optional.none();
1344      };
1345      var flatten = function (oot) {
1346        return oot.bind(identity);
1347      };
1348      var someIf = function (b, a) {
1349        return b ? Optional.some(a) : Optional.none();
1350      };
1351  
1352      var isSupported = function (dom) {
1353        return dom.style !== undefined && isFunction(dom.style.getPropertyValue);
1354      };
1355  
1356      var internalSet = function (dom, property, value) {
1357        if (!isString(value)) {
1358          console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom);
1359          throw new Error('CSS value must be a string: ' + value);
1360        }
1361        if (isSupported(dom)) {
1362          dom.style.setProperty(property, value);
1363        }
1364      };
1365      var internalRemove = function (dom, property) {
1366        if (isSupported(dom)) {
1367          dom.style.removeProperty(property);
1368        }
1369      };
1370      var set$1 = function (element, property, value) {
1371        var dom = element.dom;
1372        internalSet(dom, property, value);
1373      };
1374      var setAll = function (element, css) {
1375        var dom = element.dom;
1376        each$1(css, function (v, k) {
1377          internalSet(dom, k, v);
1378        });
1379      };
1380      var get$a = function (element, property) {
1381        var dom = element.dom;
1382        var styles = window.getComputedStyle(dom);
1383        var r = styles.getPropertyValue(property);
1384        return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r;
1385      };
1386      var getUnsafeProperty = function (dom, property) {
1387        return isSupported(dom) ? dom.style.getPropertyValue(property) : '';
1388      };
1389      var getRaw$2 = function (element, property) {
1390        var dom = element.dom;
1391        var raw = getUnsafeProperty(dom, property);
1392        return Optional.from(raw).filter(function (r) {
1393          return r.length > 0;
1394        });
1395      };
1396      var remove$6 = function (element, property) {
1397        var dom = element.dom;
1398        internalRemove(dom, property);
1399        if (is(getOpt(element, 'style').map(trim), '')) {
1400          remove$7(element, 'style');
1401        }
1402      };
1403      var copy$2 = function (source, target) {
1404        var sourceDom = source.dom;
1405        var targetDom = target.dom;
1406        if (isSupported(sourceDom) && isSupported(targetDom)) {
1407          targetDom.style.cssText = sourceDom.style.cssText;
1408        }
1409      };
1410  
1411      var getAttrValue = function (cell, name, fallback) {
1412        if (fallback === void 0) {
1413          fallback = 0;
1414        }
1415        return getOpt(cell, name).map(function (value) {
1416          return parseInt(value, 10);
1417        }).getOr(fallback);
1418      };
1419      var getSpan = function (cell, type) {
1420        return getAttrValue(cell, type, 1);
1421      };
1422      var hasColspan = function (cellOrCol) {
1423        if (isTag('col')(cellOrCol)) {
1424          return getAttrValue(cellOrCol, 'span', 1) > 1;
1425        } else {
1426          return getSpan(cellOrCol, 'colspan') > 1;
1427        }
1428      };
1429      var hasRowspan = function (cell) {
1430        return getSpan(cell, 'rowspan') > 1;
1431      };
1432      var getCssValue = function (element, property) {
1433        return parseInt(get$a(element, property), 10);
1434      };
1435      var minWidth = constant(10);
1436      var minHeight = constant(10);
1437  
1438      var firstLayer = function (scope, selector) {
1439        return filterFirstLayer(scope, selector, always);
1440      };
1441      var filterFirstLayer = function (scope, selector, predicate) {
1442        return bind$2(children$3(scope), function (x) {
1443          if (is$2(x, selector)) {
1444            return predicate(x) ? [x] : [];
1445          } else {
1446            return filterFirstLayer(x, selector, predicate);
1447          }
1448        });
1449      };
1450  
1451      var lookup = function (tags, element, isRoot) {
1452        if (isRoot === void 0) {
1453          isRoot = never;
1454        }
1455        if (isRoot(element)) {
1456          return Optional.none();
1457        }
1458        if (contains$2(tags, name(element))) {
1459          return Optional.some(element);
1460        }
1461        var isRootOrUpperTable = function (elm) {
1462          return is$2(elm, 'table') || isRoot(elm);
1463        };
1464        return ancestor$1(element, tags.join(','), isRootOrUpperTable);
1465      };
1466      var cell = function (element, isRoot) {
1467        return lookup([
1468          'td',
1469          'th'
1470        ], element, isRoot);
1471      };
1472      var cells$1 = function (ancestor) {
1473        return firstLayer(ancestor, 'th,td');
1474      };
1475      var columns$1 = function (ancestor) {
1476        if (is$2(ancestor, 'colgroup')) {
1477          return children$1(ancestor, 'col');
1478        } else {
1479          return bind$2(columnGroups(ancestor), function (columnGroup) {
1480            return children$1(columnGroup, 'col');
1481          });
1482        }
1483      };
1484      var table = function (element, isRoot) {
1485        return closest$1(element, 'table', isRoot);
1486      };
1487      var rows$1 = function (ancestor) {
1488        return firstLayer(ancestor, 'tr');
1489      };
1490      var columnGroups = function (ancestor) {
1491        return table(ancestor).fold(constant([]), function (table) {
1492          return children$1(table, 'colgroup');
1493        });
1494      };
1495  
1496      var fromRowsOrColGroups = function (elems, getSection) {
1497        return map$1(elems, function (row) {
1498          if (name(row) === 'colgroup') {
1499            var cells = map$1(columns$1(row), function (column) {
1500              var colspan = getAttrValue(column, 'span', 1);
1501              return detail(column, 1, colspan);
1502            });
1503            return rowdetail(row, cells, 'colgroup');
1504          } else {
1505            var cells = map$1(cells$1(row), function (cell) {
1506              var rowspan = getAttrValue(cell, 'rowspan', 1);
1507              var colspan = getAttrValue(cell, 'colspan', 1);
1508              return detail(cell, rowspan, colspan);
1509            });
1510            return rowdetail(row, cells, getSection(row));
1511          }
1512        });
1513      };
1514      var getParentSection = function (group) {
1515        return parent(group).map(function (parent) {
1516          var parentName = name(parent);
1517          return isValidSection(parentName) ? parentName : 'tbody';
1518        }).getOr('tbody');
1519      };
1520      var fromTable$1 = function (table) {
1521        var rows = rows$1(table);
1522        var columnGroups$1 = columnGroups(table);
1523        var elems = __spreadArray(__spreadArray([], columnGroups$1, true), rows, true);
1524        return fromRowsOrColGroups(elems, getParentSection);
1525      };
1526      var fromPastedRows = function (elems, section) {
1527        return fromRowsOrColGroups(elems, function () {
1528          return section;
1529        });
1530      };
1531  
1532      var addCells = function (gridRow, index, cells) {
1533        var existingCells = gridRow.cells;
1534        var before = existingCells.slice(0, index);
1535        var after = existingCells.slice(index);
1536        var newCells = before.concat(cells).concat(after);
1537        return setCells(gridRow, newCells);
1538      };
1539      var addCell = function (gridRow, index, cell) {
1540        return addCells(gridRow, index, [cell]);
1541      };
1542      var mutateCell = function (gridRow, index, cell) {
1543        var cells = gridRow.cells;
1544        cells[index] = cell;
1545      };
1546      var setCells = function (gridRow, cells) {
1547        return rowcells(gridRow.element, cells, gridRow.section, gridRow.isNew);
1548      };
1549      var mapCells = function (gridRow, f) {
1550        var cells = gridRow.cells;
1551        var r = map$1(cells, f);
1552        return rowcells(gridRow.element, r, gridRow.section, gridRow.isNew);
1553      };
1554      var getCell = function (gridRow, index) {
1555        return gridRow.cells[index];
1556      };
1557      var getCellElement = function (gridRow, index) {
1558        return getCell(gridRow, index).element;
1559      };
1560      var cellLength = function (gridRow) {
1561        return gridRow.cells.length;
1562      };
1563      var extractGridDetails = function (grid) {
1564        var result = partition(grid, function (row) {
1565          return row.section === 'colgroup';
1566        });
1567        return {
1568          rows: result.fail,
1569          cols: result.pass
1570        };
1571      };
1572      var clone$1 = function (gridRow, cloneRow, cloneCell) {
1573        var newCells = map$1(gridRow.cells, cloneCell);
1574        return rowcells(cloneRow(gridRow.element), newCells, gridRow.section, true);
1575      };
1576  
1577      var LOCKED_COL_ATTR = 'data-snooker-locked-cols';
1578      var getLockedColumnsFromTable = function (table) {
1579        return getOpt(table, LOCKED_COL_ATTR).bind(function (lockedColStr) {
1580          return Optional.from(lockedColStr.match(/\d+/g));
1581        }).map(function (lockedCols) {
1582          return mapToObject(lockedCols, always);
1583        });
1584      };
1585      var getLockedColumnsFromGrid = function (grid) {
1586        var locked = foldl(extractGridDetails(grid).rows, function (acc, row) {
1587          each$2(row.cells, function (cell, idx) {
1588            if (cell.isLocked) {
1589              acc[idx] = true;
1590            }
1591          });
1592          return acc;
1593        }, {});
1594        var lockedArr = mapToArray(locked, function (_val, key) {
1595          return parseInt(key, 10);
1596        });
1597        return sort$1(lockedArr);
1598      };
1599  
1600      var key = function (row, column) {
1601        return row + ',' + column;
1602      };
1603      var getAt = function (warehouse, row, column) {
1604        return Optional.from(warehouse.access[key(row, column)]);
1605      };
1606      var findItem = function (warehouse, item, comparator) {
1607        var filtered = filterItems(warehouse, function (detail) {
1608          return comparator(item, detail.element);
1609        });
1610        return filtered.length > 0 ? Optional.some(filtered[0]) : Optional.none();
1611      };
1612      var filterItems = function (warehouse, predicate) {
1613        var all = bind$2(warehouse.all, function (r) {
1614          return r.cells;
1615        });
1616        return filter$2(all, predicate);
1617      };
1618      var generateColumns = function (rowData) {
1619        var columnsGroup = {};
1620        var index = 0;
1621        each$2(rowData.cells, function (column) {
1622          var colspan = column.colspan;
1623          range$1(colspan, function (columnIndex) {
1624            var colIndex = index + columnIndex;
1625            columnsGroup[colIndex] = columnext(column.element, colspan, colIndex);
1626          });
1627          index += colspan;
1628        });
1629        return columnsGroup;
1630      };
1631      var generate$1 = function (list) {
1632        var access = {};
1633        var cells = [];
1634        var tableOpt = head(list).map(function (rowData) {
1635          return rowData.element;
1636        }).bind(table);
1637        var lockedColumns = tableOpt.bind(getLockedColumnsFromTable).getOr({});
1638        var maxRows = 0;
1639        var maxColumns = 0;
1640        var rowCount = 0;
1641        var _a = partition(list, function (rowData) {
1642            return rowData.section === 'colgroup';
1643          }), colgroupRows = _a.pass, rows = _a.fail;
1644        each$2(rows, function (rowData) {
1645          var currentRow = [];
1646          each$2(rowData.cells, function (rowCell) {
1647            var start = 0;
1648            while (access[key(rowCount, start)] !== undefined) {
1649              start++;
1650            }
1651            var isLocked = hasNonNullableKey(lockedColumns, start.toString());
1652            var current = extended(rowCell.element, rowCell.rowspan, rowCell.colspan, rowCount, start, isLocked);
1653            for (var occupiedColumnPosition = 0; occupiedColumnPosition < rowCell.colspan; occupiedColumnPosition++) {
1654              for (var occupiedRowPosition = 0; occupiedRowPosition < rowCell.rowspan; occupiedRowPosition++) {
1655                var rowPosition = rowCount + occupiedRowPosition;
1656                var columnPosition = start + occupiedColumnPosition;
1657                var newpos = key(rowPosition, columnPosition);
1658                access[newpos] = current;
1659                maxColumns = Math.max(maxColumns, columnPosition + 1);
1660              }
1661            }
1662            currentRow.push(current);
1663          });
1664          maxRows++;
1665          cells.push(rowdetail(rowData.element, currentRow, rowData.section));
1666          rowCount++;
1667        });
1668        var _b = last$2(colgroupRows).map(function (rowData) {
1669            var columns = generateColumns(rowData);
1670            var colgroup$1 = colgroup(rowData.element, values(columns));
1671            return {
1672              colgroups: [colgroup$1],
1673              columns: columns
1674            };
1675          }).getOrThunk(function () {
1676            return {
1677              colgroups: [],
1678              columns: {}
1679            };
1680          }), columns = _b.columns, colgroups = _b.colgroups;
1681        var grid$1 = grid(maxRows, maxColumns);
1682        return {
1683          grid: grid$1,
1684          access: access,
1685          all: cells,
1686          columns: columns,
1687          colgroups: colgroups
1688        };
1689      };
1690      var fromTable = function (table) {
1691        var list = fromTable$1(table);
1692        return generate$1(list);
1693      };
1694      var justCells = function (warehouse) {
1695        return bind$2(warehouse.all, function (w) {
1696          return w.cells;
1697        });
1698      };
1699      var justColumns = function (warehouse) {
1700        return values(warehouse.columns);
1701      };
1702      var hasColumns = function (warehouse) {
1703        return keys(warehouse.columns).length > 0;
1704      };
1705      var getColumnAt = function (warehouse, columnIndex) {
1706        return Optional.from(warehouse.columns[columnIndex]);
1707      };
1708      var Warehouse = {
1709        fromTable: fromTable,
1710        generate: generate$1,
1711        getAt: getAt,
1712        findItem: findItem,
1713        filterItems: filterItems,
1714        justCells: justCells,
1715        justColumns: justColumns,
1716        hasColumns: hasColumns,
1717        getColumnAt: getColumnAt
1718      };
1719  
1720      var inSelection = function (bounds, detail) {
1721        var leftEdge = detail.column;
1722        var rightEdge = detail.column + detail.colspan - 1;
1723        var topEdge = detail.row;
1724        var bottomEdge = detail.row + detail.rowspan - 1;
1725        return leftEdge <= bounds.finishCol && rightEdge >= bounds.startCol && (topEdge <= bounds.finishRow && bottomEdge >= bounds.startRow);
1726      };
1727      var isWithin = function (bounds, detail) {
1728        return detail.column >= bounds.startCol && detail.column + detail.colspan - 1 <= bounds.finishCol && detail.row >= bounds.startRow && detail.row + detail.rowspan - 1 <= bounds.finishRow;
1729      };
1730      var isRectangular = function (warehouse, bounds) {
1731        var isRect = true;
1732        var detailIsWithin = curry(isWithin, bounds);
1733        for (var i = bounds.startRow; i <= bounds.finishRow; i++) {
1734          for (var j = bounds.startCol; j <= bounds.finishCol; j++) {
1735            isRect = isRect && Warehouse.getAt(warehouse, i, j).exists(detailIsWithin);
1736          }
1737        }
1738        return isRect ? Optional.some(bounds) : Optional.none();
1739      };
1740  
1741      var getBounds = function (detailA, detailB) {
1742        return bounds(Math.min(detailA.row, detailB.row), Math.min(detailA.column, detailB.column), Math.max(detailA.row + detailA.rowspan - 1, detailB.row + detailB.rowspan - 1), Math.max(detailA.column + detailA.colspan - 1, detailB.column + detailB.colspan - 1));
1743      };
1744      var getAnyBox = function (warehouse, startCell, finishCell) {
1745        var startCoords = Warehouse.findItem(warehouse, startCell, eq$1);
1746        var finishCoords = Warehouse.findItem(warehouse, finishCell, eq$1);
1747        return startCoords.bind(function (sc) {
1748          return finishCoords.map(function (fc) {
1749            return getBounds(sc, fc);
1750          });
1751        });
1752      };
1753      var getBox$1 = function (warehouse, startCell, finishCell) {
1754        return getAnyBox(warehouse, startCell, finishCell).bind(function (bounds) {
1755          return isRectangular(warehouse, bounds);
1756        });
1757      };
1758  
1759      var moveBy$1 = function (warehouse, cell, row, column) {
1760        return Warehouse.findItem(warehouse, cell, eq$1).bind(function (detail) {
1761          var startRow = row > 0 ? detail.row + detail.rowspan - 1 : detail.row;
1762          var startCol = column > 0 ? detail.column + detail.colspan - 1 : detail.column;
1763          var dest = Warehouse.getAt(warehouse, startRow + row, startCol + column);
1764          return dest.map(function (d) {
1765            return d.element;
1766          });
1767        });
1768      };
1769      var intercepts$1 = function (warehouse, start, finish) {
1770        return getAnyBox(warehouse, start, finish).map(function (bounds) {
1771          var inside = Warehouse.filterItems(warehouse, curry(inSelection, bounds));
1772          return map$1(inside, function (detail) {
1773            return detail.element;
1774          });
1775        });
1776      };
1777      var parentCell = function (warehouse, innerCell) {
1778        var isContainedBy = function (c1, c2) {
1779          return contains(c2, c1);
1780        };
1781        return Warehouse.findItem(warehouse, innerCell, isContainedBy).map(function (detail) {
1782          return detail.element;
1783        });
1784      };
1785  
1786      var moveBy = function (cell, deltaRow, deltaColumn) {
1787        return table(cell).bind(function (table) {
1788          var warehouse = getWarehouse(table);
1789          return moveBy$1(warehouse, cell, deltaRow, deltaColumn);
1790        });
1791      };
1792      var intercepts = function (table, first, last) {
1793        var warehouse = getWarehouse(table);
1794        return intercepts$1(warehouse, first, last);
1795      };
1796      var nestedIntercepts = function (table, first, firstTable, last, lastTable) {
1797        var warehouse = getWarehouse(table);
1798        var optStartCell = eq$1(table, firstTable) ? Optional.some(first) : parentCell(warehouse, first);
1799        var optLastCell = eq$1(table, lastTable) ? Optional.some(last) : parentCell(warehouse, last);
1800        return optStartCell.bind(function (startCell) {
1801          return optLastCell.bind(function (lastCell) {
1802            return intercepts$1(warehouse, startCell, lastCell);
1803          });
1804        });
1805      };
1806      var getBox = function (table, first, last) {
1807        var warehouse = getWarehouse(table);
1808        return getBox$1(warehouse, first, last);
1809      };
1810      var getWarehouse = Warehouse.fromTable;
1811  
1812      var before$4 = function (marker, element) {
1813        var parent$1 = parent(marker);
1814        parent$1.each(function (v) {
1815          v.dom.insertBefore(element.dom, marker.dom);
1816        });
1817      };
1818      var after$5 = function (marker, element) {
1819        var sibling = nextSibling(marker);
1820        sibling.fold(function () {
1821          var parent$1 = parent(marker);
1822          parent$1.each(function (v) {
1823            append$1(v, element);
1824          });
1825        }, function (v) {
1826          before$4(v, element);
1827        });
1828      };
1829      var prepend = function (parent, element) {
1830        var firstChild$1 = firstChild(parent);
1831        firstChild$1.fold(function () {
1832          append$1(parent, element);
1833        }, function (v) {
1834          parent.dom.insertBefore(element.dom, v.dom);
1835        });
1836      };
1837      var append$1 = function (parent, element) {
1838        parent.dom.appendChild(element.dom);
1839      };
1840      var appendAt = function (parent, element, index) {
1841        child$3(parent, index).fold(function () {
1842          append$1(parent, element);
1843        }, function (v) {
1844          before$4(v, element);
1845        });
1846      };
1847      var wrap = function (element, wrapper) {
1848        before$4(element, wrapper);
1849        append$1(wrapper, element);
1850      };
1851  
1852      var before$3 = function (marker, elements) {
1853        each$2(elements, function (x) {
1854          before$4(marker, x);
1855        });
1856      };
1857      var after$4 = function (marker, elements) {
1858        each$2(elements, function (x, i) {
1859          var e = i === 0 ? marker : elements[i - 1];
1860          after$5(e, x);
1861        });
1862      };
1863      var append = function (parent, elements) {
1864        each$2(elements, function (x) {
1865          append$1(parent, x);
1866        });
1867      };
1868  
1869      var empty = function (element) {
1870        element.dom.textContent = '';
1871        each$2(children$3(element), function (rogue) {
1872          remove$5(rogue);
1873        });
1874      };
1875      var remove$5 = function (element) {
1876        var dom = element.dom;
1877        if (dom.parentNode !== null) {
1878          dom.parentNode.removeChild(dom);
1879        }
1880      };
1881      var unwrap = function (wrapper) {
1882        var children = children$3(wrapper);
1883        if (children.length > 0) {
1884          before$3(wrapper, children);
1885        }
1886        remove$5(wrapper);
1887      };
1888  
1889      var NodeValue = function (is, name) {
1890        var get = function (element) {
1891          if (!is(element)) {
1892            throw new Error('Can only get ' + name + ' value of a ' + name + ' node');
1893          }
1894          return getOption(element).getOr('');
1895        };
1896        var getOption = function (element) {
1897          return is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();
1898        };
1899        var set = function (element, value) {
1900          if (!is(element)) {
1901            throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');
1902          }
1903          element.dom.nodeValue = value;
1904        };
1905        return {
1906          get: get,
1907          getOption: getOption,
1908          set: set
1909        };
1910      };
1911  
1912      var api$2 = NodeValue(isText, 'text');
1913      var get$9 = function (element) {
1914        return api$2.get(element);
1915      };
1916      var getOption = function (element) {
1917        return api$2.getOption(element);
1918      };
1919      var set = function (element, value) {
1920        return api$2.set(element, value);
1921      };
1922  
1923      var TagBoundaries = [
1924        'body',
1925        'p',
1926        'div',
1927        'article',
1928        'aside',
1929        'figcaption',
1930        'figure',
1931        'footer',
1932        'header',
1933        'nav',
1934        'section',
1935        'ol',
1936        'ul',
1937        'li',
1938        'table',
1939        'thead',
1940        'tbody',
1941        'tfoot',
1942        'caption',
1943        'tr',
1944        'td',
1945        'th',
1946        'h1',
1947        'h2',
1948        'h3',
1949        'h4',
1950        'h5',
1951        'h6',
1952        'blockquote',
1953        'pre',
1954        'address'
1955      ];
1956  
1957      function DomUniverse () {
1958        var clone = function (element) {
1959          return SugarElement.fromDom(element.dom.cloneNode(false));
1960        };
1961        var document = function (element) {
1962          return documentOrOwner(element).dom;
1963        };
1964        var isBoundary = function (element) {
1965          if (!isElement(element)) {
1966            return false;
1967          }
1968          if (name(element) === 'body') {
1969            return true;
1970          }
1971          return contains$2(TagBoundaries, name(element));
1972        };
1973        var isEmptyTag = function (element) {
1974          if (!isElement(element)) {
1975            return false;
1976          }
1977          return contains$2([
1978            'br',
1979            'img',
1980            'hr',
1981            'input'
1982          ], name(element));
1983        };
1984        var isNonEditable = function (element) {
1985          return isElement(element) && get$b(element, 'contenteditable') === 'false';
1986        };
1987        var comparePosition = function (element, other) {
1988          return element.dom.compareDocumentPosition(other.dom);
1989        };
1990        var copyAttributesTo = function (source, destination) {
1991          var as = clone$2(source);
1992          setAll$1(destination, as);
1993        };
1994        var isSpecial = function (element) {
1995          var tag = name(element);
1996          return contains$2([
1997            'script',
1998            'noscript',
1999            'iframe',
2000            'noframes',
2001            'noembed',
2002            'title',
2003            'style',
2004            'textarea',
2005            'xmp'
2006          ], tag);
2007        };
2008        var getLanguage = function (element) {
2009          return isElement(element) ? getOpt(element, 'lang') : Optional.none();
2010        };
2011        return {
2012          up: constant({
2013            selector: ancestor$1,
2014            closest: closest$1,
2015            predicate: ancestor$2,
2016            all: parents
2017          }),
2018          down: constant({
2019            selector: descendants,
2020            predicate: descendants$1
2021          }),
2022          styles: constant({
2023            get: get$a,
2024            getRaw: getRaw$2,
2025            set: set$1,
2026            remove: remove$6
2027          }),
2028          attrs: constant({
2029            get: get$b,
2030            set: set$2,
2031            remove: remove$7,
2032            copyTo: copyAttributesTo
2033          }),
2034          insert: constant({
2035            before: before$4,
2036            after: after$5,
2037            afterAll: after$4,
2038            append: append$1,
2039            appendAll: append,
2040            prepend: prepend,
2041            wrap: wrap
2042          }),
2043          remove: constant({
2044            unwrap: unwrap,
2045            remove: remove$5
2046          }),
2047          create: constant({
2048            nu: SugarElement.fromTag,
2049            clone: clone,
2050            text: SugarElement.fromText
2051          }),
2052          query: constant({
2053            comparePosition: comparePosition,
2054            prevSibling: prevSibling,
2055            nextSibling: nextSibling
2056          }),
2057          property: constant({
2058            children: children$3,
2059            name: name,
2060            parent: parent,
2061            document: document,
2062            isText: isText,
2063            isComment: isComment,
2064            isElement: isElement,
2065            isSpecial: isSpecial,
2066            getLanguage: getLanguage,
2067            getText: get$9,
2068            setText: set,
2069            isBoundary: isBoundary,
2070            isEmptyTag: isEmptyTag,
2071            isNonEditable: isNonEditable
2072          }),
2073          eq: eq$1,
2074          is: is$1
2075        };
2076      }
2077  
2078      var all = function (universe, look, elements, f) {
2079        var head = elements[0];
2080        var tail = elements.slice(1);
2081        return f(universe, look, head, tail);
2082      };
2083      var oneAll = function (universe, look, elements) {
2084        return elements.length > 0 ? all(universe, look, elements, unsafeOne) : Optional.none();
2085      };
2086      var unsafeOne = function (universe, look, head, tail) {
2087        var start = look(universe, head);
2088        return foldr(tail, function (b, a) {
2089          var current = look(universe, a);
2090          return commonElement(universe, b, current);
2091        }, start);
2092      };
2093      var commonElement = function (universe, start, end) {
2094        return start.bind(function (s) {
2095          return end.filter(curry(universe.eq, s));
2096        });
2097      };
2098  
2099      var eq = function (universe, item) {
2100        return curry(universe.eq, item);
2101      };
2102      var ancestors$2 = function (universe, start, end, isRoot) {
2103        if (isRoot === void 0) {
2104          isRoot = never;
2105        }
2106        var ps1 = [start].concat(universe.up().all(start));
2107        var ps2 = [end].concat(universe.up().all(end));
2108        var prune = function (path) {
2109          var index = findIndex(path, isRoot);
2110          return index.fold(function () {
2111            return path;
2112          }, function (ind) {
2113            return path.slice(0, ind + 1);
2114          });
2115        };
2116        var pruned1 = prune(ps1);
2117        var pruned2 = prune(ps2);
2118        var shared = find$1(pruned1, function (x) {
2119          return exists(pruned2, eq(universe, x));
2120        });
2121        return {
2122          firstpath: pruned1,
2123          secondpath: pruned2,
2124          shared: shared
2125        };
2126      };
2127  
2128      var sharedOne$1 = oneAll;
2129      var ancestors$1 = ancestors$2;
2130  
2131      var universe$3 = DomUniverse();
2132      var sharedOne = function (look, elements) {
2133        return sharedOne$1(universe$3, function (_universe, element) {
2134          return look(element);
2135        }, elements);
2136      };
2137      var ancestors = function (start, finish, isRoot) {
2138        return ancestors$1(universe$3, start, finish, isRoot);
2139      };
2140  
2141      var lookupTable = function (container) {
2142        return ancestor$1(container, 'table');
2143      };
2144      var identify = function (start, finish, isRoot) {
2145        var getIsRoot = function (rootTable) {
2146          return function (element) {
2147            return isRoot !== undefined && isRoot(element) || eq$1(element, rootTable);
2148          };
2149        };
2150        if (eq$1(start, finish)) {
2151          return Optional.some({
2152            boxes: Optional.some([start]),
2153            start: start,
2154            finish: finish
2155          });
2156        } else {
2157          return lookupTable(start).bind(function (startTable) {
2158            return lookupTable(finish).bind(function (finishTable) {
2159              if (eq$1(startTable, finishTable)) {
2160                return Optional.some({
2161                  boxes: intercepts(startTable, start, finish),
2162                  start: start,
2163                  finish: finish
2164                });
2165              } else if (contains(startTable, finishTable)) {
2166                var ancestorCells = ancestors$3(finish, 'td,th', getIsRoot(startTable));
2167                var finishCell = ancestorCells.length > 0 ? ancestorCells[ancestorCells.length - 1] : finish;
2168                return Optional.some({
2169                  boxes: nestedIntercepts(startTable, start, startTable, finish, finishTable),
2170                  start: start,
2171                  finish: finishCell
2172                });
2173              } else if (contains(finishTable, startTable)) {
2174                var ancestorCells = ancestors$3(start, 'td,th', getIsRoot(finishTable));
2175                var startCell = ancestorCells.length > 0 ? ancestorCells[ancestorCells.length - 1] : start;
2176                return Optional.some({
2177                  boxes: nestedIntercepts(finishTable, start, startTable, finish, finishTable),
2178                  start: start,
2179                  finish: startCell
2180                });
2181              } else {
2182                return ancestors(start, finish).shared.bind(function (lca) {
2183                  return closest$1(lca, 'table', isRoot).bind(function (lcaTable) {
2184                    var finishAncestorCells = ancestors$3(finish, 'td,th', getIsRoot(lcaTable));
2185                    var finishCell = finishAncestorCells.length > 0 ? finishAncestorCells[finishAncestorCells.length - 1] : finish;
2186                    var startAncestorCells = ancestors$3(start, 'td,th', getIsRoot(lcaTable));
2187                    var startCell = startAncestorCells.length > 0 ? startAncestorCells[startAncestorCells.length - 1] : start;
2188                    return Optional.some({
2189                      boxes: nestedIntercepts(lcaTable, start, startTable, finish, finishTable),
2190                      start: startCell,
2191                      finish: finishCell
2192                    });
2193                  });
2194                });
2195              }
2196            });
2197          });
2198        }
2199      };
2200      var retrieve$1 = function (container, selector) {
2201        var sels = descendants(container, selector);
2202        return sels.length > 0 ? Optional.some(sels) : Optional.none();
2203      };
2204      var getLast = function (boxes, lastSelectedSelector) {
2205        return find$1(boxes, function (box) {
2206          return is$2(box, lastSelectedSelector);
2207        });
2208      };
2209      var getEdges = function (container, firstSelectedSelector, lastSelectedSelector) {
2210        return descendant(container, firstSelectedSelector).bind(function (first) {
2211          return descendant(container, lastSelectedSelector).bind(function (last) {
2212            return sharedOne(lookupTable, [
2213              first,
2214              last
2215            ]).map(function (table) {
2216              return {
2217                first: first,
2218                last: last,
2219                table: table
2220              };
2221            });
2222          });
2223        });
2224      };
2225      var expandTo = function (finish, firstSelectedSelector) {
2226        return ancestor$1(finish, 'table').bind(function (table) {
2227          return descendant(table, firstSelectedSelector).bind(function (start) {
2228            return identify(start, finish).bind(function (identified) {
2229              return identified.boxes.map(function (boxes) {
2230                return {
2231                  boxes: boxes,
2232                  start: identified.start,
2233                  finish: identified.finish
2234                };
2235              });
2236            });
2237          });
2238        });
2239      };
2240      var shiftSelection = function (boxes, deltaRow, deltaColumn, firstSelectedSelector, lastSelectedSelector) {
2241        return getLast(boxes, lastSelectedSelector).bind(function (last) {
2242          return moveBy(last, deltaRow, deltaColumn).bind(function (finish) {
2243            return expandTo(finish, firstSelectedSelector);
2244          });
2245        });
2246      };
2247  
2248      var retrieve = function (container, selector) {
2249        return retrieve$1(container, selector);
2250      };
2251      var retrieveBox = function (container, firstSelectedSelector, lastSelectedSelector) {
2252        return getEdges(container, firstSelectedSelector, lastSelectedSelector).bind(function (edges) {
2253          var isRoot = function (ancestor) {
2254            return eq$1(container, ancestor);
2255          };
2256          var sectionSelector = 'thead,tfoot,tbody,table';
2257          var firstAncestor = ancestor$1(edges.first, sectionSelector, isRoot);
2258          var lastAncestor = ancestor$1(edges.last, sectionSelector, isRoot);
2259          return firstAncestor.bind(function (fA) {
2260            return lastAncestor.bind(function (lA) {
2261              return eq$1(fA, lA) ? getBox(edges.table, edges.first, edges.last) : Optional.none();
2262            });
2263          });
2264        });
2265      };
2266  
2267      var generate = function (cases) {
2268        if (!isArray(cases)) {
2269          throw new Error('cases must be an array');
2270        }
2271        if (cases.length === 0) {
2272          throw new Error('there must be at least one case');
2273        }
2274        var constructors = [];
2275        var adt = {};
2276        each$2(cases, function (acase, count) {
2277          var keys$1 = keys(acase);
2278          if (keys$1.length !== 1) {
2279            throw new Error('one and only one name per case');
2280          }
2281          var key = keys$1[0];
2282          var value = acase[key];
2283          if (adt[key] !== undefined) {
2284            throw new Error('duplicate key detected:' + key);
2285          } else if (key === 'cata') {
2286            throw new Error('cannot have a case named cata (sorry)');
2287          } else if (!isArray(value)) {
2288            throw new Error('case arguments must be an array');
2289          }
2290          constructors.push(key);
2291          adt[key] = function () {
2292            var args = [];
2293            for (var _i = 0; _i < arguments.length; _i++) {
2294              args[_i] = arguments[_i];
2295            }
2296            var argLength = args.length;
2297            if (argLength !== value.length) {
2298              throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
2299            }
2300            var match = function (branches) {
2301              var branchKeys = keys(branches);
2302              if (constructors.length !== branchKeys.length) {
2303                throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
2304              }
2305              var allReqd = forall(constructors, function (reqKey) {
2306                return contains$2(branchKeys, reqKey);
2307              });
2308              if (!allReqd) {
2309                throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
2310              }
2311              return branches[key].apply(null, args);
2312            };
2313            return {
2314              fold: function () {
2315                var foldArgs = [];
2316                for (var _i = 0; _i < arguments.length; _i++) {
2317                  foldArgs[_i] = arguments[_i];
2318                }
2319                if (foldArgs.length !== cases.length) {
2320                  throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
2321                }
2322                var target = foldArgs[count];
2323                return target.apply(null, args);
2324              },
2325              match: match,
2326              log: function (label) {
2327                console.log(label, {
2328                  constructors: constructors,
2329                  constructor: key,
2330                  params: args
2331                });
2332              }
2333            };
2334          };
2335        });
2336        return adt;
2337      };
2338      var Adt = { generate: generate };
2339  
2340      var type = Adt.generate([
2341        { none: [] },
2342        { multiple: ['elements'] },
2343        { single: ['element'] }
2344      ]);
2345      var cata$2 = function (subject, onNone, onMultiple, onSingle) {
2346        return subject.fold(onNone, onMultiple, onSingle);
2347      };
2348      var none$1 = type.none;
2349      var multiple = type.multiple;
2350      var single = type.single;
2351  
2352      var Selections = function (lazyRoot, getStart, selectedSelector) {
2353        var get = function () {
2354          return retrieve(lazyRoot(), selectedSelector).fold(function () {
2355            return getStart().fold(none$1, single);
2356          }, function (cells) {
2357            return multiple(cells);
2358          });
2359        };
2360        return { get: get };
2361      };
2362  
2363      var global$3 = tinymce.util.Tools.resolve('tinymce.PluginManager');
2364  
2365      var clone = function (original, isDeep) {
2366        return SugarElement.fromDom(original.dom.cloneNode(isDeep));
2367      };
2368      var shallow = function (original) {
2369        return clone(original, false);
2370      };
2371      var deep = function (original) {
2372        return clone(original, true);
2373      };
2374      var shallowAs = function (original, tag) {
2375        var nu = SugarElement.fromTag(tag);
2376        var attributes = clone$2(original);
2377        setAll$1(nu, attributes);
2378        return nu;
2379      };
2380      var copy$1 = function (original, tag) {
2381        var nu = shallowAs(original, tag);
2382        var cloneChildren = children$3(deep(original));
2383        append(nu, cloneChildren);
2384        return nu;
2385      };
2386      var mutate$1 = function (original, tag) {
2387        var nu = shallowAs(original, tag);
2388        before$4(original, nu);
2389        var children = children$3(original);
2390        append(nu, children);
2391        remove$5(original);
2392        return nu;
2393      };
2394  
2395      var Dimension = function (name, getOffset) {
2396        var set = function (element, h) {
2397          if (!isNumber(h) && !h.match(/^[0-9]+$/)) {
2398            throw new Error(name + '.set accepts only positive integer values. Value was ' + h);
2399          }
2400          var dom = element.dom;
2401          if (isSupported(dom)) {
2402            dom.style[name] = h + 'px';
2403          }
2404        };
2405        var get = function (element) {
2406          var r = getOffset(element);
2407          if (r <= 0 || r === null) {
2408            var css = get$a(element, name);
2409            return parseFloat(css) || 0;
2410          }
2411          return r;
2412        };
2413        var getOuter = get;
2414        var aggregate = function (element, properties) {
2415          return foldl(properties, function (acc, property) {
2416            var val = get$a(element, property);
2417            var value = val === undefined ? 0 : parseInt(val, 10);
2418            return isNaN(value) ? acc : acc + value;
2419          }, 0);
2420        };
2421        var max = function (element, value, properties) {
2422          var cumulativeInclusions = aggregate(element, properties);
2423          var absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0;
2424          return absoluteMax;
2425        };
2426        return {
2427          set: set,
2428          get: get,
2429          getOuter: getOuter,
2430          aggregate: aggregate,
2431          max: max
2432        };
2433      };
2434  
2435      var needManualCalc = function () {
2436        var browser = detect$3().browser;
2437        return browser.isIE() || browser.isEdge();
2438      };
2439      var toNumber = function (px, fallback) {
2440        return toFloat(px).getOr(fallback);
2441      };
2442      var getProp = function (element, name, fallback) {
2443        return toNumber(get$a(element, name), fallback);
2444      };
2445      var getBoxSizing = function (element) {
2446        return get$a(element, 'box-sizing');
2447      };
2448      var calcContentBoxSize = function (element, size, upper, lower) {
2449        var paddingUpper = getProp(element, 'padding-' + upper, 0);
2450        var paddingLower = getProp(element, 'padding-' + lower, 0);
2451        var borderUpper = getProp(element, 'border-' + upper + '-width', 0);
2452        var borderLower = getProp(element, 'border-' + lower + '-width', 0);
2453        return size - paddingUpper - paddingLower - borderUpper - borderLower;
2454      };
2455      var getCalculatedHeight = function (element, boxSizing) {
2456        var dom = element.dom;
2457        var height = dom.getBoundingClientRect().height || dom.offsetHeight;
2458        return boxSizing === 'border-box' ? height : calcContentBoxSize(element, height, 'top', 'bottom');
2459      };
2460      var getCalculatedWidth = function (element, boxSizing) {
2461        var dom = element.dom;
2462        var width = dom.getBoundingClientRect().width || dom.offsetWidth;
2463        return boxSizing === 'border-box' ? width : calcContentBoxSize(element, width, 'left', 'right');
2464      };
2465      var getHeight$1 = function (element) {
2466        return needManualCalc() ? getCalculatedHeight(element, getBoxSizing(element)) : getProp(element, 'height', element.dom.offsetHeight);
2467      };
2468      var getWidth = function (element) {
2469        return needManualCalc() ? getCalculatedWidth(element, getBoxSizing(element)) : getProp(element, 'width', element.dom.offsetWidth);
2470      };
2471      var getInnerWidth = function (element) {
2472        return getCalculatedWidth(element, 'content-box');
2473      };
2474  
2475      var api$1 = Dimension('width', function (element) {
2476        return element.dom.offsetWidth;
2477      });
2478      var get$8 = function (element) {
2479        return api$1.get(element);
2480      };
2481      var getOuter$2 = function (element) {
2482        return api$1.getOuter(element);
2483      };
2484      var getInner = getInnerWidth;
2485      var getRuntime$1 = getWidth;
2486  
2487      var columns = function (warehouse, isValidCell) {
2488        if (isValidCell === void 0) {
2489          isValidCell = always;
2490        }
2491        var grid = warehouse.grid;
2492        var cols = range$1(grid.columns, identity);
2493        var rowsArr = range$1(grid.rows, identity);
2494        return map$1(cols, function (col) {
2495          var getBlock = function () {
2496            return bind$2(rowsArr, function (r) {
2497              return Warehouse.getAt(warehouse, r, col).filter(function (detail) {
2498                return detail.column === col;
2499              }).toArray();
2500            });
2501          };
2502          var isValid = function (detail) {
2503            return detail.colspan === 1 && isValidCell(detail.element);
2504          };
2505          var getFallback = function () {
2506            return Warehouse.getAt(warehouse, 0, col);
2507          };
2508          return decide(getBlock, isValid, getFallback);
2509        });
2510      };
2511      var decide = function (getBlock, isValid, getFallback) {
2512        var inBlock = getBlock();
2513        var validInBlock = find$1(inBlock, isValid);
2514        var detailOption = validInBlock.orThunk(function () {
2515          return Optional.from(inBlock[0]).orThunk(getFallback);
2516        });
2517        return detailOption.map(function (detail) {
2518          return detail.element;
2519        });
2520      };
2521      var rows = function (warehouse) {
2522        var grid = warehouse.grid;
2523        var rowsArr = range$1(grid.rows, identity);
2524        var cols = range$1(grid.columns, identity);
2525        return map$1(rowsArr, function (row) {
2526          var getBlock = function () {
2527            return bind$2(cols, function (c) {
2528              return Warehouse.getAt(warehouse, row, c).filter(function (detail) {
2529                return detail.row === row;
2530              }).fold(constant([]), function (detail) {
2531                return [detail];
2532              });
2533            });
2534          };
2535          var isSingle = function (detail) {
2536            return detail.rowspan === 1;
2537          };
2538          var getFallback = function () {
2539            return Warehouse.getAt(warehouse, row, 0);
2540          };
2541          return decide(getBlock, isSingle, getFallback);
2542        });
2543      };
2544  
2545      var deduce = function (xs, index) {
2546        if (index < 0 || index >= xs.length - 1) {
2547          return Optional.none();
2548        }
2549        var current = xs[index].fold(function () {
2550          var rest = reverse(xs.slice(0, index));
2551          return findMap(rest, function (a, i) {
2552            return a.map(function (aa) {
2553              return {
2554                value: aa,
2555                delta: i + 1
2556              };
2557            });
2558          });
2559        }, function (c) {
2560          return Optional.some({
2561            value: c,
2562            delta: 0
2563          });
2564        });
2565        var next = xs[index + 1].fold(function () {
2566          var rest = xs.slice(index + 1);
2567          return findMap(rest, function (a, i) {
2568            return a.map(function (aa) {
2569              return {
2570                value: aa,
2571                delta: i + 1
2572              };
2573            });
2574          });
2575        }, function (n) {
2576          return Optional.some({
2577            value: n,
2578            delta: 1
2579          });
2580        });
2581        return current.bind(function (c) {
2582          return next.map(function (n) {
2583            var extras = n.delta + c.delta;
2584            return Math.abs(n.value - c.value) / extras;
2585          });
2586        });
2587      };
2588  
2589      var onDirection = function (isLtr, isRtl) {
2590        return function (element) {
2591          return getDirection(element) === 'rtl' ? isRtl : isLtr;
2592        };
2593      };
2594      var getDirection = function (element) {
2595        return get$a(element, 'direction') === 'rtl' ? 'rtl' : 'ltr';
2596      };
2597  
2598      var api = Dimension('height', function (element) {
2599        var dom = element.dom;
2600        return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight;
2601      });
2602      var get$7 = function (element) {
2603        return api.get(element);
2604      };
2605      var getOuter$1 = function (element) {
2606        return api.getOuter(element);
2607      };
2608      var getRuntime = getHeight$1;
2609  
2610      var r = function (left, top) {
2611        var translate = function (x, y) {
2612          return r(left + x, top + y);
2613        };
2614        return {
2615          left: left,
2616          top: top,
2617          translate: translate
2618        };
2619      };
2620      var SugarPosition = r;
2621  
2622      var boxPosition = function (dom) {
2623        var box = dom.getBoundingClientRect();
2624        return SugarPosition(box.left, box.top);
2625      };
2626      var firstDefinedOrZero = function (a, b) {
2627        if (a !== undefined) {
2628          return a;
2629        } else {
2630          return b !== undefined ? b : 0;
2631        }
2632      };
2633      var absolute = function (element) {
2634        var doc = element.dom.ownerDocument;
2635        var body = doc.body;
2636        var win = doc.defaultView;
2637        var html = doc.documentElement;
2638        if (body === element.dom) {
2639          return SugarPosition(body.offsetLeft, body.offsetTop);
2640        }
2641        var scrollTop = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageYOffset, html.scrollTop);
2642        var scrollLeft = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageXOffset, html.scrollLeft);
2643        var clientTop = firstDefinedOrZero(html.clientTop, body.clientTop);
2644        var clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft);
2645        return viewport(element).translate(scrollLeft - clientLeft, scrollTop - clientTop);
2646      };
2647      var viewport = function (element) {
2648        var dom = element.dom;
2649        var doc = dom.ownerDocument;
2650        var body = doc.body;
2651        if (body === dom) {
2652          return SugarPosition(body.offsetLeft, body.offsetTop);
2653        }
2654        if (!inBody(element)) {
2655          return SugarPosition(0, 0);
2656        }
2657        return boxPosition(dom);
2658      };
2659  
2660      var rowInfo = function (row, y) {
2661        return {
2662          row: row,
2663          y: y
2664        };
2665      };
2666      var colInfo = function (col, x) {
2667        return {
2668          col: col,
2669          x: x
2670        };
2671      };
2672      var rtlEdge = function (cell) {
2673        var pos = absolute(cell);
2674        return pos.left + getOuter$2(cell);
2675      };
2676      var ltrEdge = function (cell) {
2677        return absolute(cell).left;
2678      };
2679      var getLeftEdge = function (index, cell) {
2680        return colInfo(index, ltrEdge(cell));
2681      };
2682      var getRightEdge = function (index, cell) {
2683        return colInfo(index, rtlEdge(cell));
2684      };
2685      var getTop$1 = function (cell) {
2686        return absolute(cell).top;
2687      };
2688      var getTopEdge = function (index, cell) {
2689        return rowInfo(index, getTop$1(cell));
2690      };
2691      var getBottomEdge = function (index, cell) {
2692        return rowInfo(index, getTop$1(cell) + getOuter$1(cell));
2693      };
2694      var findPositions = function (getInnerEdge, getOuterEdge, array) {
2695        if (array.length === 0) {
2696          return [];
2697        }
2698        var lines = map$1(array.slice(1), function (cellOption, index) {
2699          return cellOption.map(function (cell) {
2700            return getInnerEdge(index, cell);
2701          });
2702        });
2703        var lastLine = array[array.length - 1].map(function (cell) {
2704          return getOuterEdge(array.length - 1, cell);
2705        });
2706        return lines.concat([lastLine]);
2707      };
2708      var negate = function (step) {
2709        return -step;
2710      };
2711      var height = {
2712        delta: identity,
2713        positions: function (optElements) {
2714          return findPositions(getTopEdge, getBottomEdge, optElements);
2715        },
2716        edge: getTop$1
2717      };
2718      var ltr$1 = {
2719        delta: identity,
2720        edge: ltrEdge,
2721        positions: function (optElements) {
2722          return findPositions(getLeftEdge, getRightEdge, optElements);
2723        }
2724      };
2725      var rtl$1 = {
2726        delta: negate,
2727        edge: rtlEdge,
2728        positions: function (optElements) {
2729          return findPositions(getRightEdge, getLeftEdge, optElements);
2730        }
2731      };
2732      var detect$2 = onDirection(ltr$1, rtl$1);
2733      var width = {
2734        delta: function (amount, table) {
2735          return detect$2(table).delta(amount, table);
2736        },
2737        positions: function (cols, table) {
2738          return detect$2(table).positions(cols, table);
2739        },
2740        edge: function (cell) {
2741          return detect$2(cell).edge(cell);
2742        }
2743      };
2744  
2745      var units = {
2746        unsupportedLength: [
2747          'em',
2748          'ex',
2749          'cap',
2750          'ch',
2751          'ic',
2752          'rem',
2753          'lh',
2754          'rlh',
2755          'vw',
2756          'vh',
2757          'vi',
2758          'vb',
2759          'vmin',
2760          'vmax',
2761          'cm',
2762          'mm',
2763          'Q',
2764          'in',
2765          'pc',
2766          'pt',
2767          'px'
2768        ],
2769        fixed: [
2770          'px',
2771          'pt'
2772        ],
2773        relative: ['%'],
2774        empty: ['']
2775      };
2776      var pattern = function () {
2777        var decimalDigits = '[0-9]+';
2778        var signedInteger = '[+-]?' + decimalDigits;
2779        var exponentPart = '[eE]' + signedInteger;
2780        var dot = '\\.';
2781        var opt = function (input) {
2782          return '(?:' + input + ')?';
2783        };
2784        var unsignedDecimalLiteral = [
2785          'Infinity',
2786          decimalDigits + dot + opt(decimalDigits) + opt(exponentPart),
2787          dot + decimalDigits + opt(exponentPart),
2788          decimalDigits + opt(exponentPart)
2789        ].join('|');
2790        var float = '[+-]?(?:' + unsignedDecimalLiteral + ')';
2791        return new RegExp('^(' + float + ')(.*)$');
2792      }();
2793      var isUnit = function (unit, accepted) {
2794        return exists(accepted, function (acc) {
2795          return exists(units[acc], function (check) {
2796            return unit === check;
2797          });
2798        });
2799      };
2800      var parse = function (input, accepted) {
2801        var match = Optional.from(pattern.exec(input));
2802        return match.bind(function (array) {
2803          var value = Number(array[1]);
2804          var unitRaw = array[2];
2805          if (isUnit(unitRaw, accepted)) {
2806            return Optional.some({
2807              value: value,
2808              unit: unitRaw
2809            });
2810          } else {
2811            return Optional.none();
2812          }
2813        });
2814      };
2815  
2816      var rPercentageBasedSizeRegex = /(\d+(\.\d+)?)%/;
2817      var rPixelBasedSizeRegex = /(\d+(\.\d+)?)px|em/;
2818      var isCol$2 = isTag('col');
2819      var getPercentSize = function (elm, outerGetter, innerGetter) {
2820        var relativeParent = parentElement(elm).getOrThunk(function () {
2821          return getBody$1(owner(elm));
2822        });
2823        return outerGetter(elm) / innerGetter(relativeParent) * 100;
2824      };
2825      var setPixelWidth = function (cell, amount) {
2826        set$1(cell, 'width', amount + 'px');
2827      };
2828      var setPercentageWidth = function (cell, amount) {
2829        set$1(cell, 'width', amount + '%');
2830      };
2831      var setHeight = function (cell, amount) {
2832        set$1(cell, 'height', amount + 'px');
2833      };
2834      var getHeightValue = function (cell) {
2835        return getRuntime(cell) + 'px';
2836      };
2837      var convert = function (cell, number, getter, setter) {
2838        var newSize = table(cell).map(function (table) {
2839          var total = getter(table);
2840          return Math.floor(number / 100 * total);
2841        }).getOr(number);
2842        setter(cell, newSize);
2843        return newSize;
2844      };
2845      var normalizePixelSize = function (value, cell, getter, setter) {
2846        var number = parseFloat(value);
2847        return endsWith(value, '%') && name(cell) !== 'table' ? convert(cell, number, getter, setter) : number;
2848      };
2849      var getTotalHeight = function (cell) {
2850        var value = getHeightValue(cell);
2851        if (!value) {
2852          return get$7(cell);
2853        }
2854        return normalizePixelSize(value, cell, get$7, setHeight);
2855      };
2856      var get$6 = function (cell, type, f) {
2857        var v = f(cell);
2858        var span = getSpan(cell, type);
2859        return v / span;
2860      };
2861      var getRaw$1 = function (element, prop) {
2862        return getRaw$2(element, prop).orThunk(function () {
2863          return getOpt(element, prop).map(function (val) {
2864            return val + 'px';
2865          });
2866        });
2867      };
2868      var getRawWidth$1 = function (element) {
2869        return getRaw$1(element, 'width');
2870      };
2871      var getRawHeight = function (element) {
2872        return getRaw$1(element, 'height');
2873      };
2874      var getPercentageWidth = function (cell) {
2875        return getPercentSize(cell, get$8, getInner);
2876      };
2877      var getPixelWidth$1 = function (cell) {
2878        return isCol$2(cell) ? get$8(cell) : getRuntime$1(cell);
2879      };
2880      var getHeight = function (cell) {
2881        return get$6(cell, 'rowspan', getTotalHeight);
2882      };
2883      var getGenericWidth = function (cell) {
2884        var width = getRawWidth$1(cell);
2885        return width.bind(function (w) {
2886          return parse(w, [
2887            'fixed',
2888            'relative',
2889            'empty'
2890          ]);
2891        });
2892      };
2893      var setGenericWidth = function (cell, amount, unit) {
2894        set$1(cell, 'width', amount + unit);
2895      };
2896      var getPixelTableWidth = function (table) {
2897        return get$8(table) + 'px';
2898      };
2899      var getPercentTableWidth = function (table) {
2900        return getPercentSize(table, get$8, getInner) + '%';
2901      };
2902      var isPercentSizing$1 = function (table) {
2903        return getRawWidth$1(table).exists(function (size) {
2904          return rPercentageBasedSizeRegex.test(size);
2905        });
2906      };
2907      var isPixelSizing$1 = function (table) {
2908        return getRawWidth$1(table).exists(function (size) {
2909          return rPixelBasedSizeRegex.test(size);
2910        });
2911      };
2912      var isNoneSizing$1 = function (table) {
2913        return getRawWidth$1(table).isNone();
2914      };
2915      var percentageBasedSizeRegex = constant(rPercentageBasedSizeRegex);
2916  
2917      var isCol$1 = isTag('col');
2918      var getRawW = function (cell) {
2919        return getRawWidth$1(cell).getOrThunk(function () {
2920          return getPixelWidth$1(cell) + 'px';
2921        });
2922      };
2923      var getRawH = function (cell) {
2924        return getRawHeight(cell).getOrThunk(function () {
2925          return getHeight(cell) + 'px';
2926        });
2927      };
2928      var justCols = function (warehouse) {
2929        return map$1(Warehouse.justColumns(warehouse), function (column) {
2930          return Optional.from(column.element);
2931        });
2932      };
2933      var isValidColumn = function (cell) {
2934        var browser = detect$3().browser;
2935        var supportsColWidths = browser.isChrome() || browser.isFirefox();
2936        return isCol$1(cell) ? supportsColWidths : true;
2937      };
2938      var getDimension = function (cellOpt, index, backups, filter, getter, fallback) {
2939        return cellOpt.filter(filter).fold(function () {
2940          return fallback(deduce(backups, index));
2941        }, function (cell) {
2942          return getter(cell);
2943        });
2944      };
2945      var getWidthFrom = function (warehouse, table, getWidth, fallback) {
2946        var columnCells = columns(warehouse);
2947        var columns$1 = Warehouse.hasColumns(warehouse) ? justCols(warehouse) : columnCells;
2948        var backups = [Optional.some(width.edge(table))].concat(map$1(width.positions(columnCells, table), function (pos) {
2949          return pos.map(function (p) {
2950            return p.x;
2951          });
2952        }));
2953        var colFilter = not(hasColspan);
2954        return map$1(columns$1, function (cellOption, c) {
2955          return getDimension(cellOption, c, backups, colFilter, function (column) {
2956            if (isValidColumn(column)) {
2957              return getWidth(column);
2958            } else {
2959              var cell = bindFrom(columnCells[c], identity);
2960              return getDimension(cell, c, backups, colFilter, function (cell) {
2961                return fallback(Optional.some(get$8(cell)));
2962              }, fallback);
2963            }
2964          }, fallback);
2965        });
2966      };
2967      var getDeduced = function (deduced) {
2968        return deduced.map(function (d) {
2969          return d + 'px';
2970        }).getOr('');
2971      };
2972      var getRawWidths = function (warehouse, table) {
2973        return getWidthFrom(warehouse, table, getRawW, getDeduced);
2974      };
2975      var getPercentageWidths = function (warehouse, table, tableSize) {
2976        return getWidthFrom(warehouse, table, getPercentageWidth, function (deduced) {
2977          return deduced.fold(function () {
2978            return tableSize.minCellWidth();
2979          }, function (cellWidth) {
2980            return cellWidth / tableSize.pixelWidth() * 100;
2981          });
2982        });
2983      };
2984      var getPixelWidths = function (warehouse, table, tableSize) {
2985        return getWidthFrom(warehouse, table, getPixelWidth$1, function (deduced) {
2986          return deduced.getOrThunk(tableSize.minCellWidth);
2987        });
2988      };
2989      var getHeightFrom = function (warehouse, table, direction, getHeight, fallback) {
2990        var rows$1 = rows(warehouse);
2991        var backups = [Optional.some(direction.edge(table))].concat(map$1(direction.positions(rows$1, table), function (pos) {
2992          return pos.map(function (p) {
2993            return p.y;
2994          });
2995        }));
2996        return map$1(rows$1, function (cellOption, c) {
2997          return getDimension(cellOption, c, backups, not(hasRowspan), getHeight, fallback);
2998        });
2999      };
3000      var getPixelHeights = function (warehouse, table, direction) {
3001        return getHeightFrom(warehouse, table, direction, getHeight, function (deduced) {
3002          return deduced.getOrThunk(minHeight);
3003        });
3004      };
3005      var getRawHeights = function (warehouse, table, direction) {
3006        return getHeightFrom(warehouse, table, direction, getRawH, getDeduced);
3007      };
3008  
3009      var widthLookup = function (table, getter) {
3010        return function () {
3011          if (inBody(table)) {
3012            return getter(table);
3013          } else {
3014            return parseFloat(getRaw$2(table, 'width').getOr('0'));
3015          }
3016        };
3017      };
3018      var noneSize = function (table) {
3019        var getWidth = widthLookup(table, get$8);
3020        var zero = constant(0);
3021        var getWidths = function (warehouse, tableSize) {
3022          return getPixelWidths(warehouse, table, tableSize);
3023        };
3024        return {
3025          width: getWidth,
3026          pixelWidth: getWidth,
3027          getWidths: getWidths,
3028          getCellDelta: zero,
3029          singleColumnWidth: constant([0]),
3030          minCellWidth: zero,
3031          setElementWidth: noop,
3032          adjustTableWidth: noop,
3033          isRelative: true,
3034          label: 'none'
3035        };
3036      };
3037      var percentageSize = function (table) {
3038        var getFloatWidth = widthLookup(table, function (elem) {
3039          return parseFloat(getPercentTableWidth(elem));
3040        });
3041        var getWidth = widthLookup(table, get$8);
3042        var getCellDelta = function (delta) {
3043          return delta / getWidth() * 100;
3044        };
3045        var singleColumnWidth = function (w, _delta) {
3046          return [100 - w];
3047        };
3048        var minCellWidth = function () {
3049          return minWidth() / getWidth() * 100;
3050        };
3051        var adjustTableWidth = function (delta) {
3052          var currentWidth = getFloatWidth();
3053          var change = delta / 100 * currentWidth;
3054          var newWidth = currentWidth + change;
3055          setPercentageWidth(table, newWidth);
3056        };
3057        var getWidths = function (warehouse, tableSize) {
3058          return getPercentageWidths(warehouse, table, tableSize);
3059        };
3060        return {
3061          width: getFloatWidth,
3062          pixelWidth: getWidth,
3063          getWidths: getWidths,
3064          getCellDelta: getCellDelta,
3065          singleColumnWidth: singleColumnWidth,
3066          minCellWidth: minCellWidth,
3067          setElementWidth: setPercentageWidth,
3068          adjustTableWidth: adjustTableWidth,
3069          isRelative: true,
3070          label: 'percent'
3071        };
3072      };
3073      var pixelSize = function (table) {
3074        var getWidth = widthLookup(table, get$8);
3075        var getCellDelta = identity;
3076        var singleColumnWidth = function (w, delta) {
3077          var newNext = Math.max(minWidth(), w + delta);
3078          return [newNext - w];
3079        };
3080        var adjustTableWidth = function (delta) {
3081          var newWidth = getWidth() + delta;
3082          setPixelWidth(table, newWidth);
3083        };
3084        var getWidths = function (warehouse, tableSize) {
3085          return getPixelWidths(warehouse, table, tableSize);
3086        };
3087        return {
3088          width: getWidth,
3089          pixelWidth: getWidth,
3090          getWidths: getWidths,
3091          getCellDelta: getCellDelta,
3092          singleColumnWidth: singleColumnWidth,
3093          minCellWidth: minWidth,
3094          setElementWidth: setPixelWidth,
3095          adjustTableWidth: adjustTableWidth,
3096          isRelative: false,
3097          label: 'pixel'
3098        };
3099      };
3100      var chooseSize = function (element, width) {
3101        var percentMatch = percentageBasedSizeRegex().exec(width);
3102        if (percentMatch !== null) {
3103          return percentageSize(element);
3104        } else {
3105          return pixelSize(element);
3106        }
3107      };
3108      var getTableSize = function (table) {
3109        var width = getRawWidth$1(table);
3110        return width.fold(function () {
3111          return noneSize(table);
3112        }, function (w) {
3113          return chooseSize(table, w);
3114        });
3115      };
3116      var TableSize = {
3117        getTableSize: getTableSize,
3118        pixelSize: pixelSize,
3119        percentageSize: percentageSize,
3120        noneSize: noneSize
3121      };
3122  
3123      var statsStruct = function (minRow, minCol, maxRow, maxCol, allCells, selectedCells) {
3124        return {
3125          minRow: minRow,
3126          minCol: minCol,
3127          maxRow: maxRow,
3128          maxCol: maxCol,
3129          allCells: allCells,
3130          selectedCells: selectedCells
3131        };
3132      };
3133      var findSelectedStats = function (house, isSelected) {
3134        var totalColumns = house.grid.columns;
3135        var totalRows = house.grid.rows;
3136        var minRow = totalRows;
3137        var minCol = totalColumns;
3138        var maxRow = 0;
3139        var maxCol = 0;
3140        var allCells = [];
3141        var selectedCells = [];
3142        each$1(house.access, function (detail) {
3143          allCells.push(detail);
3144          if (isSelected(detail)) {
3145            selectedCells.push(detail);
3146            var startRow = detail.row;
3147            var endRow = startRow + detail.rowspan - 1;
3148            var startCol = detail.column;
3149            var endCol = startCol + detail.colspan - 1;
3150            if (startRow < minRow) {
3151              minRow = startRow;
3152            } else if (endRow > maxRow) {
3153              maxRow = endRow;
3154            }
3155            if (startCol < minCol) {
3156              minCol = startCol;
3157            } else if (endCol > maxCol) {
3158              maxCol = endCol;
3159            }
3160          }
3161        });
3162        return statsStruct(minRow, minCol, maxRow, maxCol, allCells, selectedCells);
3163      };
3164      var makeCell = function (list, seenSelected, rowIndex) {
3165        var row = list[rowIndex].element;
3166        var td = SugarElement.fromTag('td');
3167        append$1(td, SugarElement.fromTag('br'));
3168        var f = seenSelected ? append$1 : prepend;
3169        f(row, td);
3170      };
3171      var fillInGaps = function (list, house, stats, isSelected) {
3172        var totalColumns = house.grid.columns;
3173        var totalRows = house.grid.rows;
3174        for (var i = 0; i < totalRows; i++) {
3175          var seenSelected = false;
3176          for (var j = 0; j < totalColumns; j++) {
3177            if (!(i < stats.minRow || i > stats.maxRow || j < stats.minCol || j > stats.maxCol)) {
3178              var needCell = Warehouse.getAt(house, i, j).filter(isSelected).isNone();
3179              if (needCell) {
3180                makeCell(list, seenSelected, i);
3181              } else {
3182                seenSelected = true;
3183              }
3184            }
3185          }
3186        }
3187      };
3188      var clean = function (replica, stats, house, widthDelta) {
3189        each$1(house.columns, function (col) {
3190          if (col.column < stats.minCol || col.column > stats.maxCol) {
3191            remove$5(col.element);
3192          }
3193        });
3194        var emptyRows = filter$2(firstLayer(replica, 'tr'), function (row) {
3195          return row.dom.childElementCount === 0;
3196        });
3197        each$2(emptyRows, remove$5);
3198        if (stats.minCol === stats.maxCol || stats.minRow === stats.maxRow) {
3199          each$2(firstLayer(replica, 'th,td'), function (cell) {
3200            remove$7(cell, 'rowspan');
3201            remove$7(cell, 'colspan');
3202          });
3203        }
3204        remove$7(replica, LOCKED_COL_ATTR);
3205        remove$7(replica, 'data-snooker-col-series');
3206        var tableSize = TableSize.getTableSize(replica);
3207        tableSize.adjustTableWidth(widthDelta);
3208      };
3209      var getTableWidthDelta = function (table, warehouse, tableSize, stats) {
3210        if (stats.minCol === 0 && warehouse.grid.columns === stats.maxCol + 1) {
3211          return 0;
3212        }
3213        var colWidths = getPixelWidths(warehouse, table, tableSize);
3214        var allColsWidth = foldl(colWidths, function (acc, width) {
3215          return acc + width;
3216        }, 0);
3217        var selectedColsWidth = foldl(colWidths.slice(stats.minCol, stats.maxCol + 1), function (acc, width) {
3218          return acc + width;
3219        }, 0);
3220        var newWidth = selectedColsWidth / allColsWidth * tableSize.pixelWidth();
3221        var delta = newWidth - tableSize.pixelWidth();
3222        return tableSize.getCellDelta(delta);
3223      };
3224      var extract$1 = function (table, selectedSelector) {
3225        var isSelected = function (detail) {
3226          return is$2(detail.element, selectedSelector);
3227        };
3228        var replica = deep(table);
3229        var list = fromTable$1(replica);
3230        var tableSize = TableSize.getTableSize(table);
3231        var replicaHouse = Warehouse.generate(list);
3232        var replicaStats = findSelectedStats(replicaHouse, isSelected);
3233        var selector = 'th:not(' + selectedSelector + ')' + ',td:not(' + selectedSelector + ')';
3234        var unselectedCells = filterFirstLayer(replica, 'th,td', function (cell) {
3235          return is$2(cell, selector);
3236        });
3237        each$2(unselectedCells, remove$5);
3238        fillInGaps(list, replicaHouse, replicaStats, isSelected);
3239        var house = Warehouse.fromTable(table);
3240        var widthDelta = getTableWidthDelta(table, house, tableSize, replicaStats);
3241        clean(replica, replicaStats, replicaHouse, widthDelta);
3242        return replica;
3243      };
3244  
3245      var nbsp = '\xA0';
3246  
3247      var getEnd = function (element) {
3248        return name(element) === 'img' ? 1 : getOption(element).fold(function () {
3249          return children$3(element).length;
3250        }, function (v) {
3251          return v.length;
3252        });
3253      };
3254      var isTextNodeWithCursorPosition = function (el) {
3255        return getOption(el).filter(function (text) {
3256          return text.trim().length !== 0 || text.indexOf(nbsp) > -1;
3257        }).isSome();
3258      };
3259      var elementsWithCursorPosition = [
3260        'img',
3261        'br'
3262      ];
3263      var isCursorPosition = function (elem) {
3264        var hasCursorPosition = isTextNodeWithCursorPosition(elem);
3265        return hasCursorPosition || contains$2(elementsWithCursorPosition, name(elem));
3266      };
3267  
3268      var first = function (element) {
3269        return descendant$1(element, isCursorPosition);
3270      };
3271      var last$1 = function (element) {
3272        return descendantRtl(element, isCursorPosition);
3273      };
3274      var descendantRtl = function (scope, predicate) {
3275        var descend = function (element) {
3276          var children = children$3(element);
3277          for (var i = children.length - 1; i >= 0; i--) {
3278            var child = children[i];
3279            if (predicate(child)) {
3280              return Optional.some(child);
3281            }
3282            var res = descend(child);
3283            if (res.isSome()) {
3284              return res;
3285            }
3286          }
3287          return Optional.none();
3288        };
3289        return descend(scope);
3290      };
3291  
3292      var transferableAttributes = {
3293        scope: [
3294          'row',
3295          'col'
3296        ]
3297      };
3298      var createCell = function (doc) {
3299        return function () {
3300          var td = SugarElement.fromTag('td', doc.dom);
3301          append$1(td, SugarElement.fromTag('br', doc.dom));
3302          return td;
3303        };
3304      };
3305      var createCol = function (doc) {
3306        return function () {
3307          return SugarElement.fromTag('col', doc.dom);
3308        };
3309      };
3310      var createColgroup = function (doc) {
3311        return function () {
3312          return SugarElement.fromTag('colgroup', doc.dom);
3313        };
3314      };
3315      var createRow$1 = function (doc) {
3316        return function () {
3317          return SugarElement.fromTag('tr', doc.dom);
3318        };
3319      };
3320      var replace$1 = function (cell, tag, attrs) {
3321        var replica = copy$1(cell, tag);
3322        each$1(attrs, function (v, k) {
3323          if (v === null) {
3324            remove$7(replica, k);
3325          } else {
3326            set$2(replica, k, v);
3327          }
3328        });
3329        return replica;
3330      };
3331      var pasteReplace = function (cell) {
3332        return cell;
3333      };
3334      var cloneFormats = function (oldCell, newCell, formats) {
3335        var first$1 = first(oldCell);
3336        return first$1.map(function (firstText) {
3337          var formatSelector = formats.join(',');
3338          var parents = ancestors$3(firstText, formatSelector, function (element) {
3339            return eq$1(element, oldCell);
3340          });
3341          return foldr(parents, function (last, parent) {
3342            var clonedFormat = shallow(parent);
3343            remove$7(clonedFormat, 'contenteditable');
3344            append$1(last, clonedFormat);
3345            return clonedFormat;
3346          }, newCell);
3347        }).getOr(newCell);
3348      };
3349      var cloneAppropriateAttributes = function (original, clone) {
3350        each$1(transferableAttributes, function (validAttributes, attributeName) {
3351          return getOpt(original, attributeName).filter(function (attribute) {
3352            return contains$2(validAttributes, attribute);
3353          }).each(function (attribute) {
3354            return set$2(clone, attributeName, attribute);
3355          });
3356        });
3357      };
3358      var cellOperations = function (mutate, doc, formatsToClone) {
3359        var cloneCss = function (prev, clone) {
3360          copy$2(prev.element, clone);
3361          remove$6(clone, 'height');
3362          if (prev.colspan !== 1) {
3363            remove$6(clone, 'width');
3364          }
3365        };
3366        var newCell = function (prev) {
3367          var td = SugarElement.fromTag(name(prev.element), doc.dom);
3368          var formats = formatsToClone.getOr([
3369            'strong',
3370            'em',
3371            'b',
3372            'i',
3373            'span',
3374            'font',
3375            'h1',
3376            'h2',
3377            'h3',
3378            'h4',
3379            'h5',
3380            'h6',
3381            'p',
3382            'div'
3383          ]);
3384          var lastNode = formats.length > 0 ? cloneFormats(prev.element, td, formats) : td;
3385          append$1(lastNode, SugarElement.fromTag('br'));
3386          cloneCss(prev, td);
3387          cloneAppropriateAttributes(prev.element, td);
3388          mutate(prev.element, td);
3389          return td;
3390        };
3391        var newCol = function (prev) {
3392          var col = SugarElement.fromTag(name(prev.element), doc.dom);
3393          cloneCss(prev, col);
3394          mutate(prev.element, col);
3395          return col;
3396        };
3397        return {
3398          col: newCol,
3399          colgroup: createColgroup(doc),
3400          row: createRow$1(doc),
3401          cell: newCell,
3402          replace: replace$1,
3403          colGap: createCol(doc),
3404          gap: createCell(doc)
3405        };
3406      };
3407      var paste$1 = function (doc) {
3408        return {
3409          col: createCol(doc),
3410          colgroup: createColgroup(doc),
3411          row: createRow$1(doc),
3412          cell: createCell(doc),
3413          replace: pasteReplace,
3414          colGap: createCol(doc),
3415          gap: createCell(doc)
3416        };
3417      };
3418  
3419      var fromHtml = function (html, scope) {
3420        var doc = scope || document;
3421        var div = doc.createElement('div');
3422        div.innerHTML = html;
3423        return children$3(SugarElement.fromDom(div));
3424      };
3425      var fromDom = function (nodes) {
3426        return map$1(nodes, SugarElement.fromDom);
3427      };
3428  
3429      var getNodeName = function (elm) {
3430        return elm.nodeName.toLowerCase();
3431      };
3432      var getBody = function (editor) {
3433        return SugarElement.fromDom(editor.getBody());
3434      };
3435      var getPixelWidth = function (elm) {
3436        return elm.getBoundingClientRect().width;
3437      };
3438      var getPixelHeight = function (elm) {
3439        return elm.getBoundingClientRect().height;
3440      };
3441      var getIsRoot = function (editor) {
3442        return function (element) {
3443          return eq$1(element, getBody(editor));
3444        };
3445      };
3446      var removePxSuffix = function (size) {
3447        return size ? size.replace(/px$/, '') : '';
3448      };
3449      var addPxSuffix = function (size) {
3450        return /^\d+(\.\d+)?$/.test(size) ? size + 'px' : size;
3451      };
3452      var removeDataStyle = function (table) {
3453        remove$7(table, 'data-mce-style');
3454        var removeStyleAttribute = function (element) {
3455          return remove$7(element, 'data-mce-style');
3456        };
3457        each$2(cells$1(table), removeStyleAttribute);
3458        each$2(columns$1(table), removeStyleAttribute);
3459        each$2(rows$1(table), removeStyleAttribute);
3460      };
3461      var getRawWidth = function (editor, elm) {
3462        var raw = editor.dom.getStyle(elm, 'width') || editor.dom.getAttrib(elm, 'width');
3463        return Optional.from(raw).filter(isNotEmpty);
3464      };
3465      var isPercentage$1 = function (value) {
3466        return /^(\d+(\.\d+)?)%$/.test(value);
3467      };
3468      var isPixel = function (value) {
3469        return /^(\d+(\.\d+)?)px$/.test(value);
3470      };
3471      var getSelectionStart = function (editor) {
3472        return SugarElement.fromDom(editor.selection.getStart());
3473      };
3474      var getSelectionEnd = function (editor) {
3475        return SugarElement.fromDom(editor.selection.getEnd());
3476      };
3477  
3478      var selection = function (selections) {
3479        return cata$2(selections.get(), constant([]), identity, pure);
3480      };
3481      var unmergable = function (selections) {
3482        var hasSpan = function (elem, type) {
3483          return getOpt(elem, type).exists(function (span) {
3484            return parseInt(span, 10) > 1;
3485          });
3486        };
3487        var hasRowOrColSpan = function (elem) {
3488          return hasSpan(elem, 'rowspan') || hasSpan(elem, 'colspan');
3489        };
3490        var candidates = selection(selections);
3491        return candidates.length > 0 && forall(candidates, hasRowOrColSpan) ? Optional.some(candidates) : Optional.none();
3492      };
3493      var mergable = function (table, selections, ephemera) {
3494        return cata$2(selections.get(), Optional.none, function (cells) {
3495          if (cells.length <= 1) {
3496            return Optional.none();
3497          } else {
3498            return retrieveBox(table, ephemera.firstSelectedSelector, ephemera.lastSelectedSelector).map(function (bounds) {
3499              return {
3500                bounds: bounds,
3501                cells: cells
3502              };
3503            });
3504          }
3505        }, Optional.none);
3506      };
3507  
3508      var strSelected = 'data-mce-selected';
3509      var strSelectedSelector = 'td[' + strSelected + '],th[' + strSelected + ']';
3510      var strAttributeSelector = '[' + strSelected + ']';
3511      var strFirstSelected = 'data-mce-first-selected';
3512      var strFirstSelectedSelector = 'td[' + strFirstSelected + '],th[' + strFirstSelected + ']';
3513      var strLastSelected = 'data-mce-last-selected';
3514      var strLastSelectedSelector = 'td[' + strLastSelected + '],th[' + strLastSelected + ']';
3515      var attributeSelector = strAttributeSelector;
3516      var ephemera = {
3517        selected: strSelected,
3518        selectedSelector: strSelectedSelector,
3519        firstSelected: strFirstSelected,
3520        firstSelectedSelector: strFirstSelectedSelector,
3521        lastSelected: strLastSelected,
3522        lastSelectedSelector: strLastSelectedSelector
3523      };
3524  
3525      var noMenu = function (cell) {
3526        return {
3527          element: cell,
3528          mergable: Optional.none(),
3529          unmergable: Optional.none(),
3530          selection: [cell]
3531        };
3532      };
3533      var forMenu = function (selections, table, cell) {
3534        return {
3535          element: cell,
3536          mergable: mergable(table, selections, ephemera),
3537          unmergable: unmergable(selections),
3538          selection: selection(selections)
3539        };
3540      };
3541      var paste = function (element, clipboard, generators) {
3542        return {
3543          element: element,
3544          clipboard: clipboard,
3545          generators: generators
3546        };
3547      };
3548      var pasteRows = function (selections, cell, clipboard, generators) {
3549        return {
3550          selection: selection(selections),
3551          clipboard: clipboard,
3552          generators: generators
3553        };
3554      };
3555  
3556      var getSelectionCellFallback = function (element) {
3557        return table(element).bind(function (table) {
3558          return retrieve(table, ephemera.firstSelectedSelector);
3559        }).fold(constant(element), function (cells) {
3560          return cells[0];
3561        });
3562      };
3563      var getSelectionFromSelector = function (selector) {
3564        return function (initCell, isRoot) {
3565          var cellName = name(initCell);
3566          var cell = cellName === 'col' || cellName === 'colgroup' ? getSelectionCellFallback(initCell) : initCell;
3567          return closest$1(cell, selector, isRoot);
3568        };
3569      };
3570      var getSelectionCellOrCaption = getSelectionFromSelector('th,td,caption');
3571      var getSelectionCell = getSelectionFromSelector('th,td');
3572      var getCellsFromSelection = function (selections) {
3573        return selection(selections);
3574      };
3575      var getRowsFromSelection = function (selected, selector) {
3576        var cellOpt = getSelectionCell(selected);
3577        var rowsOpt = cellOpt.bind(function (cell) {
3578          return table(cell);
3579        }).map(function (table) {
3580          return rows$1(table);
3581        });
3582        return lift2(cellOpt, rowsOpt, function (cell, rows) {
3583          return filter$2(rows, function (row) {
3584            return exists(fromDom(row.dom.cells), function (rowCell) {
3585              return get$b(rowCell, selector) === '1' || eq$1(rowCell, cell);
3586            });
3587          });
3588        }).getOr([]);
3589      };
3590  
3591      var extractSelected = function (cells) {
3592        return table(cells[0]).map(function (table) {
3593          var replica = extract$1(table, attributeSelector);
3594          removeDataStyle(replica);
3595          return [replica];
3596        });
3597      };
3598      var serializeElements = function (editor, elements) {
3599        return map$1(elements, function (elm) {
3600          return editor.selection.serializer.serialize(elm.dom, {});
3601        }).join('');
3602      };
3603      var getTextContent = function (elements) {
3604        return map$1(elements, function (element) {
3605          return element.dom.innerText;
3606        }).join('');
3607      };
3608      var registerEvents = function (editor, selections, actions) {
3609        editor.on('BeforeGetContent', function (e) {
3610          var multiCellContext = function (cells) {
3611            e.preventDefault();
3612            extractSelected(cells).each(function (elements) {
3613              e.content = e.format === 'text' ? getTextContent(elements) : serializeElements(editor, elements);
3614            });
3615          };
3616          if (e.selection === true) {
3617            cata$2(selections.get(), noop, multiCellContext, noop);
3618          }
3619        });
3620        editor.on('BeforeSetContent', function (e) {
3621          if (e.selection === true && e.paste === true) {
3622            var selectedCells = getCellsFromSelection(selections);
3623            head(selectedCells).each(function (cell) {
3624              table(cell).each(function (table) {
3625                var elements = filter$2(fromHtml(e.content), function (content) {
3626                  return name(content) !== 'meta';
3627                });
3628                var isTable = isTag('table');
3629                if (elements.length === 1 && isTable(elements[0])) {
3630                  e.preventDefault();
3631                  var doc = SugarElement.fromDom(editor.getDoc());
3632                  var generators = paste$1(doc);
3633                  var targets = paste(cell, elements[0], generators);
3634                  actions.pasteCells(table, targets).each(function () {
3635                    editor.focus();
3636                  });
3637                }
3638              });
3639            });
3640          }
3641        });
3642      };
3643  
3644      var adt$7 = Adt.generate([
3645        { none: [] },
3646        { only: ['index'] },
3647        {
3648          left: [
3649            'index',
3650            'next'
3651          ]
3652        },
3653        {
3654          middle: [
3655            'prev',
3656            'index',
3657            'next'
3658          ]
3659        },
3660        {
3661          right: [
3662            'prev',
3663            'index'
3664          ]
3665        }
3666      ]);
3667      var ColumnContext = __assign({}, adt$7);
3668  
3669      var neighbours = function (input, index) {
3670        if (input.length === 0) {
3671          return ColumnContext.none();
3672        }
3673        if (input.length === 1) {
3674          return ColumnContext.only(0);
3675        }
3676        if (index === 0) {
3677          return ColumnContext.left(0, 1);
3678        }
3679        if (index === input.length - 1) {
3680          return ColumnContext.right(index - 1, index);
3681        }
3682        if (index > 0 && index < input.length - 1) {
3683          return ColumnContext.middle(index - 1, index, index + 1);
3684        }
3685        return ColumnContext.none();
3686      };
3687      var determine = function (input, column, step, tableSize, resize) {
3688        var result = input.slice(0);
3689        var context = neighbours(input, column);
3690        var onNone = constant(map$1(result, constant(0)));
3691        var onOnly = function (index) {
3692          return tableSize.singleColumnWidth(result[index], step);
3693        };
3694        var onLeft = function (index, next) {
3695          return resize.calcLeftEdgeDeltas(result, index, next, step, tableSize.minCellWidth(), tableSize.isRelative);
3696        };
3697        var onMiddle = function (prev, index, next) {
3698          return resize.calcMiddleDeltas(result, prev, index, next, step, tableSize.minCellWidth(), tableSize.isRelative);
3699        };
3700        var onRight = function (prev, index) {
3701          return resize.calcRightEdgeDeltas(result, prev, index, step, tableSize.minCellWidth(), tableSize.isRelative);
3702        };
3703        return context.fold(onNone, onOnly, onLeft, onMiddle, onRight);
3704      };
3705  
3706      var total = function (start, end, measures) {
3707        var r = 0;
3708        for (var i = start; i < end; i++) {
3709          r += measures[i] !== undefined ? measures[i] : 0;
3710        }
3711        return r;
3712      };
3713      var recalculateWidthForCells = function (warehouse, widths) {
3714        var all = Warehouse.justCells(warehouse);
3715        return map$1(all, function (cell) {
3716          var width = total(cell.column, cell.column + cell.colspan, widths);
3717          return {
3718            element: cell.element,
3719            width: width,
3720            colspan: cell.colspan
3721          };
3722        });
3723      };
3724      var recalculateWidthForColumns = function (warehouse, widths) {
3725        var groups = Warehouse.justColumns(warehouse);
3726        return map$1(groups, function (column, index) {
3727          return {
3728            element: column.element,
3729            width: widths[index],
3730            colspan: column.colspan
3731          };
3732        });
3733      };
3734      var recalculateHeightForCells = function (warehouse, heights) {
3735        var all = Warehouse.justCells(warehouse);
3736        return map$1(all, function (cell) {
3737          var height = total(cell.row, cell.row + cell.rowspan, heights);
3738          return {
3739            element: cell.element,
3740            height: height,
3741            rowspan: cell.rowspan
3742          };
3743        });
3744      };
3745      var matchRowHeight = function (warehouse, heights) {
3746        return map$1(warehouse.all, function (row, i) {
3747          return {
3748            element: row.element,
3749            height: heights[i]
3750          };
3751        });
3752      };
3753  
3754      var sumUp = function (newSize) {
3755        return foldr(newSize, function (b, a) {
3756          return b + a;
3757        }, 0);
3758      };
3759      var recalculate = function (warehouse, widths) {
3760        if (Warehouse.hasColumns(warehouse)) {
3761          return recalculateWidthForColumns(warehouse, widths);
3762        } else {
3763          return recalculateWidthForCells(warehouse, widths);
3764        }
3765      };
3766      var recalculateAndApply = function (warehouse, widths, tableSize) {
3767        var newSizes = recalculate(warehouse, widths);
3768        each$2(newSizes, function (cell) {
3769          tableSize.setElementWidth(cell.element, cell.width);
3770        });
3771      };
3772      var adjustWidth = function (table, delta, index, resizing, tableSize) {
3773        var warehouse = Warehouse.fromTable(table);
3774        var step = tableSize.getCellDelta(delta);
3775        var widths = tableSize.getWidths(warehouse, tableSize);
3776        var isLastColumn = index === warehouse.grid.columns - 1;
3777        var clampedStep = resizing.clampTableDelta(widths, index, step, tableSize.minCellWidth(), isLastColumn);
3778        var deltas = determine(widths, index, clampedStep, tableSize, resizing);
3779        var newWidths = map$1(deltas, function (dx, i) {
3780          return dx + widths[i];
3781        });
3782        recalculateAndApply(warehouse, newWidths, tableSize);
3783        resizing.resizeTable(tableSize.adjustTableWidth, clampedStep, isLastColumn);
3784      };
3785      var adjustHeight = function (table, delta, index, direction) {
3786        var warehouse = Warehouse.fromTable(table);
3787        var heights = getPixelHeights(warehouse, table, direction);
3788        var newHeights = map$1(heights, function (dy, i) {
3789          return index === i ? Math.max(delta + dy, minHeight()) : dy;
3790        });
3791        var newCellSizes = recalculateHeightForCells(warehouse, newHeights);
3792        var newRowSizes = matchRowHeight(warehouse, newHeights);
3793        each$2(newRowSizes, function (row) {
3794          setHeight(row.element, row.height);
3795        });
3796        each$2(newCellSizes, function (cell) {
3797          setHeight(cell.element, cell.height);
3798        });
3799        var total = sumUp(newHeights);
3800        setHeight(table, total);
3801      };
3802      var adjustAndRedistributeWidths$1 = function (_table, list, details, tableSize, resizeBehaviour) {
3803        var warehouse = Warehouse.generate(list);
3804        var sizes = tableSize.getWidths(warehouse, tableSize);
3805        var tablePixelWidth = tableSize.pixelWidth();
3806        var _a = resizeBehaviour.calcRedestributedWidths(sizes, tablePixelWidth, details.pixelDelta, tableSize.isRelative), newSizes = _a.newSizes, delta = _a.delta;
3807        recalculateAndApply(warehouse, newSizes, tableSize);
3808        tableSize.adjustTableWidth(delta);
3809      };
3810      var adjustWidthTo = function (_table, list, _info, tableSize) {
3811        var warehouse = Warehouse.generate(list);
3812        var widths = tableSize.getWidths(warehouse, tableSize);
3813        recalculateAndApply(warehouse, widths, tableSize);
3814      };
3815  
3816      var zero = function (array) {
3817        return map$1(array, constant(0));
3818      };
3819      var surround = function (sizes, startIndex, endIndex, results, f) {
3820        return f(sizes.slice(0, startIndex)).concat(results).concat(f(sizes.slice(endIndex)));
3821      };
3822      var clampDeltaHelper = function (predicate) {
3823        return function (sizes, index, delta, minCellSize) {
3824          if (!predicate(delta)) {
3825            return delta;
3826          } else {
3827            var newSize = Math.max(minCellSize, sizes[index] - Math.abs(delta));
3828            var diff = Math.abs(newSize - sizes[index]);
3829            return delta >= 0 ? diff : -diff;
3830          }
3831        };
3832      };
3833      var clampNegativeDelta = clampDeltaHelper(function (delta) {
3834        return delta < 0;
3835      });
3836      var clampDelta = clampDeltaHelper(always);
3837      var resizeTable = function () {
3838        var calcFixedDeltas = function (sizes, index, next, delta, minCellSize) {
3839          var clampedDelta = clampNegativeDelta(sizes, index, delta, minCellSize);
3840          return surround(sizes, index, next + 1, [
3841            clampedDelta,
3842            0
3843          ], zero);
3844        };
3845        var calcRelativeDeltas = function (sizes, index, delta, minCellSize) {
3846          var ratio = (100 + delta) / 100;
3847          var newThis = Math.max(minCellSize, (sizes[index] + delta) / ratio);
3848          return map$1(sizes, function (size, idx) {
3849            var newSize = idx === index ? newThis : size / ratio;
3850            return newSize - size;
3851          });
3852        };
3853        var calcLeftEdgeDeltas = function (sizes, index, next, delta, minCellSize, isRelative) {
3854          if (isRelative) {
3855            return calcRelativeDeltas(sizes, index, delta, minCellSize);
3856          } else {
3857            return calcFixedDeltas(sizes, index, next, delta, minCellSize);
3858          }
3859        };
3860        var calcMiddleDeltas = function (sizes, _prev, index, next, delta, minCellSize, isRelative) {
3861          return calcLeftEdgeDeltas(sizes, index, next, delta, minCellSize, isRelative);
3862        };
3863        var resizeTable = function (resizer, delta) {
3864          return resizer(delta);
3865        };
3866        var calcRightEdgeDeltas = function (sizes, _prev, index, delta, minCellSize, isRelative) {
3867          if (isRelative) {
3868            return calcRelativeDeltas(sizes, index, delta, minCellSize);
3869          } else {
3870            var clampedDelta = clampNegativeDelta(sizes, index, delta, minCellSize);
3871            return zero(sizes.slice(0, index)).concat([clampedDelta]);
3872          }
3873        };
3874        var calcRedestributedWidths = function (sizes, totalWidth, pixelDelta, isRelative) {
3875          if (isRelative) {
3876            var tableWidth = totalWidth + pixelDelta;
3877            var ratio_1 = tableWidth / totalWidth;
3878            var newSizes = map$1(sizes, function (size) {
3879              return size / ratio_1;
3880            });
3881            return {
3882              delta: ratio_1 * 100 - 100,
3883              newSizes: newSizes
3884            };
3885          } else {
3886            return {
3887              delta: pixelDelta,
3888              newSizes: sizes
3889            };
3890          }
3891        };
3892        return {
3893          resizeTable: resizeTable,
3894          clampTableDelta: clampNegativeDelta,
3895          calcLeftEdgeDeltas: calcLeftEdgeDeltas,
3896          calcMiddleDeltas: calcMiddleDeltas,
3897          calcRightEdgeDeltas: calcRightEdgeDeltas,
3898          calcRedestributedWidths: calcRedestributedWidths
3899        };
3900      };
3901      var preserveTable = function () {
3902        var calcLeftEdgeDeltas = function (sizes, index, next, delta, minCellSize) {
3903          var idx = delta >= 0 ? next : index;
3904          var clampedDelta = clampDelta(sizes, idx, delta, minCellSize);
3905          return surround(sizes, index, next + 1, [
3906            clampedDelta,
3907            -clampedDelta
3908          ], zero);
3909        };
3910        var calcMiddleDeltas = function (sizes, _prev, index, next, delta, minCellSize) {
3911          return calcLeftEdgeDeltas(sizes, index, next, delta, minCellSize);
3912        };
3913        var resizeTable = function (resizer, delta, isLastColumn) {
3914          if (isLastColumn) {
3915            resizer(delta);
3916          }
3917        };
3918        var calcRightEdgeDeltas = function (sizes, _prev, _index, delta, _minCellSize, isRelative) {
3919          if (isRelative) {
3920            return zero(sizes);
3921          } else {
3922            var diff = delta / sizes.length;
3923            return map$1(sizes, constant(diff));
3924          }
3925        };
3926        var clampTableDelta = function (sizes, index, delta, minCellSize, isLastColumn) {
3927          if (isLastColumn) {
3928            if (delta >= 0) {
3929              return delta;
3930            } else {
3931              var maxDelta = foldl(sizes, function (a, b) {
3932                return a + b - minCellSize;
3933              }, 0);
3934              return Math.max(-maxDelta, delta);
3935            }
3936          } else {
3937            return clampNegativeDelta(sizes, index, delta, minCellSize);
3938          }
3939        };
3940        var calcRedestributedWidths = function (sizes, _totalWidth, _pixelDelta, _isRelative) {
3941          return {
3942            delta: 0,
3943            newSizes: sizes
3944          };
3945        };
3946        return {
3947          resizeTable: resizeTable,
3948          clampTableDelta: clampTableDelta,
3949          calcLeftEdgeDeltas: calcLeftEdgeDeltas,
3950          calcMiddleDeltas: calcMiddleDeltas,
3951          calcRightEdgeDeltas: calcRightEdgeDeltas,
3952          calcRedestributedWidths: calcRedestributedWidths
3953        };
3954      };
3955  
3956      var only = function (element, isResizable) {
3957        var parent = Optional.from(element.dom.documentElement).map(SugarElement.fromDom).getOr(element);
3958        return {
3959          parent: constant(parent),
3960          view: constant(element),
3961          origin: constant(SugarPosition(0, 0)),
3962          isResizable: isResizable
3963        };
3964      };
3965      var detached = function (editable, chrome, isResizable) {
3966        var origin = function () {
3967          return absolute(chrome);
3968        };
3969        return {
3970          parent: constant(chrome),
3971          view: constant(editable),
3972          origin: origin,
3973          isResizable: isResizable
3974        };
3975      };
3976      var body = function (editable, chrome, isResizable) {
3977        return {
3978          parent: constant(chrome),
3979          view: constant(editable),
3980          origin: constant(SugarPosition(0, 0)),
3981          isResizable: isResizable
3982        };
3983      };
3984      var ResizeWire = {
3985        only: only,
3986        detached: detached,
3987        body: body
3988      };
3989  
3990      var adt$6 = Adt.generate([
3991        { invalid: ['raw'] },
3992        { pixels: ['value'] },
3993        { percent: ['value'] }
3994      ]);
3995      var validateFor = function (suffix, type, value) {
3996        var rawAmount = value.substring(0, value.length - suffix.length);
3997        var amount = parseFloat(rawAmount);
3998        return rawAmount === amount.toString() ? type(amount) : adt$6.invalid(value);
3999      };
4000      var from = function (value) {
4001        if (endsWith(value, '%')) {
4002          return validateFor('%', adt$6.percent, value);
4003        }
4004        if (endsWith(value, 'px')) {
4005          return validateFor('px', adt$6.pixels, value);
4006        }
4007        return adt$6.invalid(value);
4008      };
4009      var Size = __assign(__assign({}, adt$6), { from: from });
4010  
4011      var redistributeToPercent = function (widths, totalWidth) {
4012        return map$1(widths, function (w) {
4013          var colType = Size.from(w);
4014          return colType.fold(function () {
4015            return w;
4016          }, function (px) {
4017            var ratio = px / totalWidth * 100;
4018            return ratio + '%';
4019          }, function (pc) {
4020            return pc + '%';
4021          });
4022        });
4023      };
4024      var redistributeToPx = function (widths, totalWidth, newTotalWidth) {
4025        var scale = newTotalWidth / totalWidth;
4026        return map$1(widths, function (w) {
4027          var colType = Size.from(w);
4028          return colType.fold(function () {
4029            return w;
4030          }, function (px) {
4031            return px * scale + 'px';
4032          }, function (pc) {
4033            return pc / 100 * newTotalWidth + 'px';
4034          });
4035        });
4036      };
4037      var redistributeEmpty = function (newWidthType, columns) {
4038        var f = newWidthType.fold(function () {
4039          return constant('');
4040        }, function (pixels) {
4041          var num = pixels / columns;
4042          return constant(num + 'px');
4043        }, function () {
4044          var num = 100 / columns;
4045          return constant(num + '%');
4046        });
4047        return range$1(columns, f);
4048      };
4049      var redistributeValues = function (newWidthType, widths, totalWidth) {
4050        return newWidthType.fold(function () {
4051          return widths;
4052        }, function (px) {
4053          return redistributeToPx(widths, totalWidth, px);
4054        }, function (_pc) {
4055          return redistributeToPercent(widths, totalWidth);
4056        });
4057      };
4058      var redistribute$1 = function (widths, totalWidth, newWidth) {
4059        var newType = Size.from(newWidth);
4060        var floats = forall(widths, function (s) {
4061          return s === '0px';
4062        }) ? redistributeEmpty(newType, widths.length) : redistributeValues(newType, widths, totalWidth);
4063        return normalize(floats);
4064      };
4065      var sum = function (values, fallback) {
4066        if (values.length === 0) {
4067          return fallback;
4068        }
4069        return foldr(values, function (rest, v) {
4070          return Size.from(v).fold(constant(0), identity, identity) + rest;
4071        }, 0);
4072      };
4073      var roundDown = function (num, unit) {
4074        var floored = Math.floor(num);
4075        return {
4076          value: floored + unit,
4077          remainder: num - floored
4078        };
4079      };
4080      var add$3 = function (value, amount) {
4081        return Size.from(value).fold(constant(value), function (px) {
4082          return px + amount + 'px';
4083        }, function (pc) {
4084          return pc + amount + '%';
4085        });
4086      };
4087      var normalize = function (values) {
4088        if (values.length === 0) {
4089          return values;
4090        }
4091        var scan = foldr(values, function (rest, value) {
4092          var info = Size.from(value).fold(function () {
4093            return {
4094              value: value,
4095              remainder: 0
4096            };
4097          }, function (num) {
4098            return roundDown(num, 'px');
4099          }, function (num) {
4100            return {
4101              value: num + '%',
4102              remainder: 0
4103            };
4104          });
4105          return {
4106            output: [info.value].concat(rest.output),
4107            remainder: rest.remainder + info.remainder
4108          };
4109        }, {
4110          output: [],
4111          remainder: 0
4112        });
4113        var r = scan.output;
4114        return r.slice(0, r.length - 1).concat([add$3(r[r.length - 1], Math.round(scan.remainder))]);
4115      };
4116      var validate = Size.from;
4117  
4118      var redistributeToW = function (newWidths, cells, unit) {
4119        each$2(cells, function (cell) {
4120          var widths = newWidths.slice(cell.column, cell.colspan + cell.column);
4121          var w = sum(widths, minWidth());
4122          set$1(cell.element, 'width', w + unit);
4123        });
4124      };
4125      var redistributeToColumns = function (newWidths, columns, unit) {
4126        each$2(columns, function (column, index) {
4127          var width = sum([newWidths[index]], minWidth());
4128          set$1(column.element, 'width', width + unit);
4129        });
4130      };
4131      var redistributeToH = function (newHeights, rows, cells, unit) {
4132        each$2(cells, function (cell) {
4133          var heights = newHeights.slice(cell.row, cell.rowspan + cell.row);
4134          var h = sum(heights, minHeight());
4135          set$1(cell.element, 'height', h + unit);
4136        });
4137        each$2(rows, function (row, i) {
4138          set$1(row.element, 'height', newHeights[i]);
4139        });
4140      };
4141      var getUnit = function (newSize) {
4142        return validate(newSize).fold(constant('px'), constant('px'), constant('%'));
4143      };
4144      var redistribute = function (table, optWidth, optHeight) {
4145        var warehouse = Warehouse.fromTable(table);
4146        var rows = warehouse.all;
4147        var cells = Warehouse.justCells(warehouse);
4148        var columns = Warehouse.justColumns(warehouse);
4149        optWidth.each(function (newWidth) {
4150          var widthUnit = getUnit(newWidth);
4151          var totalWidth = get$8(table);
4152          var oldWidths = getRawWidths(warehouse, table);
4153          var nuWidths = redistribute$1(oldWidths, totalWidth, newWidth);
4154          if (Warehouse.hasColumns(warehouse)) {
4155            redistributeToColumns(nuWidths, columns, widthUnit);
4156          } else {
4157            redistributeToW(nuWidths, cells, widthUnit);
4158          }
4159          set$1(table, 'width', newWidth);
4160        });
4161        optHeight.each(function (newHeight) {
4162          var hUnit = getUnit(newHeight);
4163          var totalHeight = get$7(table);
4164          var oldHeights = getRawHeights(warehouse, table, height);
4165          var nuHeights = redistribute$1(oldHeights, totalHeight, newHeight);
4166          redistributeToH(nuHeights, rows, cells, hUnit);
4167          set$1(table, 'height', newHeight);
4168        });
4169      };
4170      var isPercentSizing = isPercentSizing$1;
4171      var isPixelSizing = isPixelSizing$1;
4172      var isNoneSizing = isNoneSizing$1;
4173  
4174      var getGridSize = function (table) {
4175        var warehouse = Warehouse.fromTable(table);
4176        return warehouse.grid;
4177      };
4178  
4179      var Event = function (fields) {
4180        var handlers = [];
4181        var bind = function (handler) {
4182          if (handler === undefined) {
4183            throw new Error('Event bind error: undefined handler');
4184          }
4185          handlers.push(handler);
4186        };
4187        var unbind = function (handler) {
4188          handlers = filter$2(handlers, function (h) {
4189            return h !== handler;
4190          });
4191        };
4192        var trigger = function () {
4193          var args = [];
4194          for (var _i = 0; _i < arguments.length; _i++) {
4195            args[_i] = arguments[_i];
4196          }
4197          var event = {};
4198          each$2(fields, function (name, i) {
4199            event[name] = args[i];
4200          });
4201          each$2(handlers, function (handler) {
4202            handler(event);
4203          });
4204        };
4205        return {
4206          bind: bind,
4207          unbind: unbind,
4208          trigger: trigger
4209        };
4210      };
4211  
4212      var create$4 = function (typeDefs) {
4213        var registry = map(typeDefs, function (event) {
4214          return {
4215            bind: event.bind,
4216            unbind: event.unbind
4217          };
4218        });
4219        var trigger = map(typeDefs, function (event) {
4220          return event.trigger;
4221        });
4222        return {
4223          registry: registry,
4224          trigger: trigger
4225        };
4226      };
4227  
4228      var last = function (fn, rate) {
4229        var timer = null;
4230        var cancel = function () {
4231          if (!isNull(timer)) {
4232            clearTimeout(timer);
4233            timer = null;
4234          }
4235        };
4236        var throttle = function () {
4237          var args = [];
4238          for (var _i = 0; _i < arguments.length; _i++) {
4239            args[_i] = arguments[_i];
4240          }
4241          cancel();
4242          timer = setTimeout(function () {
4243            timer = null;
4244            fn.apply(null, args);
4245          }, rate);
4246        };
4247        return {
4248          cancel: cancel,
4249          throttle: throttle
4250        };
4251      };
4252  
4253      var sort = function (arr) {
4254        return arr.slice(0).sort();
4255      };
4256      var reqMessage = function (required, keys) {
4257        throw new Error('All required keys (' + sort(required).join(', ') + ') were not specified. Specified keys were: ' + sort(keys).join(', ') + '.');
4258      };
4259      var unsuppMessage = function (unsupported) {
4260        throw new Error('Unsupported keys for object: ' + sort(unsupported).join(', '));
4261      };
4262      var validateStrArr = function (label, array) {
4263        if (!isArray(array)) {
4264          throw new Error('The ' + label + ' fields must be an array. Was: ' + array + '.');
4265        }
4266        each$2(array, function (a) {
4267          if (!isString(a)) {
4268            throw new Error('The value ' + a + ' in the ' + label + ' fields was not a string.');
4269          }
4270        });
4271      };
4272      var invalidTypeMessage = function (incorrect, type) {
4273        throw new Error('All values need to be of type: ' + type + '. Keys (' + sort(incorrect).join(', ') + ') were not.');
4274      };
4275      var checkDupes = function (everything) {
4276        var sorted = sort(everything);
4277        var dupe = find$1(sorted, function (s, i) {
4278          return i < sorted.length - 1 && s === sorted[i + 1];
4279        });
4280        dupe.each(function (d) {
4281          throw new Error('The field: ' + d + ' occurs more than once in the combined fields: [' + sorted.join(', ') + '].');
4282        });
4283      };
4284  
4285      var base = function (handleUnsupported, required) {
4286        return baseWith(handleUnsupported, required, {
4287          validate: isFunction,
4288          label: 'function'
4289        });
4290      };
4291      var baseWith = function (handleUnsupported, required, pred) {
4292        if (required.length === 0) {
4293          throw new Error('You must specify at least one required field.');
4294        }
4295        validateStrArr('required', required);
4296        checkDupes(required);
4297        return function (obj) {
4298          var keys$1 = keys(obj);
4299          var allReqd = forall(required, function (req) {
4300            return contains$2(keys$1, req);
4301          });
4302          if (!allReqd) {
4303            reqMessage(required, keys$1);
4304          }
4305          handleUnsupported(required, keys$1);
4306          var invalidKeys = filter$2(required, function (key) {
4307            return !pred.validate(obj[key], key);
4308          });
4309          if (invalidKeys.length > 0) {
4310            invalidTypeMessage(invalidKeys, pred.label);
4311          }
4312          return obj;
4313        };
4314      };
4315      var handleExact = function (required, keys) {
4316        var unsupported = filter$2(keys, function (key) {
4317          return !contains$2(required, key);
4318        });
4319        if (unsupported.length > 0) {
4320          unsuppMessage(unsupported);
4321        }
4322      };
4323      var exactly = function (required) {
4324        return base(handleExact, required);
4325      };
4326  
4327      var DragMode = exactly([
4328        'compare',
4329        'extract',
4330        'mutate',
4331        'sink'
4332      ]);
4333      var DragSink = exactly([
4334        'element',
4335        'start',
4336        'stop',
4337        'destroy'
4338      ]);
4339      var DragApi = exactly([
4340        'forceDrop',
4341        'drop',
4342        'move',
4343        'delayDrop'
4344      ]);
4345  
4346      var InDrag = function () {
4347        var previous = Optional.none();
4348        var reset = function () {
4349          previous = Optional.none();
4350        };
4351        var update = function (mode, nu) {
4352          var result = previous.map(function (old) {
4353            return mode.compare(old, nu);
4354          });
4355          previous = Optional.some(nu);
4356          return result;
4357        };
4358        var onEvent = function (event, mode) {
4359          var dataOption = mode.extract(event);
4360          dataOption.each(function (data) {
4361            var offset = update(mode, data);
4362            offset.each(function (d) {
4363              events.trigger.move(d);
4364            });
4365          });
4366        };
4367        var events = create$4({ move: Event(['info']) });
4368        return {
4369          onEvent: onEvent,
4370          reset: reset,
4371          events: events.registry
4372        };
4373      };
4374  
4375      var NoDrag = function () {
4376        var events = create$4({ move: Event(['info']) });
4377        return {
4378          onEvent: noop,
4379          reset: noop,
4380          events: events.registry
4381        };
4382      };
4383  
4384      var Movement = function () {
4385        var noDragState = NoDrag();
4386        var inDragState = InDrag();
4387        var dragState = noDragState;
4388        var on = function () {
4389          dragState.reset();
4390          dragState = inDragState;
4391        };
4392        var off = function () {
4393          dragState.reset();
4394          dragState = noDragState;
4395        };
4396        var onEvent = function (event, mode) {
4397          dragState.onEvent(event, mode);
4398        };
4399        var isOn = function () {
4400          return dragState === inDragState;
4401        };
4402        return {
4403          on: on,
4404          off: off,
4405          isOn: isOn,
4406          onEvent: onEvent,
4407          events: inDragState.events
4408        };
4409      };
4410  
4411      var setup = function (mutation, mode, settings) {
4412        var active = false;
4413        var events = create$4({
4414          start: Event([]),
4415          stop: Event([])
4416        });
4417        var movement = Movement();
4418        var drop = function () {
4419          sink.stop();
4420          if (movement.isOn()) {
4421            movement.off();
4422            events.trigger.stop();
4423          }
4424        };
4425        var throttledDrop = last(drop, 200);
4426        var go = function (parent) {
4427          sink.start(parent);
4428          movement.on();
4429          events.trigger.start();
4430        };
4431        var mousemove = function (event) {
4432          throttledDrop.cancel();
4433          movement.onEvent(event, mode);
4434        };
4435        movement.events.move.bind(function (event) {
4436          mode.mutate(mutation, event.info);
4437        });
4438        var on = function () {
4439          active = true;
4440        };
4441        var off = function () {
4442          active = false;
4443        };
4444        var runIfActive = function (f) {
4445          return function () {
4446            var args = [];
4447            for (var _i = 0; _i < arguments.length; _i++) {
4448              args[_i] = arguments[_i];
4449            }
4450            if (active) {
4451              f.apply(null, args);
4452            }
4453          };
4454        };
4455        var sink = mode.sink(DragApi({
4456          forceDrop: drop,
4457          drop: runIfActive(drop),
4458          move: runIfActive(mousemove),
4459          delayDrop: runIfActive(throttledDrop.throttle)
4460        }), settings);
4461        var destroy = function () {
4462          sink.destroy();
4463        };
4464        return {
4465          element: sink.element,
4466          go: go,
4467          on: on,
4468          off: off,
4469          destroy: destroy,
4470          events: events.registry
4471        };
4472      };
4473  
4474      var mkEvent = function (target, x, y, stop, prevent, kill, raw) {
4475        return {
4476          target: target,
4477          x: x,
4478          y: y,
4479          stop: stop,
4480          prevent: prevent,
4481          kill: kill,
4482          raw: raw
4483        };
4484      };
4485      var fromRawEvent$1 = function (rawEvent) {
4486        var target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target));
4487        var stop = function () {
4488          return rawEvent.stopPropagation();
4489        };
4490        var prevent = function () {
4491          return rawEvent.preventDefault();
4492        };
4493        var kill = compose(prevent, stop);
4494        return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent);
4495      };
4496      var handle$2 = function (filter, handler) {
4497        return function (rawEvent) {
4498          if (filter(rawEvent)) {
4499            handler(fromRawEvent$1(rawEvent));
4500          }
4501        };
4502      };
4503      var binder = function (element, event, filter, handler, useCapture) {
4504        var wrapped = handle$2(filter, handler);
4505        element.dom.addEventListener(event, wrapped, useCapture);
4506        return { unbind: curry(unbind, element, event, wrapped, useCapture) };
4507      };
4508      var bind$1 = function (element, event, filter, handler) {
4509        return binder(element, event, filter, handler, false);
4510      };
4511      var unbind = function (element, event, handler, useCapture) {
4512        element.dom.removeEventListener(event, handler, useCapture);
4513      };
4514  
4515      var filter = always;
4516      var bind = function (element, event, handler) {
4517        return bind$1(element, event, filter, handler);
4518      };
4519      var fromRawEvent = fromRawEvent$1;
4520  
4521      var read = function (element, attr) {
4522        var value = get$b(element, attr);
4523        return value === undefined || value === '' ? [] : value.split(' ');
4524      };
4525      var add$2 = function (element, attr, id) {
4526        var old = read(element, attr);
4527        var nu = old.concat([id]);
4528        set$2(element, attr, nu.join(' '));
4529        return true;
4530      };
4531      var remove$4 = function (element, attr, id) {
4532        var nu = filter$2(read(element, attr), function (v) {
4533          return v !== id;
4534        });
4535        if (nu.length > 0) {
4536          set$2(element, attr, nu.join(' '));
4537        } else {
4538          remove$7(element, attr);
4539        }
4540        return false;
4541      };
4542  
4543      var supports = function (element) {
4544        return element.dom.classList !== undefined;
4545      };
4546      var get$5 = function (element) {
4547        return read(element, 'class');
4548      };
4549      var add$1 = function (element, clazz) {
4550        return add$2(element, 'class', clazz);
4551      };
4552      var remove$3 = function (element, clazz) {
4553        return remove$4(element, 'class', clazz);
4554      };
4555  
4556      var add = function (element, clazz) {
4557        if (supports(element)) {
4558          element.dom.classList.add(clazz);
4559        } else {
4560          add$1(element, clazz);
4561        }
4562      };
4563      var cleanClass = function (element) {
4564        var classList = supports(element) ? element.dom.classList : get$5(element);
4565        if (classList.length === 0) {
4566          remove$7(element, 'class');
4567        }
4568      };
4569      var remove$2 = function (element, clazz) {
4570        if (supports(element)) {
4571          var classList = element.dom.classList;
4572          classList.remove(clazz);
4573        } else {
4574          remove$3(element, clazz);
4575        }
4576        cleanClass(element);
4577      };
4578      var has = function (element, clazz) {
4579        return supports(element) && element.dom.classList.contains(clazz);
4580      };
4581  
4582      var css = function (namespace) {
4583        var dashNamespace = namespace.replace(/\./g, '-');
4584        var resolve = function (str) {
4585          return dashNamespace + '-' + str;
4586        };
4587        return { resolve: resolve };
4588      };
4589  
4590      var styles$1 = css('ephox-dragster');
4591      var resolve$1 = styles$1.resolve;
4592  
4593      var Blocker = function (options) {
4594        var settings = __assign({ layerClass: resolve$1('blocker') }, options);
4595        var div = SugarElement.fromTag('div');
4596        set$2(div, 'role', 'presentation');
4597        setAll(div, {
4598          position: 'fixed',
4599          left: '0px',
4600          top: '0px',
4601          width: '100%',
4602          height: '100%'
4603        });
4604        add(div, resolve$1('blocker'));
4605        add(div, settings.layerClass);
4606        var element = constant(div);
4607        var destroy = function () {
4608          remove$5(div);
4609        };
4610        return {
4611          element: element,
4612          destroy: destroy
4613        };
4614      };
4615  
4616      var compare = function (old, nu) {
4617        return SugarPosition(nu.left - old.left, nu.top - old.top);
4618      };
4619      var extract = function (event) {
4620        return Optional.some(SugarPosition(event.x, event.y));
4621      };
4622      var mutate = function (mutation, info) {
4623        mutation.mutate(info.left, info.top);
4624      };
4625      var sink = function (dragApi, settings) {
4626        var blocker = Blocker(settings);
4627        var mdown = bind(blocker.element(), 'mousedown', dragApi.forceDrop);
4628        var mup = bind(blocker.element(), 'mouseup', dragApi.drop);
4629        var mmove = bind(blocker.element(), 'mousemove', dragApi.move);
4630        var mout = bind(blocker.element(), 'mouseout', dragApi.delayDrop);
4631        var destroy = function () {
4632          blocker.destroy();
4633          mup.unbind();
4634          mmove.unbind();
4635          mout.unbind();
4636          mdown.unbind();
4637        };
4638        var start = function (parent) {
4639          append$1(parent, blocker.element());
4640        };
4641        var stop = function () {
4642          remove$5(blocker.element());
4643        };
4644        return DragSink({
4645          element: blocker.element,
4646          start: start,
4647          stop: stop,
4648          destroy: destroy
4649        });
4650      };
4651      var MouseDrag = DragMode({
4652        compare: compare,
4653        extract: extract,
4654        sink: sink,
4655        mutate: mutate
4656      });
4657  
4658      var transform$1 = function (mutation, settings) {
4659        if (settings === void 0) {
4660          settings = {};
4661        }
4662        var mode = settings.mode !== undefined ? settings.mode : MouseDrag;
4663        return setup(mutation, mode, settings);
4664      };
4665  
4666      var closest = function (target) {
4667        return closest$1(target, '[contenteditable]');
4668      };
4669      var isEditable$1 = function (element, assumeEditable) {
4670        if (assumeEditable === void 0) {
4671          assumeEditable = false;
4672        }
4673        if (!detect$3().browser.isIE() && inBody(element)) {
4674          return element.dom.isContentEditable;
4675        } else {
4676          return closest(element).fold(constant(assumeEditable), function (editable) {
4677            return getRaw(editable) === 'true';
4678          });
4679        }
4680      };
4681      var getRaw = function (element) {
4682        return element.dom.contentEditable;
4683      };
4684  
4685      var styles = css('ephox-snooker');
4686      var resolve = styles.resolve;
4687  
4688      var Mutation = function () {
4689        var events = create$4({
4690          drag: Event([
4691            'xDelta',
4692            'yDelta'
4693          ])
4694        });
4695        var mutate = function (x, y) {
4696          events.trigger.drag(x, y);
4697        };
4698        return {
4699          mutate: mutate,
4700          events: events.registry
4701        };
4702      };
4703  
4704      var BarMutation = function () {
4705        var events = create$4({
4706          drag: Event([
4707            'xDelta',
4708            'yDelta',
4709            'target'
4710          ])
4711        });
4712        var target = Optional.none();
4713        var delegate = Mutation();
4714        delegate.events.drag.bind(function (event) {
4715          target.each(function (t) {
4716            events.trigger.drag(event.xDelta, event.yDelta, t);
4717          });
4718        });
4719        var assign = function (t) {
4720          target = Optional.some(t);
4721        };
4722        var get = function () {
4723          return target;
4724        };
4725        return {
4726          assign: assign,
4727          get: get,
4728          mutate: delegate.mutate,
4729          events: events.registry
4730        };
4731      };
4732  
4733      var col = function (column, x, y, w, h) {
4734        var bar = SugarElement.fromTag('div');
4735        setAll(bar, {
4736          position: 'absolute',
4737          left: x - w / 2 + 'px',
4738          top: y + 'px',
4739          height: h + 'px',
4740          width: w + 'px'
4741        });
4742        setAll$1(bar, {
4743          'data-column': column,
4744          'role': 'presentation'
4745        });
4746        return bar;
4747      };
4748      var row = function (r, x, y, w, h) {
4749        var bar = SugarElement.fromTag('div');
4750        setAll(bar, {
4751          position: 'absolute',
4752          left: x + 'px',
4753          top: y - h / 2 + 'px',
4754          height: h + 'px',
4755          width: w + 'px'
4756        });
4757        setAll$1(bar, {
4758          'data-row': r,
4759          'role': 'presentation'
4760        });
4761        return bar;
4762      };
4763  
4764      var resizeBar = resolve('resizer-bar');
4765      var resizeRowBar = resolve('resizer-rows');
4766      var resizeColBar = resolve('resizer-cols');
4767      var BAR_THICKNESS = 7;
4768      var resizableRows = function (warehouse, isResizable) {
4769        return bind$2(warehouse.all, function (row, i) {
4770          return isResizable(row.element) ? [i] : [];
4771        });
4772      };
4773      var resizableColumns = function (warehouse, isResizable) {
4774        var resizableCols = [];
4775        range$1(warehouse.grid.columns, function (index) {
4776          var colElmOpt = Warehouse.getColumnAt(warehouse, index).map(function (col) {
4777            return col.element;
4778          });
4779          if (colElmOpt.forall(isResizable)) {
4780            resizableCols.push(index);
4781          }
4782        });
4783        return filter$2(resizableCols, function (colIndex) {
4784          var columnCells = Warehouse.filterItems(warehouse, function (cell) {
4785            return cell.column === colIndex;
4786          });
4787          return forall(columnCells, function (cell) {
4788            return isResizable(cell.element);
4789          });
4790        });
4791      };
4792      var destroy = function (wire) {
4793        var previous = descendants(wire.parent(), '.' + resizeBar);
4794        each$2(previous, remove$5);
4795      };
4796      var drawBar = function (wire, positions, create) {
4797        var origin = wire.origin();
4798        each$2(positions, function (cpOption) {
4799          cpOption.each(function (cp) {
4800            var bar = create(origin, cp);
4801            add(bar, resizeBar);
4802            append$1(wire.parent(), bar);
4803          });
4804        });
4805      };
4806      var refreshCol = function (wire, colPositions, position, tableHeight) {
4807        drawBar(wire, colPositions, function (origin, cp) {
4808          var colBar = col(cp.col, cp.x - origin.left, position.top - origin.top, BAR_THICKNESS, tableHeight);
4809          add(colBar, resizeColBar);
4810          return colBar;
4811        });
4812      };
4813      var refreshRow = function (wire, rowPositions, position, tableWidth) {
4814        drawBar(wire, rowPositions, function (origin, cp) {
4815          var rowBar = row(cp.row, position.left - origin.left, cp.y - origin.top, tableWidth, BAR_THICKNESS);
4816          add(rowBar, resizeRowBar);
4817          return rowBar;
4818        });
4819      };
4820      var refreshGrid = function (warhouse, wire, table, rows, cols) {
4821        var position = absolute(table);
4822        var isResizable = wire.isResizable;
4823        var rowPositions = rows.length > 0 ? height.positions(rows, table) : [];
4824        var resizableRowBars = rowPositions.length > 0 ? resizableRows(warhouse, isResizable) : [];
4825        var resizableRowPositions = filter$2(rowPositions, function (_pos, i) {
4826          return exists(resizableRowBars, function (barIndex) {
4827            return i === barIndex;
4828          });
4829        });
4830        refreshRow(wire, resizableRowPositions, position, getOuter$2(table));
4831        var colPositions = cols.length > 0 ? width.positions(cols, table) : [];
4832        var resizableColBars = colPositions.length > 0 ? resizableColumns(warhouse, isResizable) : [];
4833        var resizableColPositions = filter$2(colPositions, function (_pos, i) {
4834          return exists(resizableColBars, function (barIndex) {
4835            return i === barIndex;
4836          });
4837        });
4838        refreshCol(wire, resizableColPositions, position, getOuter$1(table));
4839      };
4840      var refresh = function (wire, table) {
4841        destroy(wire);
4842        if (wire.isResizable(table)) {
4843          var warehouse = Warehouse.fromTable(table);
4844          var rows$1 = rows(warehouse);
4845          var cols = columns(warehouse);
4846          refreshGrid(warehouse, wire, table, rows$1, cols);
4847        }
4848      };
4849      var each = function (wire, f) {
4850        var bars = descendants(wire.parent(), '.' + resizeBar);
4851        each$2(bars, f);
4852      };
4853      var hide = function (wire) {
4854        each(wire, function (bar) {
4855          set$1(bar, 'display', 'none');
4856        });
4857      };
4858      var show = function (wire) {
4859        each(wire, function (bar) {
4860          set$1(bar, 'display', 'block');
4861        });
4862      };
4863      var isRowBar = function (element) {
4864        return has(element, resizeRowBar);
4865      };
4866      var isColBar = function (element) {
4867        return has(element, resizeColBar);
4868      };
4869  
4870      var resizeBarDragging = resolve('resizer-bar-dragging');
4871      var BarManager = function (wire) {
4872        var mutation = BarMutation();
4873        var resizing = transform$1(mutation, {});
4874        var hoverTable = Optional.none();
4875        var getResizer = function (element, type) {
4876          return Optional.from(get$b(element, type));
4877        };
4878        mutation.events.drag.bind(function (event) {
4879          getResizer(event.target, 'data-row').each(function (_dataRow) {
4880            var currentRow = getCssValue(event.target, 'top');
4881            set$1(event.target, 'top', currentRow + event.yDelta + 'px');
4882          });
4883          getResizer(event.target, 'data-column').each(function (_dataCol) {
4884            var currentCol = getCssValue(event.target, 'left');
4885            set$1(event.target, 'left', currentCol + event.xDelta + 'px');
4886          });
4887        });
4888        var getDelta = function (target, dir) {
4889          var newX = getCssValue(target, dir);
4890          var oldX = getAttrValue(target, 'data-initial-' + dir, 0);
4891          return newX - oldX;
4892        };
4893        resizing.events.stop.bind(function () {
4894          mutation.get().each(function (target) {
4895            hoverTable.each(function (table) {
4896              getResizer(target, 'data-row').each(function (row) {
4897                var delta = getDelta(target, 'top');
4898                remove$7(target, 'data-initial-top');
4899                events.trigger.adjustHeight(table, delta, parseInt(row, 10));
4900              });
4901              getResizer(target, 'data-column').each(function (column) {
4902                var delta = getDelta(target, 'left');
4903                remove$7(target, 'data-initial-left');
4904                events.trigger.adjustWidth(table, delta, parseInt(column, 10));
4905              });
4906              refresh(wire, table);
4907            });
4908          });
4909        });
4910        var handler = function (target, dir) {
4911          events.trigger.startAdjust();
4912          mutation.assign(target);
4913          set$2(target, 'data-initial-' + dir, getCssValue(target, dir));
4914          add(target, resizeBarDragging);
4915          set$1(target, 'opacity', '0.2');
4916          resizing.go(wire.parent());
4917        };
4918        var mousedown = bind(wire.parent(), 'mousedown', function (event) {
4919          if (isRowBar(event.target)) {
4920            handler(event.target, 'top');
4921          }
4922          if (isColBar(event.target)) {
4923            handler(event.target, 'left');
4924          }
4925        });
4926        var isRoot = function (e) {
4927          return eq$1(e, wire.view());
4928        };
4929        var findClosestEditableTable = function (target) {
4930          return closest$1(target, 'table', isRoot).filter(isEditable$1);
4931        };
4932        var mouseover = bind(wire.view(), 'mouseover', function (event) {
4933          findClosestEditableTable(event.target).fold(function () {
4934            if (inBody(event.target)) {
4935              destroy(wire);
4936            }
4937          }, function (table) {
4938            hoverTable = Optional.some(table);
4939            refresh(wire, table);
4940          });
4941        });
4942        var destroy$1 = function () {
4943          mousedown.unbind();
4944          mouseover.unbind();
4945          resizing.destroy();
4946          destroy(wire);
4947        };
4948        var refresh$1 = function (tbl) {
4949          refresh(wire, tbl);
4950        };
4951        var events = create$4({
4952          adjustHeight: Event([
4953            'table',
4954            'delta',
4955            'row'
4956          ]),
4957          adjustWidth: Event([
4958            'table',
4959            'delta',
4960            'column'
4961          ]),
4962          startAdjust: Event([])
4963        });
4964        return {
4965          destroy: destroy$1,
4966          refresh: refresh$1,
4967          on: resizing.on,
4968          off: resizing.off,
4969          hideBars: curry(hide, wire),
4970          showBars: curry(show, wire),
4971          events: events.registry
4972        };
4973      };
4974  
4975      var create$3 = function (wire, resizing, lazySizing) {
4976        var hdirection = height;
4977        var vdirection = width;
4978        var manager = BarManager(wire);
4979        var events = create$4({
4980          beforeResize: Event([
4981            'table',
4982            'type'
4983          ]),
4984          afterResize: Event([
4985            'table',
4986            'type'
4987          ]),
4988          startDrag: Event([])
4989        });
4990        manager.events.adjustHeight.bind(function (event) {
4991          var table = event.table;
4992          events.trigger.beforeResize(table, 'row');
4993          var delta = hdirection.delta(event.delta, table);
4994          adjustHeight(table, delta, event.row, hdirection);
4995          events.trigger.afterResize(table, 'row');
4996        });
4997        manager.events.startAdjust.bind(function (_event) {
4998          events.trigger.startDrag();
4999        });
5000        manager.events.adjustWidth.bind(function (event) {
5001          var table = event.table;
5002          events.trigger.beforeResize(table, 'col');
5003          var delta = vdirection.delta(event.delta, table);
5004          var tableSize = lazySizing(table);
5005          adjustWidth(table, delta, event.column, resizing, tableSize);
5006          events.trigger.afterResize(table, 'col');
5007        });
5008        return {
5009          on: manager.on,
5010          off: manager.off,
5011          hideBars: manager.hideBars,
5012          showBars: manager.showBars,
5013          destroy: manager.destroy,
5014          events: events.registry
5015        };
5016      };
5017      var TableResize = { create: create$3 };
5018  
5019      var fireNewRow = function (editor, row) {
5020        return editor.fire('newrow', { node: row });
5021      };
5022      var fireNewCell = function (editor, cell) {
5023        return editor.fire('newcell', { node: cell });
5024      };
5025      var fireObjectResizeStart = function (editor, target, width, height, origin) {
5026        editor.fire('ObjectResizeStart', {
5027          target: target,
5028          width: width,
5029          height: height,
5030          origin: origin
5031        });
5032      };
5033      var fireObjectResized = function (editor, target, width, height, origin) {
5034        editor.fire('ObjectResized', {
5035          target: target,
5036          width: width,
5037          height: height,
5038          origin: origin
5039        });
5040      };
5041      var fireTableSelectionChange = function (editor, cells, start, finish, otherCells) {
5042        editor.fire('TableSelectionChange', {
5043          cells: cells,
5044          start: start,
5045          finish: finish,
5046          otherCells: otherCells
5047        });
5048      };
5049      var fireTableSelectionClear = function (editor) {
5050        editor.fire('TableSelectionClear');
5051      };
5052      var fireTableModified = function (editor, table, data) {
5053        editor.fire('TableModified', __assign(__assign({}, data), { table: table }));
5054      };
5055      var styleModified = {
5056        structure: false,
5057        style: true
5058      };
5059      var structureModified = {
5060        structure: true,
5061        style: false
5062      };
5063      var styleAndStructureModified = {
5064        structure: true,
5065        style: true
5066      };
5067  
5068      var defaultTableToolbar = 'tableprops tabledelete | tableinsertrowbefore tableinsertrowafter tabledeleterow | tableinsertcolbefore tableinsertcolafter tabledeletecol';
5069      var defaultStyles = {
5070        'border-collapse': 'collapse',
5071        'width': '100%'
5072      };
5073      var defaultCellBorderWidths = range$1(5, function (i) {
5074        var size = i + 1 + 'px';
5075        return {
5076          title: size,
5077          value: size
5078        };
5079      });
5080      var defaultCellBorderStyles = map$1([
5081        'Solid',
5082        'Dotted',
5083        'Dashed',
5084        'Double',
5085        'Groove',
5086        'Ridge',
5087        'Inset',
5088        'Outset',
5089        'None',
5090        'Hidden'
5091      ], function (type) {
5092        return {
5093          title: type,
5094          value: type.toLowerCase()
5095        };
5096      });
5097      var determineDefaultStyles = function (editor) {
5098        var _a;
5099        if (isPixelsForced(editor)) {
5100          var dom = editor.dom;
5101          var parentBlock = (_a = dom.getParent(editor.selection.getStart(), dom.isBlock)) !== null && _a !== void 0 ? _a : editor.getBody();
5102          var contentWidth = getInner(SugarElement.fromDom(parentBlock));
5103          return __assign(__assign({}, defaultStyles), { width: contentWidth + 'px' });
5104        } else if (isResponsiveForced(editor)) {
5105          return filter$1(defaultStyles, function (_value, key) {
5106            return key !== 'width';
5107          });
5108        } else {
5109          return defaultStyles;
5110        }
5111      };
5112      var defaultAttributes = { border: '1' };
5113      var defaultColumnResizingBehaviour = 'preservetable';
5114      var getTableSizingMode = function (editor) {
5115        return editor.getParam('table_sizing_mode', 'auto');
5116      };
5117      var getTableResponseWidth = function (editor) {
5118        return editor.getParam('table_responsive_width');
5119      };
5120      var getTableBorderWidths = function (editor) {
5121        return editor.getParam('table_border_widths', defaultCellBorderWidths, 'array');
5122      };
5123      var getTableBorderStyles = function (editor) {
5124        return editor.getParam('table_border_styles', defaultCellBorderStyles, 'array');
5125      };
5126      var getDefaultAttributes = function (editor) {
5127        return editor.getParam('table_default_attributes', defaultAttributes, 'object');
5128      };
5129      var getDefaultStyles = function (editor) {
5130        return editor.getParam('table_default_styles', determineDefaultStyles(editor), 'object');
5131      };
5132      var hasTableResizeBars = function (editor) {
5133        return editor.getParam('table_resize_bars', true, 'boolean');
5134      };
5135      var hasTabNavigation = function (editor) {
5136        return editor.getParam('table_tab_navigation', true, 'boolean');
5137      };
5138      var hasAdvancedCellTab = function (editor) {
5139        return editor.getParam('table_cell_advtab', true, 'boolean');
5140      };
5141      var hasAdvancedRowTab = function (editor) {
5142        return editor.getParam('table_row_advtab', true, 'boolean');
5143      };
5144      var hasAdvancedTableTab = function (editor) {
5145        return editor.getParam('table_advtab', true, 'boolean');
5146      };
5147      var hasAppearanceOptions = function (editor) {
5148        return editor.getParam('table_appearance_options', true, 'boolean');
5149      };
5150      var hasTableGrid = function (editor) {
5151        return editor.getParam('table_grid', true, 'boolean');
5152      };
5153      var shouldStyleWithCss = function (editor) {
5154        return editor.getParam('table_style_by_css', false, 'boolean');
5155      };
5156      var getCellClassList = function (editor) {
5157        return editor.getParam('table_cell_class_list', [], 'array');
5158      };
5159      var getRowClassList = function (editor) {
5160        return editor.getParam('table_row_class_list', [], 'array');
5161      };
5162      var getTableClassList = function (editor) {
5163        return editor.getParam('table_class_list', [], 'array');
5164      };
5165      var isPercentagesForced = function (editor) {
5166        return getTableSizingMode(editor) === 'relative' || getTableResponseWidth(editor) === true;
5167      };
5168      var isPixelsForced = function (editor) {
5169        return getTableSizingMode(editor) === 'fixed' || getTableResponseWidth(editor) === false;
5170      };
5171      var isResponsiveForced = function (editor) {
5172        return getTableSizingMode(editor) === 'responsive';
5173      };
5174      var getToolbar = function (editor) {
5175        return editor.getParam('table_toolbar', defaultTableToolbar);
5176      };
5177      var useColumnGroup = function (editor) {
5178        return editor.getParam('table_use_colgroups', false, 'boolean');
5179      };
5180      var getTableHeaderType = function (editor) {
5181        var defaultValue = 'section';
5182        var value = editor.getParam('table_header_type', defaultValue, 'string');
5183        var validValues = [
5184          'section',
5185          'cells',
5186          'sectionCells',
5187          'auto'
5188        ];
5189        if (!contains$2(validValues, value)) {
5190          return defaultValue;
5191        } else {
5192          return value;
5193        }
5194      };
5195      var getColumnResizingBehaviour = function (editor) {
5196        var validModes = [
5197          'preservetable',
5198          'resizetable'
5199        ];
5200        var givenMode = editor.getParam('table_column_resizing', defaultColumnResizingBehaviour, 'string');
5201        return find$1(validModes, function (mode) {
5202          return mode === givenMode;
5203        }).getOr(defaultColumnResizingBehaviour);
5204      };
5205      var isPreserveTableColumnResizing = function (editor) {
5206        return getColumnResizingBehaviour(editor) === 'preservetable';
5207      };
5208      var isResizeTableColumnResizing = function (editor) {
5209        return getColumnResizingBehaviour(editor) === 'resizetable';
5210      };
5211      var getCloneElements = function (editor) {
5212        var cloneElements = editor.getParam('table_clone_elements');
5213        if (isString(cloneElements)) {
5214          return Optional.some(cloneElements.split(/[ ,]/));
5215        } else if (Array.isArray(cloneElements)) {
5216          return Optional.some(cloneElements);
5217        } else {
5218          return Optional.none();
5219        }
5220      };
5221      var hasObjectResizing = function (editor) {
5222        var objectResizing = editor.getParam('object_resizing', true);
5223        return isString(objectResizing) ? objectResizing === 'table' : objectResizing;
5224      };
5225      var getTableBackgroundColorMap = function (editor) {
5226        return editor.getParam('table_background_color_map', [], 'array');
5227      };
5228      var getTableBorderColorMap = function (editor) {
5229        return editor.getParam('table_border_color_map', [], 'array');
5230      };
5231  
5232      var get$4 = function (editor, table) {
5233        if (isPercentagesForced(editor)) {
5234          return TableSize.percentageSize(table);
5235        } else if (isPixelsForced(editor)) {
5236          return TableSize.pixelSize(table);
5237        } else {
5238          return TableSize.getTableSize(table);
5239        }
5240      };
5241  
5242      var cleanupLegacyAttributes = function (element) {
5243        remove$7(element, 'width');
5244      };
5245      var convertToPercentSize = function (table) {
5246        var newWidth = getPercentTableWidth(table);
5247        redistribute(table, Optional.some(newWidth), Optional.none());
5248        cleanupLegacyAttributes(table);
5249      };
5250      var convertToPixelSize = function (table) {
5251        var newWidth = getPixelTableWidth(table);
5252        redistribute(table, Optional.some(newWidth), Optional.none());
5253        cleanupLegacyAttributes(table);
5254      };
5255      var convertToNoneSize = function (table) {
5256        remove$6(table, 'width');
5257        var columns = columns$1(table);
5258        var rowElements = columns.length > 0 ? columns : cells$1(table);
5259        each$2(rowElements, function (cell) {
5260          remove$6(cell, 'width');
5261          cleanupLegacyAttributes(cell);
5262        });
5263        cleanupLegacyAttributes(table);
5264      };
5265  
5266      var enforcePercentage = convertToPercentSize;
5267      var enforcePixels = convertToPixelSize;
5268      var enforceNone = convertToNoneSize;
5269      var syncPixels = function (table) {
5270        var warehouse = Warehouse.fromTable(table);
5271        if (!Warehouse.hasColumns(warehouse)) {
5272          each$2(cells$1(table), function (cell) {
5273            var computedWidth = get$a(cell, 'width');
5274            set$1(cell, 'width', computedWidth);
5275            remove$7(cell, 'width');
5276          });
5277        }
5278      };
5279  
5280      var createContainer = function () {
5281        var container = SugarElement.fromTag('div');
5282        setAll(container, {
5283          position: 'static',
5284          height: '0',
5285          width: '0',
5286          padding: '0',
5287          margin: '0',
5288          border: '0'
5289        });
5290        append$1(body$1(), container);
5291        return container;
5292      };
5293      var get$3 = function (editor, isResizable) {
5294        return editor.inline ? ResizeWire.body(getBody(editor), createContainer(), isResizable) : ResizeWire.only(SugarElement.fromDom(editor.getDoc()), isResizable);
5295      };
5296      var remove$1 = function (editor, wire) {
5297        if (editor.inline) {
5298          remove$5(wire.parent());
5299        }
5300      };
5301  
5302      var barResizerPrefix = 'bar-';
5303      var isResizable = function (elm) {
5304        return get$b(elm, 'data-mce-resize') !== 'false';
5305      };
5306      var getResizeHandler = function (editor) {
5307        var selectionRng = Optional.none();
5308        var resize = Optional.none();
5309        var wire = Optional.none();
5310        var startW;
5311        var startRawW;
5312        var isTable = function (elm) {
5313          return elm.nodeName === 'TABLE';
5314        };
5315        var lazyResize = function () {
5316          return resize;
5317        };
5318        var lazyWire = function () {
5319          return wire.getOr(ResizeWire.only(SugarElement.fromDom(editor.getBody()), isResizable));
5320        };
5321        var lazySizing = function (table) {
5322          return get$4(editor, table);
5323        };
5324        var lazyResizingBehaviour = function () {
5325          return isPreserveTableColumnResizing(editor) ? preserveTable() : resizeTable();
5326        };
5327        var getNumColumns = function (table) {
5328          return getGridSize(table).columns;
5329        };
5330        var afterCornerResize = function (table, origin, width) {
5331          var isRightEdgeResize = endsWith(origin, 'e');
5332          if (startRawW === '') {
5333            enforcePercentage(table);
5334          }
5335          if (width !== startW && startRawW !== '') {
5336            set$1(table, 'width', startRawW);
5337            var resizing = lazyResizingBehaviour();
5338            var tableSize = lazySizing(table);
5339            var col = isPreserveTableColumnResizing(editor) || isRightEdgeResize ? getNumColumns(table) - 1 : 0;
5340            adjustWidth(table, width - startW, col, resizing, tableSize);
5341          } else if (isPercentage$1(startRawW)) {
5342            var percentW = parseFloat(startRawW.replace('%', ''));
5343            var targetPercentW = width * percentW / startW;
5344            set$1(table, 'width', targetPercentW + '%');
5345          }
5346          if (isPixel(startRawW)) {
5347            syncPixels(table);
5348          }
5349        };
5350        var destroy = function () {
5351          resize.each(function (sz) {
5352            sz.destroy();
5353          });
5354          wire.each(function (w) {
5355            remove$1(editor, w);
5356          });
5357        };
5358        editor.on('init', function () {
5359          var rawWire = get$3(editor, isResizable);
5360          wire = Optional.some(rawWire);
5361          if (hasObjectResizing(editor) && hasTableResizeBars(editor)) {
5362            var resizing = lazyResizingBehaviour();
5363            var sz = TableResize.create(rawWire, resizing, lazySizing);
5364            sz.on();
5365            sz.events.startDrag.bind(function (_event) {
5366              selectionRng = Optional.some(editor.selection.getRng());
5367            });
5368            sz.events.beforeResize.bind(function (event) {
5369              var rawTable = event.table.dom;
5370              fireObjectResizeStart(editor, rawTable, getPixelWidth(rawTable), getPixelHeight(rawTable), barResizerPrefix + event.type);
5371            });
5372            sz.events.afterResize.bind(function (event) {
5373              var table = event.table;
5374              var rawTable = table.dom;
5375              removeDataStyle(table);
5376              selectionRng.each(function (rng) {
5377                editor.selection.setRng(rng);
5378                editor.focus();
5379              });
5380              fireObjectResized(editor, rawTable, getPixelWidth(rawTable), getPixelHeight(rawTable), barResizerPrefix + event.type);
5381              editor.undoManager.add();
5382            });
5383            resize = Optional.some(sz);
5384          }
5385        });
5386        editor.on('ObjectResizeStart', function (e) {
5387          var targetElm = e.target;
5388          if (isTable(targetElm)) {
5389            var table = SugarElement.fromDom(targetElm);
5390            each$2(editor.dom.select('.mce-clonedresizable'), function (clone) {
5391              editor.dom.addClass(clone, 'mce-' + getColumnResizingBehaviour(editor) + '-columns');
5392            });
5393            if (!isPixelSizing(table) && isPixelsForced(editor)) {
5394              enforcePixels(table);
5395            } else if (!isPercentSizing(table) && isPercentagesForced(editor)) {
5396              enforcePercentage(table);
5397            }
5398            if (isNoneSizing(table) && startsWith(e.origin, barResizerPrefix)) {
5399              enforcePercentage(table);
5400            }
5401            startW = e.width;
5402            startRawW = isResponsiveForced(editor) ? '' : getRawWidth(editor, targetElm).getOr('');
5403          }
5404        });
5405        editor.on('ObjectResized', function (e) {
5406          var targetElm = e.target;
5407          if (isTable(targetElm)) {
5408            var table = SugarElement.fromDom(targetElm);
5409            var origin_1 = e.origin;
5410            if (startsWith(origin_1, 'corner-')) {
5411              afterCornerResize(table, origin_1, e.width);
5412            }
5413            removeDataStyle(table);
5414            fireTableModified(editor, table.dom, styleModified);
5415          }
5416        });
5417        editor.on('SwitchMode', function () {
5418          lazyResize().each(function (resize) {
5419            if (editor.mode.isReadOnly()) {
5420              resize.hideBars();
5421            } else {
5422              resize.showBars();
5423            }
5424          });
5425        });
5426        return {
5427          lazyResize: lazyResize,
5428          lazyWire: lazyWire,
5429          destroy: destroy
5430        };
5431      };
5432  
5433      var point = function (element, offset) {
5434        return {
5435          element: element,
5436          offset: offset
5437        };
5438      };
5439  
5440      var scan$1 = function (universe, element, direction) {
5441        if (universe.property().isText(element) && universe.property().getText(element).trim().length === 0 || universe.property().isComment(element)) {
5442          return direction(element).bind(function (elem) {
5443            return scan$1(universe, elem, direction).orThunk(function () {
5444              return Optional.some(elem);
5445            });
5446          });
5447        } else {
5448          return Optional.none();
5449        }
5450      };
5451      var toEnd = function (universe, element) {
5452        if (universe.property().isText(element)) {
5453          return universe.property().getText(element).length;
5454        }
5455        var children = universe.property().children(element);
5456        return children.length;
5457      };
5458      var freefallRtl$2 = function (universe, element) {
5459        var candidate = scan$1(universe, element, universe.query().prevSibling).getOr(element);
5460        if (universe.property().isText(candidate)) {
5461          return point(candidate, toEnd(universe, candidate));
5462        }
5463        var children = universe.property().children(candidate);
5464        return children.length > 0 ? freefallRtl$2(universe, children[children.length - 1]) : point(candidate, toEnd(universe, candidate));
5465      };
5466  
5467      var freefallRtl$1 = freefallRtl$2;
5468  
5469      var universe$2 = DomUniverse();
5470      var freefallRtl = function (element) {
5471        return freefallRtl$1(universe$2, element);
5472      };
5473  
5474      var halve = function (main, other) {
5475        var colspan = getSpan(main, 'colspan');
5476        if (colspan === 1) {
5477          var width = getGenericWidth(main);
5478          width.each(function (w) {
5479            var newWidth = w.value / 2;
5480            setGenericWidth(main, newWidth, w.unit);
5481            setGenericWidth(other, newWidth, w.unit);
5482          });
5483        }
5484      };
5485  
5486      var isHeaderCell = isTag('th');
5487      var isHeaderCells = function (cells) {
5488        return forall(cells, function (cell) {
5489          return isHeaderCell(cell.element);
5490        });
5491      };
5492      var getRowHeaderType = function (isHeaderRow, isHeaderCells) {
5493        if (isHeaderRow && isHeaderCells) {
5494          return 'sectionCells';
5495        } else if (isHeaderRow) {
5496          return 'section';
5497        } else {
5498          return 'cells';
5499        }
5500      };
5501      var getRowType$1 = function (row) {
5502        var isHeaderRow = row.section === 'thead';
5503        var isHeaderCells = is(findCommonCellType(row.cells), 'th');
5504        if (isHeaderRow || isHeaderCells) {
5505          return {
5506            type: 'header',
5507            subType: getRowHeaderType(isHeaderRow, isHeaderCells)
5508          };
5509        } else if (row.section === 'tfoot') {
5510          return { type: 'footer' };
5511        } else {
5512          return { type: 'body' };
5513        }
5514      };
5515      var findCommonCellType = function (cells) {
5516        var headerCells = filter$2(cells, function (cell) {
5517          return isHeaderCell(cell.element);
5518        });
5519        if (headerCells.length === 0) {
5520          return Optional.some('td');
5521        } else if (headerCells.length === cells.length) {
5522          return Optional.some('th');
5523        } else {
5524          return Optional.none();
5525        }
5526      };
5527      var findCommonRowType = function (rows) {
5528        var rowTypes = map$1(rows, function (row) {
5529          return getRowType$1(row).type;
5530        });
5531        var hasHeader = contains$2(rowTypes, 'header');
5532        var hasFooter = contains$2(rowTypes, 'footer');
5533        if (!hasHeader && !hasFooter) {
5534          return Optional.some('body');
5535        } else {
5536          var hasBody = contains$2(rowTypes, 'body');
5537          if (hasHeader && !hasBody && !hasFooter) {
5538            return Optional.some('header');
5539          } else if (!hasHeader && !hasBody && hasFooter) {
5540            return Optional.some('footer');
5541          } else {
5542            return Optional.none();
5543          }
5544        }
5545      };
5546      var findTableRowHeaderType = function (warehouse) {
5547        return findMap(warehouse.all, function (row) {
5548          var rowType = getRowType$1(row);
5549          return rowType.type === 'header' ? Optional.from(rowType.subType) : Optional.none();
5550        });
5551      };
5552  
5553      var transformCell = function (cell, comparator, substitution) {
5554        return elementnew(substitution(cell.element, comparator), true, cell.isLocked);
5555      };
5556      var transformRow = function (row, section) {
5557        return row.section !== section ? rowcells(row.element, row.cells, section, row.isNew) : row;
5558      };
5559      var section = function () {
5560        return {
5561          transformRow: transformRow,
5562          transformCell: function (cell, comparator, substitution) {
5563            var newCell = substitution(cell.element, comparator);
5564            var fixedCell = name(newCell) !== 'td' ? mutate$1(newCell, 'td') : newCell;
5565            return elementnew(fixedCell, cell.isNew, cell.isLocked);
5566          }
5567        };
5568      };
5569      var sectionCells = function () {
5570        return {
5571          transformRow: transformRow,
5572          transformCell: transformCell
5573        };
5574      };
5575      var cells = function () {
5576        return {
5577          transformRow: function (row, section) {
5578            var newSection = section === 'thead' ? 'tbody' : section;
5579            return transformRow(row, newSection);
5580          },
5581          transformCell: transformCell
5582        };
5583      };
5584      var fallback = function () {
5585        return {
5586          transformRow: identity,
5587          transformCell: transformCell
5588        };
5589      };
5590      var getTableSectionType = function (table, fallback) {
5591        var warehouse = Warehouse.fromTable(table);
5592        var type = findTableRowHeaderType(warehouse).getOr(fallback);
5593        switch (type) {
5594        case 'section':
5595          return section();
5596        case 'sectionCells':
5597          return sectionCells();
5598        case 'cells':
5599          return cells();
5600        }
5601      };
5602      var TableSection = {
5603        getTableSectionType: getTableSectionType,
5604        section: section,
5605        sectionCells: sectionCells,
5606        cells: cells,
5607        fallback: fallback
5608      };
5609  
5610      var setIfNot = function (element, property, value, ignore) {
5611        if (value === ignore) {
5612          remove$7(element, property);
5613        } else {
5614          set$2(element, property, value);
5615        }
5616      };
5617      var insert$1 = function (table, selector, element) {
5618        last$2(children$1(table, selector)).fold(function () {
5619          return prepend(table, element);
5620        }, function (child) {
5621          return after$5(child, element);
5622        });
5623      };
5624      var generateSection = function (table, sectionName) {
5625        var section = child$1(table, sectionName).getOrThunk(function () {
5626          var newSection = SugarElement.fromTag(sectionName, owner(table).dom);
5627          if (sectionName === 'thead') {
5628            insert$1(table, 'caption,colgroup', newSection);
5629          } else if (sectionName === 'colgroup') {
5630            insert$1(table, 'caption', newSection);
5631          } else {
5632            append$1(table, newSection);
5633          }
5634          return newSection;
5635        });
5636        empty(section);
5637        return section;
5638      };
5639      var render$1 = function (table, grid) {
5640        var newRows = [];
5641        var newCells = [];
5642        var syncRows = function (gridSection) {
5643          return map$1(gridSection, function (row) {
5644            if (row.isNew) {
5645              newRows.push(row.element);
5646            }
5647            var tr = row.element;
5648            empty(tr);
5649            each$2(row.cells, function (cell) {
5650              if (cell.isNew) {
5651                newCells.push(cell.element);
5652              }
5653              setIfNot(cell.element, 'colspan', cell.colspan, 1);
5654              setIfNot(cell.element, 'rowspan', cell.rowspan, 1);
5655              append$1(tr, cell.element);
5656            });
5657            return tr;
5658          });
5659        };
5660        var syncColGroup = function (gridSection) {
5661          return bind$2(gridSection, function (colGroup) {
5662            return map$1(colGroup.cells, function (col) {
5663              setIfNot(col.element, 'span', col.colspan, 1);
5664              return col.element;
5665            });
5666          });
5667        };
5668        var renderSection = function (gridSection, sectionName) {
5669          var section = generateSection(table, sectionName);
5670          var sync = sectionName === 'colgroup' ? syncColGroup : syncRows;
5671          var sectionElems = sync(gridSection);
5672          append(section, sectionElems);
5673        };
5674        var removeSection = function (sectionName) {
5675          child$1(table, sectionName).each(remove$5);
5676        };
5677        var renderOrRemoveSection = function (gridSection, sectionName) {
5678          if (gridSection.length > 0) {
5679            renderSection(gridSection, sectionName);
5680          } else {
5681            removeSection(sectionName);
5682          }
5683        };
5684        var headSection = [];
5685        var bodySection = [];
5686        var footSection = [];
5687        var columnGroupsSection = [];
5688        each$2(grid, function (row) {
5689          switch (row.section) {
5690          case 'thead':
5691            headSection.push(row);
5692            break;
5693          case 'tbody':
5694            bodySection.push(row);
5695            break;
5696          case 'tfoot':
5697            footSection.push(row);
5698            break;
5699          case 'colgroup':
5700            columnGroupsSection.push(row);
5701            break;
5702          }
5703        });
5704        renderOrRemoveSection(columnGroupsSection, 'colgroup');
5705        renderOrRemoveSection(headSection, 'thead');
5706        renderOrRemoveSection(bodySection, 'tbody');
5707        renderOrRemoveSection(footSection, 'tfoot');
5708        return {
5709          newRows: newRows,
5710          newCells: newCells
5711        };
5712      };
5713      var copy = function (grid) {
5714        return map$1(grid, function (row) {
5715          var tr = shallow(row.element);
5716          each$2(row.cells, function (cell) {
5717            var clonedCell = deep(cell.element);
5718            setIfNot(clonedCell, 'colspan', cell.colspan, 1);
5719            setIfNot(clonedCell, 'rowspan', cell.rowspan, 1);
5720            append$1(tr, clonedCell);
5721          });
5722          return tr;
5723        });
5724      };
5725  
5726      var getColumn = function (grid, index) {
5727        return map$1(grid, function (row) {
5728          return getCell(row, index);
5729        });
5730      };
5731      var getRow = function (grid, index) {
5732        return grid[index];
5733      };
5734      var findDiff = function (xs, comp) {
5735        if (xs.length === 0) {
5736          return 0;
5737        }
5738        var first = xs[0];
5739        var index = findIndex(xs, function (x) {
5740          return !comp(first.element, x.element);
5741        });
5742        return index.getOr(xs.length);
5743      };
5744      var subgrid = function (grid, row, column, comparator) {
5745        var gridRow = getRow(grid, row);
5746        var isColRow = gridRow.section === 'colgroup';
5747        var colspan = findDiff(gridRow.cells.slice(column), comparator);
5748        var rowspan = isColRow ? 1 : findDiff(getColumn(grid.slice(row), column), comparator);
5749        return {
5750          colspan: colspan,
5751          rowspan: rowspan
5752        };
5753      };
5754  
5755      var toDetails = function (grid, comparator) {
5756        var seen = map$1(grid, function (row) {
5757          return map$1(row.cells, never);
5758        });
5759        var updateSeen = function (rowIndex, columnIndex, rowspan, colspan) {
5760          for (var row = rowIndex; row < rowIndex + rowspan; row++) {
5761            for (var column = columnIndex; column < columnIndex + colspan; column++) {
5762              seen[row][column] = true;
5763            }
5764          }
5765        };
5766        return map$1(grid, function (row, rowIndex) {
5767          var details = bind$2(row.cells, function (cell, columnIndex) {
5768            if (seen[rowIndex][columnIndex] === false) {
5769              var result = subgrid(grid, rowIndex, columnIndex, comparator);
5770              updateSeen(rowIndex, columnIndex, result.rowspan, result.colspan);
5771              return [detailnew(cell.element, result.rowspan, result.colspan, cell.isNew)];
5772            } else {
5773              return [];
5774            }
5775          });
5776          return rowdetailnew(row.element, details, row.section, row.isNew);
5777        });
5778      };
5779      var toGrid = function (warehouse, generators, isNew) {
5780        var grid = [];
5781        each$2(warehouse.colgroups, function (colgroup) {
5782          var colgroupCols = [];
5783          for (var columnIndex = 0; columnIndex < warehouse.grid.columns; columnIndex++) {
5784            var element = Warehouse.getColumnAt(warehouse, columnIndex).map(function (column) {
5785              return elementnew(column.element, isNew, false);
5786            }).getOrThunk(function () {
5787              return elementnew(generators.colGap(), true, false);
5788            });
5789            colgroupCols.push(element);
5790          }
5791          grid.push(rowcells(colgroup.element, colgroupCols, 'colgroup', isNew));
5792        });
5793        for (var rowIndex = 0; rowIndex < warehouse.grid.rows; rowIndex++) {
5794          var rowCells = [];
5795          for (var columnIndex = 0; columnIndex < warehouse.grid.columns; columnIndex++) {
5796            var element = Warehouse.getAt(warehouse, rowIndex, columnIndex).map(function (item) {
5797              return elementnew(item.element, isNew, item.isLocked);
5798            }).getOrThunk(function () {
5799              return elementnew(generators.gap(), true, false);
5800            });
5801            rowCells.push(element);
5802          }
5803          var rowDetail = warehouse.all[rowIndex];
5804          var row = rowcells(rowDetail.element, rowCells, rowDetail.section, isNew);
5805          grid.push(row);
5806        }
5807        return grid;
5808      };
5809  
5810      var fromWarehouse = function (warehouse, generators) {
5811        return toGrid(warehouse, generators, false);
5812      };
5813      var toDetailList = function (grid) {
5814        return toDetails(grid, eq$1);
5815      };
5816      var findInWarehouse = function (warehouse, element) {
5817        return findMap(warehouse.all, function (r) {
5818          return find$1(r.cells, function (e) {
5819            return eq$1(element, e.element);
5820          });
5821        });
5822      };
5823      var extractCells = function (warehouse, target, predicate) {
5824        var details = map$1(target.selection, function (cell$1) {
5825          return cell(cell$1).bind(function (lc) {
5826            return findInWarehouse(warehouse, lc);
5827          }).filter(predicate);
5828        });
5829        var cells = cat(details);
5830        return someIf(cells.length > 0, cells);
5831      };
5832      var run = function (operation, extract, adjustment, postAction, genWrappers) {
5833        return function (wire, table, target, generators, behaviours) {
5834          var warehouse = Warehouse.fromTable(table);
5835          var tableSection = Optional.from(behaviours === null || behaviours === void 0 ? void 0 : behaviours.section).getOrThunk(TableSection.fallback);
5836          var output = extract(warehouse, target).map(function (info) {
5837            var model = fromWarehouse(warehouse, generators);
5838            var result = operation(model, info, eq$1, genWrappers(generators), tableSection);
5839            var lockedColumns = getLockedColumnsFromGrid(result.grid);
5840            var grid = toDetailList(result.grid);
5841            return {
5842              info: info,
5843              grid: grid,
5844              cursor: result.cursor,
5845              lockedColumns: lockedColumns
5846            };
5847          });
5848          return output.bind(function (out) {
5849            var newElements = render$1(table, out.grid);
5850            var tableSizing = Optional.from(behaviours === null || behaviours === void 0 ? void 0 : behaviours.sizing).getOrThunk(function () {
5851              return TableSize.getTableSize(table);
5852            });
5853            var resizing = Optional.from(behaviours === null || behaviours === void 0 ? void 0 : behaviours.resize).getOrThunk(preserveTable);
5854            adjustment(table, out.grid, out.info, {
5855              sizing: tableSizing,
5856              resize: resizing,
5857              section: tableSection
5858            });
5859            postAction(table);
5860            refresh(wire, table);
5861            remove$7(table, LOCKED_COL_ATTR);
5862            if (out.lockedColumns.length > 0) {
5863              set$2(table, LOCKED_COL_ATTR, out.lockedColumns.join(','));
5864            }
5865            return Optional.some({
5866              cursor: out.cursor,
5867              newRows: newElements.newRows,
5868              newCells: newElements.newCells
5869            });
5870          });
5871        };
5872      };
5873      var onPaste = function (warehouse, target) {
5874        return cell(target.element).bind(function (cell) {
5875          return findInWarehouse(warehouse, cell).map(function (details) {
5876            var value = __assign(__assign({}, details), {
5877              generators: target.generators,
5878              clipboard: target.clipboard
5879            });
5880            return value;
5881          });
5882        });
5883      };
5884      var onPasteByEditor = function (warehouse, target) {
5885        return extractCells(warehouse, target, always).map(function (cells) {
5886          return {
5887            cells: cells,
5888            generators: target.generators,
5889            clipboard: target.clipboard
5890          };
5891        });
5892      };
5893      var onMergable = function (_warehouse, target) {
5894        return target.mergable;
5895      };
5896      var onUnmergable = function (_warehouse, target) {
5897        return target.unmergable;
5898      };
5899      var onCells = function (warehouse, target) {
5900        return extractCells(warehouse, target, always);
5901      };
5902      var onUnlockedCells = function (warehouse, target) {
5903        return extractCells(warehouse, target, function (detail) {
5904          return !detail.isLocked;
5905        });
5906      };
5907      var isUnlockedTableCell = function (warehouse, cell) {
5908        return findInWarehouse(warehouse, cell).exists(function (detail) {
5909          return !detail.isLocked;
5910        });
5911      };
5912      var allUnlocked = function (warehouse, cells) {
5913        return forall(cells, function (cell) {
5914          return isUnlockedTableCell(warehouse, cell);
5915        });
5916      };
5917      var onUnlockedMergable = function (warehouse, target) {
5918        return onMergable(warehouse, target).filter(function (mergeable) {
5919          return allUnlocked(warehouse, mergeable.cells);
5920        });
5921      };
5922      var onUnlockedUnmergable = function (warehouse, target) {
5923        return onUnmergable(warehouse, target).filter(function (cells) {
5924          return allUnlocked(warehouse, cells);
5925        });
5926      };
5927  
5928      var merge$2 = function (grid, bounds, comparator, substitution) {
5929        var rows = extractGridDetails(grid).rows;
5930        if (rows.length === 0) {
5931          return grid;
5932        }
5933        for (var i = bounds.startRow; i <= bounds.finishRow; i++) {
5934          for (var j = bounds.startCol; j <= bounds.finishCol; j++) {
5935            var row = rows[i];
5936            var isLocked = getCell(row, j).isLocked;
5937            mutateCell(row, j, elementnew(substitution(), false, isLocked));
5938          }
5939        }
5940        return grid;
5941      };
5942      var unmerge = function (grid, target, comparator, substitution) {
5943        var rows = extractGridDetails(grid).rows;
5944        var first = true;
5945        for (var i = 0; i < rows.length; i++) {
5946          for (var j = 0; j < cellLength(rows[0]); j++) {
5947            var row = rows[i];
5948            var currentCell = getCell(row, j);
5949            var currentCellElm = currentCell.element;
5950            var isToReplace = comparator(currentCellElm, target);
5951            if (isToReplace === true && first === false) {
5952              mutateCell(row, j, elementnew(substitution(), true, currentCell.isLocked));
5953            } else if (isToReplace === true) {
5954              first = false;
5955            }
5956          }
5957        }
5958        return grid;
5959      };
5960      var uniqueCells = function (row, comparator) {
5961        return foldl(row, function (rest, cell) {
5962          return exists(rest, function (currentCell) {
5963            return comparator(currentCell.element, cell.element);
5964          }) ? rest : rest.concat([cell]);
5965        }, []);
5966      };
5967      var splitCols = function (grid, index, comparator, substitution) {
5968        if (index > 0 && index < grid[0].cells.length) {
5969          each$2(grid, function (row) {
5970            var prevCell = row.cells[index - 1];
5971            var current = row.cells[index];
5972            var isToReplace = comparator(current.element, prevCell.element);
5973            if (isToReplace) {
5974              mutateCell(row, index, elementnew(substitution(), true, current.isLocked));
5975            }
5976          });
5977        }
5978        return grid;
5979      };
5980      var splitRows = function (grid, index, comparator, substitution) {
5981        var rows = extractGridDetails(grid).rows;
5982        if (index > 0 && index < rows.length) {
5983          var rowPrevCells = rows[index - 1].cells;
5984          var cells = uniqueCells(rowPrevCells, comparator);
5985          each$2(cells, function (cell) {
5986            var replacement = Optional.none();
5987            for (var i = index; i < rows.length; i++) {
5988              var _loop_1 = function (j) {
5989                var row = rows[i];
5990                var current = getCell(row, j);
5991                var isToReplace = comparator(current.element, cell.element);
5992                if (isToReplace) {
5993                  if (replacement.isNone()) {
5994                    replacement = Optional.some(substitution());
5995                  }
5996                  replacement.each(function (sub) {
5997                    mutateCell(row, j, elementnew(sub, true, current.isLocked));
5998                  });
5999                }
6000              };
6001              for (var j = 0; j < cellLength(rows[0]); j++) {
6002                _loop_1(j);
6003              }
6004            }
6005          });
6006        }
6007        return grid;
6008      };
6009  
6010      var value$1 = function (o) {
6011        var or = function (_opt) {
6012          return value$1(o);
6013        };
6014        var orThunk = function (_f) {
6015          return value$1(o);
6016        };
6017        var map = function (f) {
6018          return value$1(f(o));
6019        };
6020        var mapError = function (_f) {
6021          return value$1(o);
6022        };
6023        var each = function (f) {
6024          f(o);
6025        };
6026        var bind = function (f) {
6027          return f(o);
6028        };
6029        var fold = function (_, onValue) {
6030          return onValue(o);
6031        };
6032        var exists = function (f) {
6033          return f(o);
6034        };
6035        var forall = function (f) {
6036          return f(o);
6037        };
6038        var toOptional = function () {
6039          return Optional.some(o);
6040        };
6041        return {
6042          isValue: always,
6043          isError: never,
6044          getOr: constant(o),
6045          getOrThunk: constant(o),
6046          getOrDie: constant(o),
6047          or: or,
6048          orThunk: orThunk,
6049          fold: fold,
6050          map: map,
6051          mapError: mapError,
6052          each: each,
6053          bind: bind,
6054          exists: exists,
6055          forall: forall,
6056          toOptional: toOptional
6057        };
6058      };
6059      var error = function (message) {
6060        var getOrThunk = function (f) {
6061          return f();
6062        };
6063        var getOrDie = function () {
6064          return die(String(message))();
6065        };
6066        var or = identity;
6067        var orThunk = function (f) {
6068          return f();
6069        };
6070        var map = function (_f) {
6071          return error(message);
6072        };
6073        var mapError = function (f) {
6074          return error(f(message));
6075        };
6076        var bind = function (_f) {
6077          return error(message);
6078        };
6079        var fold = function (onError, _) {
6080          return onError(message);
6081        };
6082        return {
6083          isValue: never,
6084          isError: always,
6085          getOr: identity,
6086          getOrThunk: getOrThunk,
6087          getOrDie: getOrDie,
6088          or: or,
6089          orThunk: orThunk,
6090          fold: fold,
6091          map: map,
6092          mapError: mapError,
6093          each: noop,
6094          bind: bind,
6095          exists: never,
6096          forall: always,
6097          toOptional: Optional.none
6098        };
6099      };
6100      var fromOption = function (opt, err) {
6101        return opt.fold(function () {
6102          return error(err);
6103        }, value$1);
6104      };
6105      var Result = {
6106        value: value$1,
6107        error: error,
6108        fromOption: fromOption
6109      };
6110  
6111      var measure = function (startAddress, gridA, gridB) {
6112        if (startAddress.row >= gridA.length || startAddress.column > cellLength(gridA[0])) {
6113          return Result.error('invalid start address out of table bounds, row: ' + startAddress.row + ', column: ' + startAddress.column);
6114        }
6115        var rowRemainder = gridA.slice(startAddress.row);
6116        var colRemainder = rowRemainder[0].cells.slice(startAddress.column);
6117        var colRequired = cellLength(gridB[0]);
6118        var rowRequired = gridB.length;
6119        return Result.value({
6120          rowDelta: rowRemainder.length - rowRequired,
6121          colDelta: colRemainder.length - colRequired
6122        });
6123      };
6124      var measureWidth = function (gridA, gridB) {
6125        var colLengthA = cellLength(gridA[0]);
6126        var colLengthB = cellLength(gridB[0]);
6127        return {
6128          rowDelta: 0,
6129          colDelta: colLengthA - colLengthB
6130        };
6131      };
6132      var measureHeight = function (gridA, gridB) {
6133        var rowLengthA = gridA.length;
6134        var rowLengthB = gridB.length;
6135        return {
6136          rowDelta: rowLengthA - rowLengthB,
6137          colDelta: 0
6138        };
6139      };
6140      var generateElements = function (amount, row, generators, isLocked) {
6141        var generator = row.section === 'colgroup' ? generators.col : generators.cell;
6142        return range$1(amount, function (idx) {
6143          return elementnew(generator(), true, isLocked(idx));
6144        });
6145      };
6146      var rowFill = function (grid, amount, generators, lockedColumns) {
6147        var exampleRow = grid[grid.length - 1];
6148        return grid.concat(range$1(amount, function () {
6149          var generator = exampleRow.section === 'colgroup' ? generators.colgroup : generators.row;
6150          var row = clone$1(exampleRow, generator, identity);
6151          var elements = generateElements(row.cells.length, row, generators, function (idx) {
6152            return has$1(lockedColumns, idx.toString());
6153          });
6154          return setCells(row, elements);
6155        }));
6156      };
6157      var colFill = function (grid, amount, generators, startIndex) {
6158        return map$1(grid, function (row) {
6159          var newChildren = generateElements(amount, row, generators, never);
6160          return addCells(row, startIndex, newChildren);
6161        });
6162      };
6163      var lockedColFill = function (grid, generators, lockedColumns) {
6164        return map$1(grid, function (row) {
6165          return foldl(lockedColumns, function (acc, colNum) {
6166            var newChild = generateElements(1, row, generators, always)[0];
6167            return addCell(acc, colNum, newChild);
6168          }, row);
6169        });
6170      };
6171      var tailor = function (gridA, delta, generators) {
6172        var fillCols = delta.colDelta < 0 ? colFill : identity;
6173        var fillRows = delta.rowDelta < 0 ? rowFill : identity;
6174        var lockedColumns = getLockedColumnsFromGrid(gridA);
6175        var gridWidth = cellLength(gridA[0]);
6176        var isLastColLocked = exists(lockedColumns, function (locked) {
6177          return locked === gridWidth - 1;
6178        });
6179        var modifiedCols = fillCols(gridA, Math.abs(delta.colDelta), generators, isLastColLocked ? gridWidth - 1 : gridWidth);
6180        var newLockedColumns = getLockedColumnsFromGrid(modifiedCols);
6181        return fillRows(modifiedCols, Math.abs(delta.rowDelta), generators, mapToObject(newLockedColumns, always));
6182      };
6183  
6184      var isSpanning = function (grid, row, col, comparator) {
6185        var candidate = getCell(grid[row], col);
6186        var matching = curry(comparator, candidate.element);
6187        var currentRow = grid[row];
6188        return grid.length > 1 && cellLength(currentRow) > 1 && (col > 0 && matching(getCellElement(currentRow, col - 1)) || col < currentRow.cells.length - 1 && matching(getCellElement(currentRow, col + 1)) || row > 0 && matching(getCellElement(grid[row - 1], col)) || row < grid.length - 1 && matching(getCellElement(grid[row + 1], col)));
6189      };
6190      var mergeTables = function (startAddress, gridA, gridB, generator, comparator, lockedColumns) {
6191        var startRow = startAddress.row;
6192        var startCol = startAddress.column;
6193        var mergeHeight = gridB.length;
6194        var mergeWidth = cellLength(gridB[0]);
6195        var endRow = startRow + mergeHeight;
6196        var endCol = startCol + mergeWidth + lockedColumns.length;
6197        var lockedColumnObj = mapToObject(lockedColumns, always);
6198        for (var r = startRow; r < endRow; r++) {
6199          var skippedCol = 0;
6200          for (var c = startCol; c < endCol; c++) {
6201            if (lockedColumnObj[c]) {
6202              skippedCol++;
6203              continue;
6204            }
6205            if (isSpanning(gridA, r, c, comparator)) {
6206              unmerge(gridA, getCellElement(gridA[r], c), comparator, generator.cell);
6207            }
6208            var gridBColIndex = c - startCol - skippedCol;
6209            var newCell = getCell(gridB[r - startRow], gridBColIndex);
6210            var newCellElm = newCell.element;
6211            var replacement = generator.replace(newCellElm);
6212            mutateCell(gridA[r], c, elementnew(replacement, true, newCell.isLocked));
6213          }
6214        }
6215        return gridA;
6216      };
6217      var getValidStartAddress = function (currentStartAddress, grid, lockedColumns) {
6218        var gridColLength = cellLength(grid[0]);
6219        var adjustedRowAddress = extractGridDetails(grid).cols.length + currentStartAddress.row;
6220        var possibleColAddresses = range$1(gridColLength - currentStartAddress.column, function (num) {
6221          return num + currentStartAddress.column;
6222        });
6223        var validColAddress = find$1(possibleColAddresses, function (num) {
6224          return forall(lockedColumns, function (col) {
6225            return col !== num;
6226          });
6227        }).getOr(gridColLength - 1);
6228        return {
6229          row: adjustedRowAddress,
6230          column: validColAddress
6231        };
6232      };
6233      var getLockedColumnsWithinBounds = function (startAddress, grid, lockedColumns) {
6234        return filter$2(lockedColumns, function (colNum) {
6235          return colNum >= startAddress.column && colNum <= cellLength(grid[0]) + startAddress.column;
6236        });
6237      };
6238      var merge$1 = function (startAddress, gridA, gridB, generator, comparator) {
6239        var lockedColumns = getLockedColumnsFromGrid(gridA);
6240        var validStartAddress = getValidStartAddress(startAddress, gridA, lockedColumns);
6241        var gridBRows = extractGridDetails(gridB).rows;
6242        var lockedColumnsWithinBounds = getLockedColumnsWithinBounds(validStartAddress, gridBRows, lockedColumns);
6243        var result = measure(validStartAddress, gridA, gridBRows);
6244        return result.map(function (diff) {
6245          var delta = __assign(__assign({}, diff), { colDelta: diff.colDelta - lockedColumnsWithinBounds.length });
6246          var fittedGrid = tailor(gridA, delta, generator);
6247          var newLockedColumns = getLockedColumnsFromGrid(fittedGrid);
6248          var newLockedColumnsWithinBounds = getLockedColumnsWithinBounds(validStartAddress, gridBRows, newLockedColumns);
6249          return mergeTables(validStartAddress, fittedGrid, gridBRows, generator, comparator, newLockedColumnsWithinBounds);
6250        });
6251      };
6252      var insertCols = function (index, gridA, gridB, generator, comparator) {
6253        splitCols(gridA, index, comparator, generator.cell);
6254        var delta = measureHeight(gridB, gridA);
6255        var fittedNewGrid = tailor(gridB, delta, generator);
6256        var secondDelta = measureHeight(gridA, fittedNewGrid);
6257        var fittedOldGrid = tailor(gridA, secondDelta, generator);
6258        return map$1(fittedOldGrid, function (gridRow, i) {
6259          return addCells(gridRow, index, fittedNewGrid[i].cells);
6260        });
6261      };
6262      var insertRows = function (index, gridA, gridB, generator, comparator) {
6263        splitRows(gridA, index, comparator, generator.cell);
6264        var locked = getLockedColumnsFromGrid(gridA);
6265        var diff = measureWidth(gridA, gridB);
6266        var delta = __assign(__assign({}, diff), { colDelta: diff.colDelta - locked.length });
6267        var fittedOldGrid = tailor(gridA, delta, generator);
6268        var _a = extractGridDetails(fittedOldGrid), oldCols = _a.cols, oldRows = _a.rows;
6269        var newLocked = getLockedColumnsFromGrid(fittedOldGrid);
6270        var secondDiff = measureWidth(gridB, gridA);
6271        var secondDelta = __assign(__assign({}, secondDiff), { colDelta: secondDiff.colDelta + newLocked.length });
6272        var fittedGridB = lockedColFill(gridB, generator, newLocked);
6273        var fittedNewGrid = tailor(fittedGridB, secondDelta, generator);
6274        return oldCols.concat(oldRows.slice(0, index)).concat(fittedNewGrid).concat(oldRows.slice(index, oldRows.length));
6275      };
6276  
6277      var cloneRow = function (row, cloneCell, comparator, substitution) {
6278        return clone$1(row, function (elem) {
6279          return substitution(elem, comparator);
6280        }, cloneCell);
6281      };
6282      var insertRowAt = function (grid, index, example, comparator, substitution) {
6283        var _a = extractGridDetails(grid), rows = _a.rows, cols = _a.cols;
6284        var before = rows.slice(0, index);
6285        var after = rows.slice(index);
6286        var newRow = cloneRow(rows[example], function (ex, c) {
6287          var withinSpan = index > 0 && index < rows.length && comparator(getCellElement(rows[index - 1], c), getCellElement(rows[index], c));
6288          var ret = withinSpan ? getCell(rows[index], c) : elementnew(substitution(ex.element, comparator), true, ex.isLocked);
6289          return ret;
6290        }, comparator, substitution);
6291        return cols.concat(before).concat([newRow]).concat(after);
6292      };
6293      var getElementFor = function (row, column, section, withinSpan, example, comparator, substitution) {
6294        if (section === 'colgroup' || !withinSpan) {
6295          var cell = getCell(row, example);
6296          return elementnew(substitution(cell.element, comparator), true, false);
6297        } else {
6298          return getCell(row, column);
6299        }
6300      };
6301      var insertColumnAt = function (grid, index, example, comparator, substitution) {
6302        return map$1(grid, function (row) {
6303          var withinSpan = index > 0 && index < cellLength(row) && comparator(getCellElement(row, index - 1), getCellElement(row, index));
6304          var sub = getElementFor(row, index, row.section, withinSpan, example, comparator, substitution);
6305          return addCell(row, index, sub);
6306        });
6307      };
6308      var deleteColumnsAt = function (grid, columns) {
6309        return bind$2(grid, function (row) {
6310          var existingCells = row.cells;
6311          var cells = foldr(columns, function (acc, column) {
6312            return column >= 0 && column < acc.length ? acc.slice(0, column).concat(acc.slice(column + 1)) : acc;
6313          }, existingCells);
6314          return cells.length > 0 ? [rowcells(row.element, cells, row.section, row.isNew)] : [];
6315        });
6316      };
6317      var deleteRowsAt = function (grid, start, finish) {
6318        var _a = extractGridDetails(grid), rows = _a.rows, cols = _a.cols;
6319        return cols.concat(rows.slice(0, start)).concat(rows.slice(finish + 1));
6320      };
6321  
6322      var notInStartRow = function (grid, rowIndex, colIndex, comparator) {
6323        return getCellElement(grid[rowIndex], colIndex) !== undefined && (rowIndex > 0 && comparator(getCellElement(grid[rowIndex - 1], colIndex), getCellElement(grid[rowIndex], colIndex)));
6324      };
6325      var notInStartColumn = function (row, index, comparator) {
6326        return index > 0 && comparator(getCellElement(row, index - 1), getCellElement(row, index));
6327      };
6328      var isDuplicatedCell = function (grid, rowIndex, colIndex, comparator) {
6329        return notInStartRow(grid, rowIndex, colIndex, comparator) || notInStartColumn(grid[rowIndex], colIndex, comparator);
6330      };
6331      var rowReplacerPredicate = function (targetRow, columnHeaders) {
6332        var entireTableIsHeader = forall(columnHeaders, identity) && isHeaderCells(targetRow.cells);
6333        return entireTableIsHeader ? always : function (cell, _rowIndex, colIndex) {
6334          var type = name(cell.element);
6335          return !(type === 'th' && columnHeaders[colIndex]);
6336        };
6337      };
6338      var columnReplacePredicate = function (targetColumn, rowHeaders) {
6339        var entireTableIsHeader = forall(rowHeaders, identity) && isHeaderCells(targetColumn);
6340        return entireTableIsHeader ? always : function (cell, rowIndex, _colIndex) {
6341          var type = name(cell.element);
6342          return !(type === 'th' && rowHeaders[rowIndex]);
6343        };
6344      };
6345      var determineScope = function (applyScope, element, newScope, isInHeader) {
6346        var hasSpan = function (scope) {
6347          return scope === 'row' ? hasRowspan(element) : hasColspan(element);
6348        };
6349        var getScope = function (scope) {
6350          return hasSpan(scope) ? scope + 'group' : scope;
6351        };
6352        if (applyScope) {
6353          return isHeaderCell(element) ? getScope(newScope) : null;
6354        } else if (isInHeader && isHeaderCell(element)) {
6355          var oppositeScope = newScope === 'row' ? 'col' : 'row';
6356          return getScope(oppositeScope);
6357        } else {
6358          return null;
6359        }
6360      };
6361      var rowScopeGenerator = function (applyScope, columnHeaders) {
6362        return function (cell, rowIndex, columnIndex) {
6363          return Optional.some(determineScope(applyScope, cell.element, 'col', columnHeaders[columnIndex]));
6364        };
6365      };
6366      var columnScopeGenerator = function (applyScope, rowHeaders) {
6367        return function (cell, rowIndex) {
6368          return Optional.some(determineScope(applyScope, cell.element, 'row', rowHeaders[rowIndex]));
6369        };
6370      };
6371      var replace = function (cell, comparator, substitute) {
6372        return elementnew(substitute(cell.element, comparator), true, cell.isLocked);
6373      };
6374      var replaceIn = function (grid, targets, comparator, substitute, replacer, genScope, shouldReplace) {
6375        var isTarget = function (cell) {
6376          return exists(targets, function (target) {
6377            return comparator(cell.element, target.element);
6378          });
6379        };
6380        return map$1(grid, function (row, rowIndex) {
6381          return mapCells(row, function (cell, colIndex) {
6382            if (isTarget(cell)) {
6383              var newCell_1 = shouldReplace(cell, rowIndex, colIndex) ? replacer(cell, comparator, substitute) : cell;
6384              genScope(newCell_1, rowIndex, colIndex).each(function (scope) {
6385                setOptions(newCell_1.element, { scope: Optional.from(scope) });
6386              });
6387              return newCell_1;
6388            } else {
6389              return cell;
6390            }
6391          });
6392        });
6393      };
6394      var getColumnCells = function (rows, columnIndex, comparator) {
6395        return bind$2(rows, function (row, i) {
6396          return isDuplicatedCell(rows, i, columnIndex, comparator) ? [] : [getCell(row, columnIndex)];
6397        });
6398      };
6399      var getRowCells = function (rows, rowIndex, comparator) {
6400        var targetRow = rows[rowIndex];
6401        return bind$2(targetRow.cells, function (item, i) {
6402          return isDuplicatedCell(rows, rowIndex, i, comparator) ? [] : [item];
6403        });
6404      };
6405      var replaceColumns = function (grid, indexes, applyScope, comparator, substitution) {
6406        var rows = extractGridDetails(grid).rows;
6407        var targets = bind$2(indexes, function (index) {
6408          return getColumnCells(rows, index, comparator);
6409        });
6410        var rowHeaders = map$1(grid, function (row) {
6411          return isHeaderCells(row.cells);
6412        });
6413        var shouldReplaceCell = columnReplacePredicate(targets, rowHeaders);
6414        var scopeGenerator = columnScopeGenerator(applyScope, rowHeaders);
6415        return replaceIn(grid, targets, comparator, substitution, replace, scopeGenerator, shouldReplaceCell);
6416      };
6417      var replaceRows = function (grid, indexes, section, applyScope, comparator, substitution, tableSection) {
6418        var _a = extractGridDetails(grid), cols = _a.cols, rows = _a.rows;
6419        var targetRow = rows[indexes[0]];
6420        var targets = bind$2(indexes, function (index) {
6421          return getRowCells(rows, index, comparator);
6422        });
6423        var columnHeaders = map$1(targetRow.cells, function (_cell, index) {
6424          return isHeaderCells(getColumnCells(rows, index, comparator));
6425        });
6426        var newRows = __spreadArray([], rows, true);
6427        each$2(indexes, function (index) {
6428          newRows[index] = tableSection.transformRow(rows[index], section);
6429        });
6430        var newGrid = cols.concat(newRows);
6431        var shouldReplaceCell = rowReplacerPredicate(targetRow, columnHeaders);
6432        var scopeGenerator = rowScopeGenerator(applyScope, columnHeaders);
6433        return replaceIn(newGrid, targets, comparator, substitution, tableSection.transformCell, scopeGenerator, shouldReplaceCell);
6434      };
6435      var replaceCells = function (grid, details, comparator, substitution) {
6436        var rows = extractGridDetails(grid).rows;
6437        var targetCells = map$1(details, function (detail) {
6438          return getCell(rows[detail.row], detail.column);
6439        });
6440        return replaceIn(grid, targetCells, comparator, substitution, replace, Optional.none, always);
6441      };
6442  
6443      var uniqueColumns = function (details) {
6444        var uniqueCheck = function (rest, detail) {
6445          var columnExists = exists(rest, function (currentDetail) {
6446            return currentDetail.column === detail.column;
6447          });
6448          return columnExists ? rest : rest.concat([detail]);
6449        };
6450        return foldl(details, uniqueCheck, []).sort(function (detailA, detailB) {
6451          return detailA.column - detailB.column;
6452        });
6453      };
6454  
6455      var isCol = isTag('col');
6456      var isColgroup = isTag('colgroup');
6457      var isRow$1 = function (element) {
6458        return name(element) === 'tr' || isColgroup(element);
6459      };
6460      var elementToData = function (element) {
6461        var colspan = getAttrValue(element, 'colspan', 1);
6462        var rowspan = getAttrValue(element, 'rowspan', 1);
6463        return {
6464          element: element,
6465          colspan: colspan,
6466          rowspan: rowspan
6467        };
6468      };
6469      var modification = function (generators, toData) {
6470        if (toData === void 0) {
6471          toData = elementToData;
6472        }
6473        var nuCell = function (data) {
6474          return isCol(data.element) ? generators.col(data) : generators.cell(data);
6475        };
6476        var nuRow = function (data) {
6477          return isColgroup(data.element) ? generators.colgroup(data) : generators.row(data);
6478        };
6479        var add = function (element) {
6480          if (isRow$1(element)) {
6481            return nuRow({ element: element });
6482          } else {
6483            var replacement = nuCell(toData(element));
6484            recent = Optional.some({
6485              item: element,
6486              replacement: replacement
6487            });
6488            return replacement;
6489          }
6490        };
6491        var recent = Optional.none();
6492        var getOrInit = function (element, comparator) {
6493          return recent.fold(function () {
6494            return add(element);
6495          }, function (p) {
6496            return comparator(element, p.item) ? p.replacement : add(element);
6497          });
6498        };
6499        return { getOrInit: getOrInit };
6500      };
6501      var transform = function (tag) {
6502        return function (generators) {
6503          var list = [];
6504          var find = function (element, comparator) {
6505            return find$1(list, function (x) {
6506              return comparator(x.item, element);
6507            });
6508          };
6509          var makeNew = function (element) {
6510            var attrs = tag === 'td' ? { scope: null } : {};
6511            var cell = generators.replace(element, tag, attrs);
6512            list.push({
6513              item: element,
6514              sub: cell
6515            });
6516            return cell;
6517          };
6518          var replaceOrInit = function (element, comparator) {
6519            if (isRow$1(element) || isCol(element)) {
6520              return element;
6521            } else {
6522              return find(element, comparator).fold(function () {
6523                return makeNew(element);
6524              }, function (p) {
6525                return comparator(element, p.item) ? p.sub : makeNew(element);
6526              });
6527            }
6528          };
6529          return { replaceOrInit: replaceOrInit };
6530        };
6531      };
6532      var getScopeAttribute = function (cell) {
6533        return getOpt(cell, 'scope').map(function (attribute) {
6534          return attribute.substr(0, 3);
6535        });
6536      };
6537      var merging = function (generators) {
6538        var unmerge = function (cell) {
6539          var scope = getScopeAttribute(cell);
6540          scope.each(function (attribute) {
6541            return set$2(cell, 'scope', attribute);
6542          });
6543          return function () {
6544            var raw = generators.cell({
6545              element: cell,
6546              colspan: 1,
6547              rowspan: 1
6548            });
6549            remove$6(raw, 'width');
6550            remove$6(cell, 'width');
6551            scope.each(function (attribute) {
6552              return set$2(raw, 'scope', attribute);
6553            });
6554            return raw;
6555          };
6556        };
6557        var merge = function (cells) {
6558          var getScopeProperty = function () {
6559            var stringAttributes = cat(map$1(cells, getScopeAttribute));
6560            if (stringAttributes.length === 0) {
6561              return Optional.none();
6562            } else {
6563              var baseScope_1 = stringAttributes[0];
6564              var scopes_1 = [
6565                'row',
6566                'col'
6567              ];
6568              var isMixed = exists(stringAttributes, function (attribute) {
6569                return attribute !== baseScope_1 && contains$2(scopes_1, attribute);
6570              });
6571              return isMixed ? Optional.none() : Optional.from(baseScope_1);
6572            }
6573          };
6574          remove$6(cells[0], 'width');
6575          getScopeProperty().fold(function () {
6576            return remove$7(cells[0], 'scope');
6577          }, function (attribute) {
6578            return set$2(cells[0], 'scope', attribute + 'group');
6579          });
6580          return constant(cells[0]);
6581        };
6582        return {
6583          unmerge: unmerge,
6584          merge: merge
6585        };
6586      };
6587      var Generators = {
6588        modification: modification,
6589        transform: transform,
6590        merging: merging
6591      };
6592  
6593      var blockList = [
6594        'body',
6595        'p',
6596        'div',
6597        'article',
6598        'aside',
6599        'figcaption',
6600        'figure',
6601        'footer',
6602        'header',
6603        'nav',
6604        'section',
6605        'ol',
6606        'ul',
6607        'table',
6608        'thead',
6609        'tfoot',
6610        'tbody',
6611        'caption',
6612        'tr',
6613        'td',
6614        'th',
6615        'h1',
6616        'h2',
6617        'h3',
6618        'h4',
6619        'h5',
6620        'h6',
6621        'blockquote',
6622        'pre',
6623        'address'
6624      ];
6625      var isList$1 = function (universe, item) {
6626        var tagName = universe.property().name(item);
6627        return contains$2([
6628          'ol',
6629          'ul'
6630        ], tagName);
6631      };
6632      var isBlock$1 = function (universe, item) {
6633        var tagName = universe.property().name(item);
6634        return contains$2(blockList, tagName);
6635      };
6636      var isEmptyTag$1 = function (universe, item) {
6637        return contains$2([
6638          'br',
6639          'img',
6640          'hr',
6641          'input'
6642        ], universe.property().name(item));
6643      };
6644  
6645      var universe$1 = DomUniverse();
6646      var isBlock = function (element) {
6647        return isBlock$1(universe$1, element);
6648      };
6649      var isList = function (element) {
6650        return isList$1(universe$1, element);
6651      };
6652      var isEmptyTag = function (element) {
6653        return isEmptyTag$1(universe$1, element);
6654      };
6655  
6656      var merge = function (cells) {
6657        var isBr = function (el) {
6658          return name(el) === 'br';
6659        };
6660        var advancedBr = function (children) {
6661          return forall(children, function (c) {
6662            return isBr(c) || isText(c) && get$9(c).trim().length === 0;
6663          });
6664        };
6665        var isListItem = function (el) {
6666          return name(el) === 'li' || ancestor$2(el, isList).isSome();
6667        };
6668        var siblingIsBlock = function (el) {
6669          return nextSibling(el).map(function (rightSibling) {
6670            if (isBlock(rightSibling)) {
6671              return true;
6672            }
6673            if (isEmptyTag(rightSibling)) {
6674              return name(rightSibling) === 'img' ? false : true;
6675            }
6676            return false;
6677          }).getOr(false);
6678        };
6679        var markCell = function (cell) {
6680          return last$1(cell).bind(function (rightEdge) {
6681            var rightSiblingIsBlock = siblingIsBlock(rightEdge);
6682            return parent(rightEdge).map(function (parent) {
6683              return rightSiblingIsBlock === true || isListItem(parent) || isBr(rightEdge) || isBlock(parent) && !eq$1(cell, parent) ? [] : [SugarElement.fromTag('br')];
6684            });
6685          }).getOr([]);
6686        };
6687        var markContent = function () {
6688          var content = bind$2(cells, function (cell) {
6689            var children = children$3(cell);
6690            return advancedBr(children) ? [] : children.concat(markCell(cell));
6691          });
6692          return content.length === 0 ? [SugarElement.fromTag('br')] : content;
6693        };
6694        var contents = markContent();
6695        empty(cells[0]);
6696        append(cells[0], contents);
6697      };
6698  
6699      var isEditable = function (elem) {
6700        return isEditable$1(elem, true);
6701      };
6702      var prune = function (table) {
6703        var cells = cells$1(table);
6704        if (cells.length === 0) {
6705          remove$5(table);
6706        }
6707      };
6708      var outcome = function (grid, cursor) {
6709        return {
6710          grid: grid,
6711          cursor: cursor
6712        };
6713      };
6714      var findEditableCursorPosition = function (rows) {
6715        return findMap(rows, function (row) {
6716          return findMap(row.cells, function (cell) {
6717            var elem = cell.element;
6718            return someIf(isEditable(elem), elem);
6719          });
6720        });
6721      };
6722      var elementFromGrid = function (grid, row, column) {
6723        var _a, _b;
6724        var rows = extractGridDetails(grid).rows;
6725        return Optional.from((_b = (_a = rows[row]) === null || _a === void 0 ? void 0 : _a.cells[column]) === null || _b === void 0 ? void 0 : _b.element).filter(isEditable).orThunk(function () {
6726          return findEditableCursorPosition(rows);
6727        });
6728      };
6729      var bundle = function (grid, row, column) {
6730        var cursorElement = elementFromGrid(grid, row, column);
6731        return outcome(grid, cursorElement);
6732      };
6733      var uniqueRows = function (details) {
6734        var rowCompilation = function (rest, detail) {
6735          var rowExists = exists(rest, function (currentDetail) {
6736            return currentDetail.row === detail.row;
6737          });
6738          return rowExists ? rest : rest.concat([detail]);
6739        };
6740        return foldl(details, rowCompilation, []).sort(function (detailA, detailB) {
6741          return detailA.row - detailB.row;
6742        });
6743      };
6744      var opInsertRowsBefore = function (grid, details, comparator, genWrappers) {
6745        var targetIndex = details[0].row;
6746        var rows = uniqueRows(details);
6747        var newGrid = foldr(rows, function (acc, row) {
6748          var newG = insertRowAt(acc.grid, targetIndex, row.row + acc.delta, comparator, genWrappers.getOrInit);
6749          return {
6750            grid: newG,
6751            delta: acc.delta + 1
6752          };
6753        }, {
6754          grid: grid,
6755          delta: 0
6756        }).grid;
6757        return bundle(newGrid, targetIndex, details[0].column);
6758      };
6759      var opInsertRowsAfter = function (grid, details, comparator, genWrappers) {
6760        var rows = uniqueRows(details);
6761        var target = rows[rows.length - 1];
6762        var targetIndex = target.row + target.rowspan;
6763        var newGrid = foldr(rows, function (newG, row) {
6764          return insertRowAt(newG, targetIndex, row.row, comparator, genWrappers.getOrInit);
6765        }, grid);
6766        return bundle(newGrid, targetIndex, details[0].column);
6767      };
6768      var opInsertColumnsBefore = function (grid, extractDetail, comparator, genWrappers) {
6769        var details = extractDetail.details;
6770        var columns = uniqueColumns(details);
6771        var targetIndex = columns[0].column;
6772        var newGrid = foldr(columns, function (acc, col) {
6773          var newG = insertColumnAt(acc.grid, targetIndex, col.column + acc.delta, comparator, genWrappers.getOrInit);
6774          return {
6775            grid: newG,
6776            delta: acc.delta + 1
6777          };
6778        }, {
6779          grid: grid,
6780          delta: 0
6781        }).grid;
6782        return bundle(newGrid, details[0].row, targetIndex);
6783      };
6784      var opInsertColumnsAfter = function (grid, extractDetail, comparator, genWrappers) {
6785        var details = extractDetail.details;
6786        var target = details[details.length - 1];
6787        var targetIndex = target.column + target.colspan;
6788        var columns = uniqueColumns(details);
6789        var newGrid = foldr(columns, function (newG, col) {
6790          return insertColumnAt(newG, targetIndex, col.column, comparator, genWrappers.getOrInit);
6791        }, grid);
6792        return bundle(newGrid, details[0].row, targetIndex);
6793      };
6794      var opMakeColumnsHeader = function (initialGrid, details, comparator, genWrappers) {
6795        var columns = uniqueColumns(details);
6796        var columnIndexes = map$1(columns, function (detail) {
6797          return detail.column;
6798        });
6799        var newGrid = replaceColumns(initialGrid, columnIndexes, true, comparator, genWrappers.replaceOrInit);
6800        return bundle(newGrid, details[0].row, details[0].column);
6801      };
6802      var opMakeCellsHeader = function (initialGrid, details, comparator, genWrappers) {
6803        var newGrid = replaceCells(initialGrid, details, comparator, genWrappers.replaceOrInit);
6804        return bundle(newGrid, details[0].row, details[0].column);
6805      };
6806      var opUnmakeColumnsHeader = function (initialGrid, details, comparator, genWrappers) {
6807        var columns = uniqueColumns(details);
6808        var columnIndexes = map$1(columns, function (detail) {
6809          return detail.column;
6810        });
6811        var newGrid = replaceColumns(initialGrid, columnIndexes, false, comparator, genWrappers.replaceOrInit);
6812        return bundle(newGrid, details[0].row, details[0].column);
6813      };
6814      var opUnmakeCellsHeader = function (initialGrid, details, comparator, genWrappers) {
6815        var newGrid = replaceCells(initialGrid, details, comparator, genWrappers.replaceOrInit);
6816        return bundle(newGrid, details[0].row, details[0].column);
6817      };
6818      var makeRowsSection = function (section, applyScope) {
6819        return function (initialGrid, details, comparator, genWrappers, tableSection) {
6820          var rows = uniqueRows(details);
6821          var rowIndexes = map$1(rows, function (detail) {
6822            return detail.row;
6823          });
6824          var newGrid = replaceRows(initialGrid, rowIndexes, section, applyScope, comparator, genWrappers.replaceOrInit, tableSection);
6825          return bundle(newGrid, details[0].row, details[0].column);
6826        };
6827      };
6828      var opMakeRowsHeader = makeRowsSection('thead', true);
6829      var opMakeRowsBody = makeRowsSection('tbody', false);
6830      var opMakeRowsFooter = makeRowsSection('tfoot', false);
6831      var opEraseColumns = function (grid, extractDetail, _comparator, _genWrappers) {
6832        var columns = uniqueColumns(extractDetail.details);
6833        var newGrid = deleteColumnsAt(grid, map$1(columns, function (column) {
6834          return column.column;
6835        }));
6836        var maxColIndex = newGrid.length > 0 ? newGrid[0].cells.length - 1 : 0;
6837        return bundle(newGrid, columns[0].row, Math.min(columns[0].column, maxColIndex));
6838      };
6839      var opEraseRows = function (grid, details, _comparator, _genWrappers) {
6840        var rows = uniqueRows(details);
6841        var newGrid = deleteRowsAt(grid, rows[0].row, rows[rows.length - 1].row);
6842        var maxRowIndex = newGrid.length > 0 ? newGrid.length - 1 : 0;
6843        return bundle(newGrid, Math.min(details[0].row, maxRowIndex), details[0].column);
6844      };
6845      var opMergeCells = function (grid, mergable, comparator, genWrappers) {
6846        var cells = mergable.cells;
6847        merge(cells);
6848        var newGrid = merge$2(grid, mergable.bounds, comparator, genWrappers.merge(cells));
6849        return outcome(newGrid, Optional.from(cells[0]));
6850      };
6851      var opUnmergeCells = function (grid, unmergable, comparator, genWrappers) {
6852        var unmerge$1 = function (b, cell) {
6853          return unmerge(b, cell, comparator, genWrappers.unmerge(cell));
6854        };
6855        var newGrid = foldr(unmergable, unmerge$1, grid);
6856        return outcome(newGrid, Optional.from(unmergable[0]));
6857      };
6858      var opPasteCells = function (grid, pasteDetails, comparator, _genWrappers) {
6859        var gridify = function (table, generators) {
6860          var wh = Warehouse.fromTable(table);
6861          return toGrid(wh, generators, true);
6862        };
6863        var gridB = gridify(pasteDetails.clipboard, pasteDetails.generators);
6864        var startAddress = address(pasteDetails.row, pasteDetails.column);
6865        var mergedGrid = merge$1(startAddress, grid, gridB, pasteDetails.generators, comparator);
6866        return mergedGrid.fold(function () {
6867          return outcome(grid, Optional.some(pasteDetails.element));
6868        }, function (newGrid) {
6869          return bundle(newGrid, pasteDetails.row, pasteDetails.column);
6870        });
6871      };
6872      var gridifyRows = function (rows, generators, context) {
6873        var pasteDetails = fromPastedRows(rows, context.section);
6874        var wh = Warehouse.generate(pasteDetails);
6875        return toGrid(wh, generators, true);
6876      };
6877      var opPasteColsBefore = function (grid, pasteDetails, comparator, _genWrappers) {
6878        var rows = extractGridDetails(grid).rows;
6879        var index = pasteDetails.cells[0].column;
6880        var context = rows[pasteDetails.cells[0].row];
6881        var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context);
6882        var mergedGrid = insertCols(index, grid, gridB, pasteDetails.generators, comparator);
6883        return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column);
6884      };
6885      var opPasteColsAfter = function (grid, pasteDetails, comparator, _genWrappers) {
6886        var rows = extractGridDetails(grid).rows;
6887        var index = pasteDetails.cells[pasteDetails.cells.length - 1].column + pasteDetails.cells[pasteDetails.cells.length - 1].colspan;
6888        var context = rows[pasteDetails.cells[0].row];
6889        var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context);
6890        var mergedGrid = insertCols(index, grid, gridB, pasteDetails.generators, comparator);
6891        return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column);
6892      };
6893      var opPasteRowsBefore = function (grid, pasteDetails, comparator, _genWrappers) {
6894        var rows = extractGridDetails(grid).rows;
6895        var index = pasteDetails.cells[0].row;
6896        var context = rows[index];
6897        var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context);
6898        var mergedGrid = insertRows(index, grid, gridB, pasteDetails.generators, comparator);
6899        return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column);
6900      };
6901      var opPasteRowsAfter = function (grid, pasteDetails, comparator, _genWrappers) {
6902        var rows = extractGridDetails(grid).rows;
6903        var index = pasteDetails.cells[pasteDetails.cells.length - 1].row + pasteDetails.cells[pasteDetails.cells.length - 1].rowspan;
6904        var context = rows[pasteDetails.cells[0].row];
6905        var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context);
6906        var mergedGrid = insertRows(index, grid, gridB, pasteDetails.generators, comparator);
6907        return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column);
6908      };
6909      var opGetColumnsType = function (table, target) {
6910        var house = Warehouse.fromTable(table);
6911        var details = onCells(house, target);
6912        return details.bind(function (selectedCells) {
6913          var lastSelectedCell = selectedCells[selectedCells.length - 1];
6914          var minColRange = selectedCells[0].column;
6915          var maxColRange = lastSelectedCell.column + lastSelectedCell.colspan;
6916          var selectedColumnCells = flatten$1(map$1(house.all, function (row) {
6917            return filter$2(row.cells, function (cell) {
6918              return cell.column >= minColRange && cell.column < maxColRange;
6919            });
6920          }));
6921          return findCommonCellType(selectedColumnCells);
6922        }).getOr('');
6923      };
6924      var opGetCellsType = function (table, target) {
6925        var house = Warehouse.fromTable(table);
6926        var details = onCells(house, target);
6927        return details.bind(findCommonCellType).getOr('');
6928      };
6929      var opGetRowsType = function (table, target) {
6930        var house = Warehouse.fromTable(table);
6931        var details = onCells(house, target);
6932        return details.bind(function (selectedCells) {
6933          var lastSelectedCell = selectedCells[selectedCells.length - 1];
6934          var minRowRange = selectedCells[0].row;
6935          var maxRowRange = lastSelectedCell.row + lastSelectedCell.rowspan;
6936          var selectedRows = house.all.slice(minRowRange, maxRowRange);
6937          return findCommonRowType(selectedRows);
6938        }).getOr('');
6939      };
6940      var resize = function (table, list, details, behaviours) {
6941        return adjustWidthTo(table, list, details, behaviours.sizing);
6942      };
6943      var adjustAndRedistributeWidths = function (table, list, details, behaviours) {
6944        return adjustAndRedistributeWidths$1(table, list, details, behaviours.sizing, behaviours.resize);
6945      };
6946      var firstColumnIsLocked = function (_warehouse, details) {
6947        return exists(details, function (detail) {
6948          return detail.column === 0 && detail.isLocked;
6949        });
6950      };
6951      var lastColumnIsLocked = function (warehouse, details) {
6952        return exists(details, function (detail) {
6953          return detail.column + detail.colspan >= warehouse.grid.columns && detail.isLocked;
6954        });
6955      };
6956      var getColumnsWidth = function (warehouse, details) {
6957        var columns$1 = columns(warehouse);
6958        var uniqueCols = uniqueColumns(details);
6959        return foldl(uniqueCols, function (acc, detail) {
6960          var column = columns$1[detail.column];
6961          var colWidth = column.map(getOuter$2).getOr(0);
6962          return acc + colWidth;
6963        }, 0);
6964      };
6965      var insertColumnsExtractor = function (before) {
6966        return function (warehouse, target) {
6967          return onCells(warehouse, target).filter(function (details) {
6968            var checkLocked = before ? firstColumnIsLocked : lastColumnIsLocked;
6969            return !checkLocked(warehouse, details);
6970          }).map(function (details) {
6971            return {
6972              details: details,
6973              pixelDelta: getColumnsWidth(warehouse, details)
6974            };
6975          });
6976        };
6977      };
6978      var eraseColumnsExtractor = function (warehouse, target) {
6979        return onUnlockedCells(warehouse, target).map(function (details) {
6980          return {
6981            details: details,
6982            pixelDelta: -getColumnsWidth(warehouse, details)
6983          };
6984        });
6985      };
6986      var pasteColumnsExtractor = function (before) {
6987        return function (warehouse, target) {
6988          return onPasteByEditor(warehouse, target).filter(function (details) {
6989            var checkLocked = before ? firstColumnIsLocked : lastColumnIsLocked;
6990            return !checkLocked(warehouse, details.cells);
6991          });
6992        };
6993      };
6994      var headerCellGenerator = Generators.transform('th');
6995      var bodyCellGenerator = Generators.transform('td');
6996      var insertRowsBefore = run(opInsertRowsBefore, onCells, noop, noop, Generators.modification);
6997      var insertRowsAfter = run(opInsertRowsAfter, onCells, noop, noop, Generators.modification);
6998      var insertColumnsBefore = run(opInsertColumnsBefore, insertColumnsExtractor(true), adjustAndRedistributeWidths, noop, Generators.modification);
6999      var insertColumnsAfter = run(opInsertColumnsAfter, insertColumnsExtractor(false), adjustAndRedistributeWidths, noop, Generators.modification);
7000      var eraseColumns = run(opEraseColumns, eraseColumnsExtractor, adjustAndRedistributeWidths, prune, Generators.modification);
7001      var eraseRows = run(opEraseRows, onCells, noop, prune, Generators.modification);
7002      var makeColumnsHeader = run(opMakeColumnsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
7003      var unmakeColumnsHeader = run(opUnmakeColumnsHeader, onUnlockedCells, noop, noop, bodyCellGenerator);
7004      var makeRowsHeader = run(opMakeRowsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
7005      var makeRowsBody = run(opMakeRowsBody, onUnlockedCells, noop, noop, bodyCellGenerator);
7006      var makeRowsFooter = run(opMakeRowsFooter, onUnlockedCells, noop, noop, bodyCellGenerator);
7007      var makeCellsHeader = run(opMakeCellsHeader, onUnlockedCells, noop, noop, headerCellGenerator);
7008      var unmakeCellsHeader = run(opUnmakeCellsHeader, onUnlockedCells, noop, noop, bodyCellGenerator);
7009      var mergeCells = run(opMergeCells, onUnlockedMergable, resize, noop, Generators.merging);
7010      var unmergeCells = run(opUnmergeCells, onUnlockedUnmergable, resize, noop, Generators.merging);
7011      var pasteCells = run(opPasteCells, onPaste, resize, noop, Generators.modification);
7012      var pasteColsBefore = run(opPasteColsBefore, pasteColumnsExtractor(true), noop, noop, Generators.modification);
7013      var pasteColsAfter = run(opPasteColsAfter, pasteColumnsExtractor(false), noop, noop, Generators.modification);
7014      var pasteRowsBefore = run(opPasteRowsBefore, onPasteByEditor, noop, noop, Generators.modification);
7015      var pasteRowsAfter = run(opPasteRowsAfter, onPasteByEditor, noop, noop, Generators.modification);
7016      var getColumnsType = opGetColumnsType;
7017      var getCellsType = opGetCellsType;
7018      var getRowsType = opGetRowsType;
7019  
7020      var TableActions = function (editor, cellSelection, lazyWire) {
7021        var isTableBody = function (editor) {
7022          return name(getBody(editor)) === 'table';
7023        };
7024        var lastRowGuard = function (table) {
7025          return isTableBody(editor) === false || getGridSize(table).rows > 1;
7026        };
7027        var lastColumnGuard = function (table) {
7028          return isTableBody(editor) === false || getGridSize(table).columns > 1;
7029        };
7030        var cloneFormats = getCloneElements(editor);
7031        var colMutationOp = isResizeTableColumnResizing(editor) ? noop : halve;
7032        var getTableSectionType = function (table) {
7033          switch (getTableHeaderType(editor)) {
7034          case 'section':
7035            return TableSection.section();
7036          case 'sectionCells':
7037            return TableSection.sectionCells();
7038          case 'cells':
7039            return TableSection.cells();
7040          default:
7041            return TableSection.getTableSectionType(table, 'section');
7042          }
7043        };
7044        var setSelectionFromAction = function (table, result) {
7045          return result.cursor.fold(function () {
7046            var cells = cells$1(table);
7047            return head(cells).filter(inBody).map(function (firstCell) {
7048              cellSelection.clear(table);
7049              var rng = editor.dom.createRng();
7050              rng.selectNode(firstCell.dom);
7051              editor.selection.setRng(rng);
7052              set$2(firstCell, 'data-mce-selected', '1');
7053              return rng;
7054            });
7055          }, function (cell) {
7056            var des = freefallRtl(cell);
7057            var rng = editor.dom.createRng();
7058            rng.setStart(des.element.dom, des.offset);
7059            rng.setEnd(des.element.dom, des.offset);
7060            editor.selection.setRng(rng);
7061            cellSelection.clear(table);
7062            return Optional.some(rng);
7063          });
7064        };
7065        var execute = function (operation, guard, mutate, lazyWire, effect) {
7066          return function (table, target, noEvents) {
7067            if (noEvents === void 0) {
7068              noEvents = false;
7069            }
7070            removeDataStyle(table);
7071            var wire = lazyWire();
7072            var doc = SugarElement.fromDom(editor.getDoc());
7073            var generators = cellOperations(mutate, doc, cloneFormats);
7074            var behaviours = {
7075              sizing: get$4(editor, table),
7076              resize: isResizeTableColumnResizing(editor) ? resizeTable() : preserveTable(),
7077              section: getTableSectionType(table)
7078            };
7079            return guard(table) ? operation(wire, table, target, generators, behaviours).bind(function (result) {
7080              each$2(result.newRows, function (row) {
7081                fireNewRow(editor, row.dom);
7082              });
7083              each$2(result.newCells, function (cell) {
7084                fireNewCell(editor, cell.dom);
7085              });
7086              var range = setSelectionFromAction(table, result);
7087              if (inBody(table)) {
7088                removeDataStyle(table);
7089                if (!noEvents) {
7090                  fireTableModified(editor, table.dom, effect);
7091                }
7092              }
7093              return range.map(function (rng) {
7094                return {
7095                  rng: rng,
7096                  effect: effect
7097                };
7098              });
7099            }) : Optional.none();
7100          };
7101        };
7102        var deleteRow = execute(eraseRows, lastRowGuard, noop, lazyWire, structureModified);
7103        var deleteColumn = execute(eraseColumns, lastColumnGuard, noop, lazyWire, structureModified);
7104        var insertRowsBefore$1 = execute(insertRowsBefore, always, noop, lazyWire, structureModified);
7105        var insertRowsAfter$1 = execute(insertRowsAfter, always, noop, lazyWire, structureModified);
7106        var insertColumnsBefore$1 = execute(insertColumnsBefore, always, colMutationOp, lazyWire, structureModified);
7107        var insertColumnsAfter$1 = execute(insertColumnsAfter, always, colMutationOp, lazyWire, structureModified);
7108        var mergeCells$1 = execute(mergeCells, always, noop, lazyWire, structureModified);
7109        var unmergeCells$1 = execute(unmergeCells, always, noop, lazyWire, structureModified);
7110        var pasteColsBefore$1 = execute(pasteColsBefore, always, noop, lazyWire, structureModified);
7111        var pasteColsAfter$1 = execute(pasteColsAfter, always, noop, lazyWire, structureModified);
7112        var pasteRowsBefore$1 = execute(pasteRowsBefore, always, noop, lazyWire, structureModified);
7113        var pasteRowsAfter$1 = execute(pasteRowsAfter, always, noop, lazyWire, structureModified);
7114        var pasteCells$1 = execute(pasteCells, always, noop, lazyWire, styleAndStructureModified);
7115        var makeCellsHeader$1 = execute(makeCellsHeader, always, noop, lazyWire, structureModified);
7116        var unmakeCellsHeader$1 = execute(unmakeCellsHeader, always, noop, lazyWire, structureModified);
7117        var makeColumnsHeader$1 = execute(makeColumnsHeader, always, noop, lazyWire, structureModified);
7118        var unmakeColumnsHeader$1 = execute(unmakeColumnsHeader, always, noop, lazyWire, structureModified);
7119        var makeRowsHeader$1 = execute(makeRowsHeader, always, noop, lazyWire, structureModified);
7120        var makeRowsBody$1 = execute(makeRowsBody, always, noop, lazyWire, structureModified);
7121        var makeRowsFooter$1 = execute(makeRowsFooter, always, noop, lazyWire, structureModified);
7122        var getTableCellType = getCellsType;
7123        var getTableColType = getColumnsType;
7124        var getTableRowType = getRowsType;
7125        return {
7126          deleteRow: deleteRow,
7127          deleteColumn: deleteColumn,
7128          insertRowsBefore: insertRowsBefore$1,
7129          insertRowsAfter: insertRowsAfter$1,
7130          insertColumnsBefore: insertColumnsBefore$1,
7131          insertColumnsAfter: insertColumnsAfter$1,
7132          mergeCells: mergeCells$1,
7133          unmergeCells: unmergeCells$1,
7134          pasteColsBefore: pasteColsBefore$1,
7135          pasteColsAfter: pasteColsAfter$1,
7136          pasteRowsBefore: pasteRowsBefore$1,
7137          pasteRowsAfter: pasteRowsAfter$1,
7138          pasteCells: pasteCells$1,
7139          makeCellsHeader: makeCellsHeader$1,
7140          unmakeCellsHeader: unmakeCellsHeader$1,
7141          makeColumnsHeader: makeColumnsHeader$1,
7142          unmakeColumnsHeader: unmakeColumnsHeader$1,
7143          makeRowsHeader: makeRowsHeader$1,
7144          makeRowsBody: makeRowsBody$1,
7145          makeRowsFooter: makeRowsFooter$1,
7146          getTableRowType: getTableRowType,
7147          getTableCellType: getTableCellType,
7148          getTableColType: getTableColType
7149        };
7150      };
7151  
7152      var DefaultRenderOptions = {
7153        styles: {
7154          'border-collapse': 'collapse',
7155          'width': '100%'
7156        },
7157        attributes: { border: '1' },
7158        colGroups: false
7159      };
7160      var tableHeaderCell = function () {
7161        return SugarElement.fromTag('th');
7162      };
7163      var tableCell = function () {
7164        return SugarElement.fromTag('td');
7165      };
7166      var tableColumn = function () {
7167        return SugarElement.fromTag('col');
7168      };
7169      var createRow = function (columns, rowHeaders, columnHeaders, rowIndex) {
7170        var tr = SugarElement.fromTag('tr');
7171        for (var j = 0; j < columns; j++) {
7172          var td = rowIndex < rowHeaders || j < columnHeaders ? tableHeaderCell() : tableCell();
7173          if (j < columnHeaders) {
7174            set$2(td, 'scope', 'row');
7175          }
7176          if (rowIndex < rowHeaders) {
7177            set$2(td, 'scope', 'col');
7178          }
7179          append$1(td, SugarElement.fromTag('br'));
7180          append$1(tr, td);
7181        }
7182        return tr;
7183      };
7184      var createGroupRow = function (columns) {
7185        var columnGroup = SugarElement.fromTag('colgroup');
7186        range$1(columns, function () {
7187          return append$1(columnGroup, tableColumn());
7188        });
7189        return columnGroup;
7190      };
7191      var createRows = function (rows, columns, rowHeaders, columnHeaders) {
7192        return range$1(rows, function (r) {
7193          return createRow(columns, rowHeaders, columnHeaders, r);
7194        });
7195      };
7196      var render = function (rows, columns, rowHeaders, columnHeaders, headerType, renderOpts) {
7197        if (renderOpts === void 0) {
7198          renderOpts = DefaultRenderOptions;
7199        }
7200        var table = SugarElement.fromTag('table');
7201        var rowHeadersGoInThead = headerType !== 'cells';
7202        setAll(table, renderOpts.styles);
7203        setAll$1(table, renderOpts.attributes);
7204        if (renderOpts.colGroups) {
7205          append$1(table, createGroupRow(columns));
7206        }
7207        var actualRowHeaders = Math.min(rows, rowHeaders);
7208        if (rowHeadersGoInThead && rowHeaders > 0) {
7209          var thead = SugarElement.fromTag('thead');
7210          append$1(table, thead);
7211          var theadRowHeaders = headerType === 'sectionCells' ? actualRowHeaders : 0;
7212          var theadRows = createRows(rowHeaders, columns, theadRowHeaders, columnHeaders);
7213          append(thead, theadRows);
7214        }
7215        var tbody = SugarElement.fromTag('tbody');
7216        append$1(table, tbody);
7217        var numRows = rowHeadersGoInThead ? rows - actualRowHeaders : rows;
7218        var numRowHeaders = rowHeadersGoInThead ? 0 : rowHeaders;
7219        var tbodyRows = createRows(numRows, columns, numRowHeaders, columnHeaders);
7220        append(tbody, tbodyRows);
7221        return table;
7222      };
7223  
7224      var get$2 = function (element) {
7225        return element.dom.innerHTML;
7226      };
7227      var getOuter = function (element) {
7228        var container = SugarElement.fromTag('div');
7229        var clone = SugarElement.fromDom(element.dom.cloneNode(true));
7230        append$1(container, clone);
7231        return get$2(container);
7232      };
7233  
7234      var placeCaretInCell = function (editor, cell) {
7235        editor.selection.select(cell.dom, true);
7236        editor.selection.collapse(true);
7237      };
7238      var selectFirstCellInTable = function (editor, tableElm) {
7239        descendant(tableElm, 'td,th').each(curry(placeCaretInCell, editor));
7240      };
7241      var fireEvents = function (editor, table) {
7242        each$2(descendants(table, 'tr'), function (row) {
7243          fireNewRow(editor, row.dom);
7244          each$2(descendants(row, 'th,td'), function (cell) {
7245            fireNewCell(editor, cell.dom);
7246          });
7247        });
7248      };
7249      var isPercentage = function (width) {
7250        return isString(width) && width.indexOf('%') !== -1;
7251      };
7252      var insert = function (editor, columns, rows, colHeaders, rowHeaders) {
7253        var defaultStyles = getDefaultStyles(editor);
7254        var options = {
7255          styles: defaultStyles,
7256          attributes: getDefaultAttributes(editor),
7257          colGroups: useColumnGroup(editor)
7258        };
7259        editor.undoManager.ignore(function () {
7260          var table = render(rows, columns, rowHeaders, colHeaders, getTableHeaderType(editor), options);
7261          set$2(table, 'data-mce-id', '__mce');
7262          var html = getOuter(table);
7263          editor.insertContent(html);
7264          editor.addVisual();
7265        });
7266        return descendant(getBody(editor), 'table[data-mce-id="__mce"]').map(function (table) {
7267          if (isPixelsForced(editor)) {
7268            enforcePixels(table);
7269          } else if (isResponsiveForced(editor)) {
7270            enforceNone(table);
7271          } else if (isPercentagesForced(editor) || isPercentage(defaultStyles.width)) {
7272            enforcePercentage(table);
7273          }
7274          removeDataStyle(table);
7275          remove$7(table, 'data-mce-id');
7276          fireEvents(editor, table);
7277          selectFirstCellInTable(editor, table);
7278          return table.dom;
7279        }).getOr(null);
7280      };
7281      var insertTableWithDataValidation = function (editor, rows, columns, options, errorMsg) {
7282        if (options === void 0) {
7283          options = {};
7284        }
7285        var checkInput = function (val) {
7286          return isNumber(val) && val > 0;
7287        };
7288        if (checkInput(rows) && checkInput(columns)) {
7289          var headerRows = options.headerRows || 0;
7290          var headerColumns = options.headerColumns || 0;
7291          return insert(editor, columns, rows, headerColumns, headerRows);
7292        } else {
7293          console.error(errorMsg);
7294          return null;
7295        }
7296      };
7297  
7298      var getClipboardElements = function (getClipboard) {
7299        return function () {
7300          return getClipboard().fold(function () {
7301            return [];
7302          }, function (elems) {
7303            return map$1(elems, function (e) {
7304              return e.dom;
7305            });
7306          });
7307        };
7308      };
7309      var setClipboardElements = function (setClipboard) {
7310        return function (elems) {
7311          var elmsOpt = elems.length > 0 ? Optional.some(fromDom(elems)) : Optional.none();
7312          setClipboard(elmsOpt);
7313        };
7314      };
7315      var insertTable = function (editor) {
7316        return function (columns, rows, options) {
7317          if (options === void 0) {
7318            options = {};
7319          }
7320          var table = insertTableWithDataValidation(editor, rows, columns, options, 'Invalid values for insertTable - rows and columns values are required to insert a table.');
7321          editor.undoManager.add();
7322          return table;
7323        };
7324      };
7325      var getApi = function (editor, clipboard, resizeHandler, selectionTargets) {
7326        return {
7327          insertTable: insertTable(editor),
7328          setClipboardRows: setClipboardElements(clipboard.setRows),
7329          getClipboardRows: getClipboardElements(clipboard.getRows),
7330          setClipboardCols: setClipboardElements(clipboard.setColumns),
7331          getClipboardCols: getClipboardElements(clipboard.getColumns),
7332          resizeHandler: resizeHandler,
7333          selectionTargets: selectionTargets
7334        };
7335      };
7336  
7337      var constrainSpan = function (element, property, value) {
7338        var currentColspan = getAttrValue(element, property, 1);
7339        if (value === 1 || currentColspan <= 1) {
7340          remove$7(element, property);
7341        } else {
7342          set$2(element, property, Math.min(value, currentColspan));
7343        }
7344      };
7345      var generateColGroup = function (house, minColRange, maxColRange) {
7346        if (Warehouse.hasColumns(house)) {
7347          var colsToCopy = filter$2(Warehouse.justColumns(house), function (col) {
7348            return col.column >= minColRange && col.column < maxColRange;
7349          });
7350          var copiedCols = map$1(colsToCopy, function (c) {
7351            var clonedCol = deep(c.element);
7352            constrainSpan(clonedCol, 'span', maxColRange - minColRange);
7353            return clonedCol;
7354          });
7355          var fakeColgroup = SugarElement.fromTag('colgroup');
7356          append(fakeColgroup, copiedCols);
7357          return [fakeColgroup];
7358        } else {
7359          return [];
7360        }
7361      };
7362      var generateRows = function (house, minColRange, maxColRange) {
7363        return map$1(house.all, function (row) {
7364          var cellsToCopy = filter$2(row.cells, function (cell) {
7365            return cell.column >= minColRange && cell.column < maxColRange;
7366          });
7367          var copiedCells = map$1(cellsToCopy, function (cell) {
7368            var clonedCell = deep(cell.element);
7369            constrainSpan(clonedCell, 'colspan', maxColRange - minColRange);
7370            return clonedCell;
7371          });
7372          var fakeTR = SugarElement.fromTag('tr');
7373          append(fakeTR, copiedCells);
7374          return fakeTR;
7375        });
7376      };
7377      var copyCols = function (table, target) {
7378        var house = Warehouse.fromTable(table);
7379        var details = onUnlockedCells(house, target);
7380        return details.map(function (selectedCells) {
7381          var lastSelectedCell = selectedCells[selectedCells.length - 1];
7382          var minColRange = selectedCells[0].column;
7383          var maxColRange = lastSelectedCell.column + lastSelectedCell.colspan;
7384          var fakeColGroups = generateColGroup(house, minColRange, maxColRange);
7385          var fakeRows = generateRows(house, minColRange, maxColRange);
7386          return __spreadArray(__spreadArray([], fakeColGroups, true), fakeRows, true);
7387        });
7388      };
7389  
7390      var copyRows = function (table, target, generators) {
7391        var warehouse = Warehouse.fromTable(table);
7392        var details = onCells(warehouse, target);
7393        return details.bind(function (selectedCells) {
7394          var grid = toGrid(warehouse, generators, false);
7395          var rows = extractGridDetails(grid).rows;
7396          var slicedGrid = rows.slice(selectedCells[0].row, selectedCells[selectedCells.length - 1].row + selectedCells[selectedCells.length - 1].rowspan);
7397          var filteredGrid = bind$2(slicedGrid, function (row) {
7398            var newCells = filter$2(row.cells, function (cell) {
7399              return !cell.isLocked;
7400            });
7401            return newCells.length > 0 ? [__assign(__assign({}, row), { cells: newCells })] : [];
7402          });
7403          var slicedDetails = toDetailList(filteredGrid);
7404          return someIf(slicedDetails.length > 0, slicedDetails);
7405        }).map(function (slicedDetails) {
7406          return copy(slicedDetails);
7407        });
7408      };
7409  
7410      var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');
7411  
7412      var getTDTHOverallStyle = function (dom, elm, name) {
7413        var cells = dom.select('td,th', elm);
7414        var firstChildStyle;
7415        var checkChildren = function (firstChildStyle, elms) {
7416          for (var i = 0; i < elms.length; i++) {
7417            var currentStyle = dom.getStyle(elms[i], name);
7418            if (typeof firstChildStyle === 'undefined') {
7419              firstChildStyle = currentStyle;
7420            }
7421            if (firstChildStyle !== currentStyle) {
7422              return '';
7423            }
7424          }
7425          return firstChildStyle;
7426        };
7427        return checkChildren(firstChildStyle, cells);
7428      };
7429      var applyAlign = function (editor, elm, name) {
7430        if (name) {
7431          editor.formatter.apply('align' + name, {}, elm);
7432        }
7433      };
7434      var applyVAlign = function (editor, elm, name) {
7435        if (name) {
7436          editor.formatter.apply('valign' + name, {}, elm);
7437        }
7438      };
7439      var unApplyAlign = function (editor, elm) {
7440        global$2.each('left center right'.split(' '), function (name) {
7441          editor.formatter.remove('align' + name, {}, elm);
7442        });
7443      };
7444      var unApplyVAlign = function (editor, elm) {
7445        global$2.each('top middle bottom'.split(' '), function (name) {
7446          editor.formatter.remove('valign' + name, {}, elm);
7447        });
7448      };
7449  
7450      var verticalAlignValues = [
7451        {
7452          text: 'None',
7453          value: ''
7454        },
7455        {
7456          text: 'Top',
7457          value: 'top'
7458        },
7459        {
7460          text: 'Middle',
7461          value: 'middle'
7462        },
7463        {
7464          text: 'Bottom',
7465          value: 'bottom'
7466        }
7467      ];
7468  
7469      var hexColour = function (value) {
7470        return { value: value };
7471      };
7472      var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
7473      var longformRegex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i;
7474      var isHexString = function (hex) {
7475        return shorthandRegex.test(hex) || longformRegex.test(hex);
7476      };
7477      var normalizeHex = function (hex) {
7478        return removeLeading(hex, '#').toUpperCase();
7479      };
7480      var fromString$1 = function (hex) {
7481        return isHexString(hex) ? Optional.some({ value: normalizeHex(hex) }) : Optional.none();
7482      };
7483      var toHex = function (component) {
7484        var hex = component.toString(16);
7485        return (hex.length === 1 ? '0' + hex : hex).toUpperCase();
7486      };
7487      var fromRgba = function (rgbaColour) {
7488        var value = toHex(rgbaColour.red) + toHex(rgbaColour.green) + toHex(rgbaColour.blue);
7489        return hexColour(value);
7490      };
7491  
7492      var rgbRegex = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)/;
7493      var rgbaRegex = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(\d?(?:\.\d+)?)\)/;
7494      var rgbaColour = function (red, green, blue, alpha) {
7495        return {
7496          red: red,
7497          green: green,
7498          blue: blue,
7499          alpha: alpha
7500        };
7501      };
7502      var fromStringValues = function (red, green, blue, alpha) {
7503        var r = parseInt(red, 10);
7504        var g = parseInt(green, 10);
7505        var b = parseInt(blue, 10);
7506        var a = parseFloat(alpha);
7507        return rgbaColour(r, g, b, a);
7508      };
7509      var fromString = function (rgbaString) {
7510        if (rgbaString === 'transparent') {
7511          return Optional.some(rgbaColour(0, 0, 0, 0));
7512        }
7513        var rgbMatch = rgbRegex.exec(rgbaString);
7514        if (rgbMatch !== null) {
7515          return Optional.some(fromStringValues(rgbMatch[1], rgbMatch[2], rgbMatch[3], '1'));
7516        }
7517        var rgbaMatch = rgbaRegex.exec(rgbaString);
7518        if (rgbaMatch !== null) {
7519          return Optional.some(fromStringValues(rgbaMatch[1], rgbaMatch[2], rgbaMatch[3], rgbaMatch[4]));
7520        }
7521        return Optional.none();
7522      };
7523  
7524      var anyToHex = function (color) {
7525        return fromString$1(color).orThunk(function () {
7526          return fromString(color).map(fromRgba);
7527        }).getOrThunk(function () {
7528          var canvas = document.createElement('canvas');
7529          canvas.height = 1;
7530          canvas.width = 1;
7531          var canvasContext = canvas.getContext('2d');
7532          canvasContext.clearRect(0, 0, canvas.width, canvas.height);
7533          canvasContext.fillStyle = '#FFFFFF';
7534          canvasContext.fillStyle = color;
7535          canvasContext.fillRect(0, 0, 1, 1);
7536          var rgba = canvasContext.getImageData(0, 0, 1, 1).data;
7537          var r = rgba[0];
7538          var g = rgba[1];
7539          var b = rgba[2];
7540          var a = rgba[3];
7541          return fromRgba(rgbaColour(r, g, b, a));
7542        });
7543      };
7544  
7545      var Cell = function (initial) {
7546        var value = initial;
7547        var get = function () {
7548          return value;
7549        };
7550        var set = function (v) {
7551          value = v;
7552        };
7553        return {
7554          get: get,
7555          set: set
7556        };
7557      };
7558  
7559      var singleton = function (doRevoke) {
7560        var subject = Cell(Optional.none());
7561        var revoke = function () {
7562          return subject.get().each(doRevoke);
7563        };
7564        var clear = function () {
7565          revoke();
7566          subject.set(Optional.none());
7567        };
7568        var isSet = function () {
7569          return subject.get().isSome();
7570        };
7571        var get = function () {
7572          return subject.get();
7573        };
7574        var set = function (s) {
7575          revoke();
7576          subject.set(Optional.some(s));
7577        };
7578        return {
7579          clear: clear,
7580          isSet: isSet,
7581          get: get,
7582          set: set
7583        };
7584      };
7585      var unbindable = function () {
7586        return singleton(function (s) {
7587          return s.unbind();
7588        });
7589      };
7590      var value = function () {
7591        var subject = singleton(noop);
7592        var on = function (f) {
7593          return subject.get().each(f);
7594        };
7595        return __assign(__assign({}, subject), { on: on });
7596      };
7597  
7598      var onSetupToggle = function (editor, selections, formatName, formatValue) {
7599        return function (api) {
7600          var boundCallback = unbindable();
7601          var isNone = isEmpty$1(formatValue);
7602          var init = function () {
7603            var selectedCells = getCellsFromSelection(selections);
7604            var checkNode = function (cell) {
7605              return editor.formatter.match(formatName, { value: formatValue }, cell.dom, isNone);
7606            };
7607            if (isNone) {
7608              api.setActive(!exists(selectedCells, checkNode));
7609              boundCallback.set(editor.formatter.formatChanged(formatName, function (match) {
7610                return api.setActive(!match);
7611              }, true));
7612            } else {
7613              api.setActive(forall(selectedCells, checkNode));
7614              boundCallback.set(editor.formatter.formatChanged(formatName, api.setActive, false, { value: formatValue }));
7615            }
7616          };
7617          editor.initialized ? init() : editor.on('init', init);
7618          return boundCallback.clear;
7619        };
7620      };
7621      var isListGroup = function (item) {
7622        return hasNonNullableKey(item, 'menu');
7623      };
7624      var buildListItems = function (items) {
7625        return map$1(items, function (item) {
7626          var text = item.text || item.title;
7627          if (isListGroup(item)) {
7628            return {
7629              text: text,
7630              items: buildListItems(item.menu)
7631            };
7632          } else {
7633            return {
7634              text: text,
7635              value: item.value
7636            };
7637          }
7638        });
7639      };
7640      var buildMenuItems = function (editor, selections, items, format, onAction) {
7641        return map$1(items, function (item) {
7642          var text = item.text || item.title;
7643          if (isListGroup(item)) {
7644            return {
7645              type: 'nestedmenuitem',
7646              text: text,
7647              getSubmenuItems: function () {
7648                return buildMenuItems(editor, selections, item.menu, format, onAction);
7649              }
7650            };
7651          } else {
7652            return {
7653              text: text,
7654              type: 'togglemenuitem',
7655              onAction: function () {
7656                return onAction(item.value);
7657              },
7658              onSetup: onSetupToggle(editor, selections, format, item.value)
7659            };
7660          }
7661        });
7662      };
7663      var applyTableCellStyle = function (editor, style) {
7664        return function (value) {
7665          var _a;
7666          editor.execCommand('mceTableApplyCellStyle', false, (_a = {}, _a[style] = value, _a));
7667        };
7668      };
7669      var filterNoneItem = function (list) {
7670        return bind$2(list, function (item) {
7671          if (isListGroup(item)) {
7672            return [__assign(__assign({}, item), { menu: filterNoneItem(item.menu) })];
7673          } else {
7674            return isNotEmpty(item.value) ? [item] : [];
7675          }
7676        });
7677      };
7678      var generateMenuItemsCallback = function (editor, selections, items, format, onAction) {
7679        return function (callback) {
7680          return callback(buildMenuItems(editor, selections, items, format, onAction));
7681        };
7682      };
7683      var buildColorMenu = function (editor, colorList, style) {
7684        var colorMap = map$1(colorList, function (entry) {
7685          return {
7686            text: entry.title,
7687            value: '#' + anyToHex(entry.value).value,
7688            type: 'choiceitem'
7689          };
7690        });
7691        return [{
7692            type: 'fancymenuitem',
7693            fancytype: 'colorswatch',
7694            initData: {
7695              colors: colorMap.length > 0 ? colorMap : undefined,
7696              allowCustomColors: false
7697            },
7698            onAction: function (data) {
7699              var _a;
7700              var value = data.value === 'remove' ? '' : data.value;
7701              editor.execCommand('mceTableApplyCellStyle', false, (_a = {}, _a[style] = value, _a));
7702            }
7703          }];
7704      };
7705      var changeRowHeader = function (editor) {
7706        return function () {
7707          var currentType = editor.queryCommandValue('mceTableRowType');
7708          var newType = currentType === 'header' ? 'body' : 'header';
7709          editor.execCommand('mceTableRowType', false, { type: newType });
7710        };
7711      };
7712      var changeColumnHeader = function (editor) {
7713        return function () {
7714          var currentType = editor.queryCommandValue('mceTableColType');
7715          var newType = currentType === 'th' ? 'td' : 'th';
7716          editor.execCommand('mceTableColType', false, { type: newType });
7717        };
7718      };
7719  
7720      var getClassList$1 = function (editor) {
7721        var classes = buildListItems(getCellClassList(editor));
7722        if (classes.length > 0) {
7723          return Optional.some({
7724            name: 'class',
7725            type: 'listbox',
7726            label: 'Class',
7727            items: classes
7728          });
7729        }
7730        return Optional.none();
7731      };
7732      var children = [
7733        {
7734          name: 'width',
7735          type: 'input',
7736          label: 'Width'
7737        },
7738        {
7739          name: 'height',
7740          type: 'input',
7741          label: 'Height'
7742        },
7743        {
7744          name: 'celltype',
7745          type: 'listbox',
7746          label: 'Cell type',
7747          items: [
7748            {
7749              text: 'Cell',
7750              value: 'td'
7751            },
7752            {
7753              text: 'Header cell',
7754              value: 'th'
7755            }
7756          ]
7757        },
7758        {
7759          name: 'scope',
7760          type: 'listbox',
7761          label: 'Scope',
7762          items: [
7763            {
7764              text: 'None',
7765              value: ''
7766            },
7767            {
7768              text: 'Row',
7769              value: 'row'
7770            },
7771            {
7772              text: 'Column',
7773              value: 'col'
7774            },
7775            {
7776              text: 'Row group',
7777              value: 'rowgroup'
7778            },
7779            {
7780              text: 'Column group',
7781              value: 'colgroup'
7782            }
7783          ]
7784        },
7785        {
7786          name: 'halign',
7787          type: 'listbox',
7788          label: 'Horizontal align',
7789          items: [
7790            {
7791              text: 'None',
7792              value: ''
7793            },
7794            {
7795              text: 'Left',
7796              value: 'left'
7797            },
7798            {
7799              text: 'Center',
7800              value: 'center'
7801            },
7802            {
7803              text: 'Right',
7804              value: 'right'
7805            }
7806          ]
7807        },
7808        {
7809          name: 'valign',
7810          type: 'listbox',
7811          label: 'Vertical align',
7812          items: verticalAlignValues
7813        }
7814      ];
7815      var getItems$2 = function (editor) {
7816        return children.concat(getClassList$1(editor).toArray());
7817      };
7818  
7819      var getAdvancedTab = function (editor, dialogName) {
7820        var emptyBorderStyle = [{
7821            text: 'Select...',
7822            value: ''
7823          }];
7824        var advTabItems = [
7825          {
7826            name: 'borderstyle',
7827            type: 'listbox',
7828            label: 'Border style',
7829            items: emptyBorderStyle.concat(buildListItems(getTableBorderStyles(editor)))
7830          },
7831          {
7832            name: 'bordercolor',
7833            type: 'colorinput',
7834            label: 'Border color'
7835          },
7836          {
7837            name: 'backgroundcolor',
7838            type: 'colorinput',
7839            label: 'Background color'
7840          }
7841        ];
7842        var borderWidth = {
7843          name: 'borderwidth',
7844          type: 'input',
7845          label: 'Border width'
7846        };
7847        var items = dialogName === 'cell' ? [borderWidth].concat(advTabItems) : advTabItems;
7848        return {
7849          title: 'Advanced',
7850          name: 'advanced',
7851          items: items
7852        };
7853      };
7854  
7855      var modifiers = function (testTruthy) {
7856        return function (editor, node) {
7857          var dom = editor.dom;
7858          var setAttrib = function (attr, value) {
7859            if (!testTruthy || value) {
7860              dom.setAttrib(node, attr, value);
7861            }
7862          };
7863          var setStyle = function (prop, value) {
7864            if (!testTruthy || value) {
7865              dom.setStyle(node, prop, value);
7866            }
7867          };
7868          var setFormat = function (formatName, value) {
7869            if (!testTruthy || value) {
7870              if (value === '') {
7871                editor.formatter.remove(formatName, { value: null }, node, true);
7872              } else {
7873                editor.formatter.apply(formatName, { value: value }, node);
7874              }
7875            }
7876          };
7877          return {
7878            setAttrib: setAttrib,
7879            setStyle: setStyle,
7880            setFormat: setFormat
7881          };
7882        };
7883      };
7884      var DomModifier = {
7885        normal: modifiers(false),
7886        ifTruthy: modifiers(true)
7887      };
7888  
7889      var rgbToHex = function (dom) {
7890        return function (value) {
7891          return startsWith(value, 'rgb') ? dom.toHex(value) : value;
7892        };
7893      };
7894      var extractAdvancedStyles = function (dom, elm) {
7895        var element = SugarElement.fromDom(elm);
7896        return {
7897          borderwidth: getRaw$2(element, 'border-width').getOr(''),
7898          borderstyle: getRaw$2(element, 'border-style').getOr(''),
7899          bordercolor: getRaw$2(element, 'border-color').map(rgbToHex(dom)).getOr(''),
7900          backgroundcolor: getRaw$2(element, 'background-color').map(rgbToHex(dom)).getOr('')
7901        };
7902      };
7903      var getSharedValues = function (data) {
7904        var baseData = data[0];
7905        var comparisonData = data.slice(1);
7906        each$2(comparisonData, function (items) {
7907          each$2(keys(baseData), function (key) {
7908            each$1(items, function (itemValue, itemKey) {
7909              var comparisonValue = baseData[key];
7910              if (comparisonValue !== '' && key === itemKey) {
7911                if (comparisonValue !== itemValue) {
7912                  baseData[key] = '';
7913                }
7914              }
7915            });
7916          });
7917        });
7918        return baseData;
7919      };
7920      var getAlignment = function (formats, formatName, editor, elm) {
7921        return find$1(formats, function (name) {
7922          return !isUndefined(editor.formatter.matchNode(elm, formatName + name));
7923        }).getOr('');
7924      };
7925      var getHAlignment = curry(getAlignment, [
7926        'left',
7927        'center',
7928        'right'
7929      ], 'align');
7930      var getVAlignment = curry(getAlignment, [
7931        'top',
7932        'middle',
7933        'bottom'
7934      ], 'valign');
7935      var extractDataFromSettings = function (editor, hasAdvTableTab) {
7936        var style = getDefaultStyles(editor);
7937        var attrs = getDefaultAttributes(editor);
7938        var extractAdvancedStyleData = function (dom) {
7939          return {
7940            borderstyle: get$c(style, 'border-style').getOr(''),
7941            bordercolor: rgbToHex(dom)(get$c(style, 'border-color').getOr('')),
7942            backgroundcolor: rgbToHex(dom)(get$c(style, 'background-color').getOr(''))
7943          };
7944        };
7945        var defaultData = {
7946          height: '',
7947          width: '100%',
7948          cellspacing: '',
7949          cellpadding: '',
7950          caption: false,
7951          class: '',
7952          align: '',
7953          border: ''
7954        };
7955        var getBorder = function () {
7956          var borderWidth = style['border-width'];
7957          if (shouldStyleWithCss(editor) && borderWidth) {
7958            return { border: borderWidth };
7959          }
7960          return get$c(attrs, 'border').fold(function () {
7961            return {};
7962          }, function (border) {
7963            return { border: border };
7964          });
7965        };
7966        var advStyle = hasAdvTableTab ? extractAdvancedStyleData(editor.dom) : {};
7967        var getCellPaddingCellSpacing = function () {
7968          var spacing = get$c(style, 'border-spacing').or(get$c(attrs, 'cellspacing')).fold(function () {
7969            return {};
7970          }, function (cellspacing) {
7971            return { cellspacing: cellspacing };
7972          });
7973          var padding = get$c(style, 'border-padding').or(get$c(attrs, 'cellpadding')).fold(function () {
7974            return {};
7975          }, function (cellpadding) {
7976            return { cellpadding: cellpadding };
7977          });
7978          return __assign(__assign({}, spacing), padding);
7979        };
7980        var data = __assign(__assign(__assign(__assign(__assign(__assign({}, defaultData), style), attrs), advStyle), getBorder()), getCellPaddingCellSpacing());
7981        return data;
7982      };
7983      var getRowType = function (elm) {
7984        return table(SugarElement.fromDom(elm)).map(function (table) {
7985          var target = { selection: fromDom(elm.cells) };
7986          return getRowsType(table, target);
7987        }).getOr('');
7988      };
7989      var extractDataFromTableElement = function (editor, elm, hasAdvTableTab) {
7990        var getBorder = function (dom, elm) {
7991          var optBorderWidth = getRaw$2(SugarElement.fromDom(elm), 'border-width');
7992          if (shouldStyleWithCss(editor) && optBorderWidth.isSome()) {
7993            return optBorderWidth.getOr('');
7994          }
7995          return dom.getAttrib(elm, 'border') || getTDTHOverallStyle(editor.dom, elm, 'border-width') || getTDTHOverallStyle(editor.dom, elm, 'border');
7996        };
7997        var dom = editor.dom;
7998        var cellspacing = shouldStyleWithCss(editor) ? dom.getStyle(elm, 'border-spacing') || dom.getAttrib(elm, 'cellspacing') : dom.getAttrib(elm, 'cellspacing') || dom.getStyle(elm, 'border-spacing');
7999        var cellpadding = shouldStyleWithCss(editor) ? getTDTHOverallStyle(dom, elm, 'padding') || dom.getAttrib(elm, 'cellpadding') : dom.getAttrib(elm, 'cellpadding') || getTDTHOverallStyle(dom, elm, 'padding');
8000        return __assign({
8001          width: dom.getStyle(elm, 'width') || dom.getAttrib(elm, 'width'),
8002          height: dom.getStyle(elm, 'height') || dom.getAttrib(elm, 'height'),
8003          cellspacing: cellspacing,
8004          cellpadding: cellpadding,
8005          border: getBorder(dom, elm),
8006          caption: !!dom.select('caption', elm)[0],
8007          class: dom.getAttrib(elm, 'class', ''),
8008          align: getHAlignment(editor, elm)
8009        }, hasAdvTableTab ? extractAdvancedStyles(dom, elm) : {});
8010      };
8011      var extractDataFromRowElement = function (editor, elm, hasAdvancedRowTab) {
8012        var dom = editor.dom;
8013        return __assign({
8014          height: dom.getStyle(elm, 'height') || dom.getAttrib(elm, 'height'),
8015          class: dom.getAttrib(elm, 'class', ''),
8016          type: getRowType(elm),
8017          align: getHAlignment(editor, elm)
8018        }, hasAdvancedRowTab ? extractAdvancedStyles(dom, elm) : {});
8019      };
8020      var extractDataFromCellElement = function (editor, cell, hasAdvancedCellTab, column) {
8021        var dom = editor.dom;
8022        var colElm = column.getOr(cell);
8023        var getStyle = function (element, style) {
8024          return dom.getStyle(element, style) || dom.getAttrib(element, style);
8025        };
8026        return __assign({
8027          width: getStyle(colElm, 'width'),
8028          height: getStyle(cell, 'height'),
8029          scope: dom.getAttrib(cell, 'scope'),
8030          celltype: getNodeName(cell),
8031          class: dom.getAttrib(cell, 'class', ''),
8032          halign: getHAlignment(editor, cell),
8033          valign: getVAlignment(editor, cell)
8034        }, hasAdvancedCellTab ? extractAdvancedStyles(dom, cell) : {});
8035      };
8036  
8037      var getSelectedCells = function (table, cells) {
8038        var warehouse = Warehouse.fromTable(table);
8039        var allCells = Warehouse.justCells(warehouse);
8040        var filtered = filter$2(allCells, function (cellA) {
8041          return exists(cells, function (cellB) {
8042            return eq$1(cellA.element, cellB);
8043          });
8044        });
8045        return map$1(filtered, function (cell) {
8046          return {
8047            element: cell.element.dom,
8048            column: Warehouse.getColumnAt(warehouse, cell.column).map(function (col) {
8049              return col.element.dom;
8050            })
8051          };
8052        });
8053      };
8054      var updateSimpleProps$1 = function (modifier, colModifier, data) {
8055        modifier.setAttrib('scope', data.scope);
8056        modifier.setAttrib('class', data.class);
8057        modifier.setStyle('height', addPxSuffix(data.height));
8058        colModifier.setStyle('width', addPxSuffix(data.width));
8059      };
8060      var updateAdvancedProps$1 = function (modifier, data) {
8061        modifier.setFormat('tablecellbackgroundcolor', data.backgroundcolor);
8062        modifier.setFormat('tablecellbordercolor', data.bordercolor);
8063        modifier.setFormat('tablecellborderstyle', data.borderstyle);
8064        modifier.setFormat('tablecellborderwidth', addPxSuffix(data.borderwidth));
8065      };
8066      var applyStyleData$1 = function (editor, cells, data) {
8067        var isSingleCell = cells.length === 1;
8068        each$2(cells, function (item) {
8069          var cellElm = item.element;
8070          var modifier = isSingleCell ? DomModifier.normal(editor, cellElm) : DomModifier.ifTruthy(editor, cellElm);
8071          var colModifier = item.column.map(function (col) {
8072            return isSingleCell ? DomModifier.normal(editor, col) : DomModifier.ifTruthy(editor, col);
8073          }).getOr(modifier);
8074          updateSimpleProps$1(modifier, colModifier, data);
8075          if (hasAdvancedCellTab(editor)) {
8076            updateAdvancedProps$1(modifier, data);
8077          }
8078          if (isSingleCell) {
8079            unApplyAlign(editor, cellElm);
8080            unApplyVAlign(editor, cellElm);
8081          }
8082          if (data.halign) {
8083            applyAlign(editor, cellElm, data.halign);
8084          }
8085          if (data.valign) {
8086            applyVAlign(editor, cellElm, data.valign);
8087          }
8088        });
8089      };
8090      var applyStructureData$1 = function (editor, data) {
8091        editor.execCommand('mceTableCellType', false, {
8092          type: data.celltype,
8093          no_events: true
8094        });
8095      };
8096      var applyCellData = function (editor, cells, oldData, data) {
8097        var modifiedData = filter$1(data, function (value, key) {
8098          return oldData[key] !== value;
8099        });
8100        if (size(modifiedData) > 0 && cells.length >= 1) {
8101          table(cells[0]).each(function (table) {
8102            var selectedCells = getSelectedCells(table, cells);
8103            var styleModified = size(filter$1(modifiedData, function (_value, key) {
8104              return key !== 'scope' && key !== 'celltype';
8105            })) > 0;
8106            var structureModified = has$1(modifiedData, 'celltype');
8107            if (styleModified || has$1(modifiedData, 'scope')) {
8108              applyStyleData$1(editor, selectedCells, data);
8109            }
8110            if (structureModified) {
8111              applyStructureData$1(editor, data);
8112            }
8113            fireTableModified(editor, table.dom, {
8114              structure: structureModified,
8115              style: styleModified
8116            });
8117          });
8118        }
8119      };
8120      var onSubmitCellForm = function (editor, cells, oldData, api) {
8121        var data = api.getData();
8122        api.close();
8123        editor.undoManager.transact(function () {
8124          applyCellData(editor, cells, oldData, data);
8125          editor.focus();
8126        });
8127      };
8128      var getData = function (editor, cells) {
8129        var cellsData = table(cells[0]).map(function (table) {
8130          return map$1(getSelectedCells(table, cells), function (item) {
8131            return extractDataFromCellElement(editor, item.element, hasAdvancedCellTab(editor), item.column);
8132          });
8133        });
8134        return getSharedValues(cellsData.getOrDie());
8135      };
8136      var open$2 = function (editor, selections) {
8137        var cells = getCellsFromSelection(selections);
8138        if (cells.length === 0) {
8139          return;
8140        }
8141        var data = getData(editor, cells);
8142        var dialogTabPanel = {
8143          type: 'tabpanel',
8144          tabs: [
8145            {
8146              title: 'General',
8147              name: 'general',
8148              items: getItems$2(editor)
8149            },
8150            getAdvancedTab(editor, 'cell')
8151          ]
8152        };
8153        var dialogPanel = {
8154          type: 'panel',
8155          items: [{
8156              type: 'grid',
8157              columns: 2,
8158              items: getItems$2(editor)
8159            }]
8160        };
8161        editor.windowManager.open({
8162          title: 'Cell Properties',
8163          size: 'normal',
8164          body: hasAdvancedCellTab(editor) ? dialogTabPanel : dialogPanel,
8165          buttons: [
8166            {
8167              type: 'cancel',
8168              name: 'cancel',
8169              text: 'Cancel'
8170            },
8171            {
8172              type: 'submit',
8173              name: 'save',
8174              text: 'Save',
8175              primary: true
8176            }
8177          ],
8178          initialData: data,
8179          onSubmit: curry(onSubmitCellForm, editor, cells, data)
8180        });
8181      };
8182  
8183      var getClassList = function (editor) {
8184        var classes = buildListItems(getRowClassList(editor));
8185        if (classes.length > 0) {
8186          return Optional.some({
8187            name: 'class',
8188            type: 'listbox',
8189            label: 'Class',
8190            items: classes
8191          });
8192        }
8193        return Optional.none();
8194      };
8195      var formChildren = [
8196        {
8197          type: 'listbox',
8198          name: 'type',
8199          label: 'Row type',
8200          items: [
8201            {
8202              text: 'Header',
8203              value: 'header'
8204            },
8205            {
8206              text: 'Body',
8207              value: 'body'
8208            },
8209            {
8210              text: 'Footer',
8211              value: 'footer'
8212            }
8213          ]
8214        },
8215        {
8216          type: 'listbox',
8217          name: 'align',
8218          label: 'Alignment',
8219          items: [
8220            {
8221              text: 'None',
8222              value: ''
8223            },
8224            {
8225              text: 'Left',
8226              value: 'left'
8227            },
8228            {
8229              text: 'Center',
8230              value: 'center'
8231            },
8232            {
8233              text: 'Right',
8234              value: 'right'
8235            }
8236          ]
8237        },
8238        {
8239          label: 'Height',
8240          name: 'height',
8241          type: 'input'
8242        }
8243      ];
8244      var getItems$1 = function (editor) {
8245        return formChildren.concat(getClassList(editor).toArray());
8246      };
8247  
8248      var updateSimpleProps = function (modifier, data) {
8249        modifier.setAttrib('class', data.class);
8250        modifier.setStyle('height', addPxSuffix(data.height));
8251      };
8252      var updateAdvancedProps = function (modifier, data) {
8253        modifier.setStyle('background-color', data.backgroundcolor);
8254        modifier.setStyle('border-color', data.bordercolor);
8255        modifier.setStyle('border-style', data.borderstyle);
8256      };
8257      var applyStyleData = function (editor, rows, data, oldData) {
8258        var isSingleRow = rows.length === 1;
8259        each$2(rows, function (rowElm) {
8260          var modifier = isSingleRow ? DomModifier.normal(editor, rowElm) : DomModifier.ifTruthy(editor, rowElm);
8261          updateSimpleProps(modifier, data);
8262          if (hasAdvancedRowTab(editor)) {
8263            updateAdvancedProps(modifier, data);
8264          }
8265          if (data.align !== oldData.align) {
8266            unApplyAlign(editor, rowElm);
8267            applyAlign(editor, rowElm, data.align);
8268          }
8269        });
8270      };
8271      var applyStructureData = function (editor, data) {
8272        editor.execCommand('mceTableRowType', false, {
8273          type: data.type,
8274          no_events: true
8275        });
8276      };
8277      var applyRowData = function (editor, rows, oldData, data) {
8278        var modifiedData = filter$1(data, function (value, key) {
8279          return oldData[key] !== value;
8280        });
8281        if (size(modifiedData) > 0) {
8282          var typeModified_1 = has$1(modifiedData, 'type');
8283          var styleModified_1 = typeModified_1 ? size(modifiedData) > 1 : true;
8284          if (styleModified_1) {
8285            applyStyleData(editor, rows, data, oldData);
8286          }
8287          if (typeModified_1) {
8288            applyStructureData(editor, data);
8289          }
8290          table(SugarElement.fromDom(rows[0])).each(function (table) {
8291            return fireTableModified(editor, table.dom, {
8292              structure: typeModified_1,
8293              style: styleModified_1
8294            });
8295          });
8296        }
8297      };
8298      var onSubmitRowForm = function (editor, rows, oldData, api) {
8299        var data = api.getData();
8300        api.close();
8301        editor.undoManager.transact(function () {
8302          applyRowData(editor, rows, oldData, data);
8303          editor.focus();
8304        });
8305      };
8306      var open$1 = function (editor) {
8307        var rows = getRowsFromSelection(getSelectionStart(editor), ephemera.selected);
8308        if (rows.length === 0) {
8309          return;
8310        }
8311        var rowsData = map$1(rows, function (rowElm) {
8312          return extractDataFromRowElement(editor, rowElm.dom, hasAdvancedRowTab(editor));
8313        });
8314        var data = getSharedValues(rowsData);
8315        var dialogTabPanel = {
8316          type: 'tabpanel',
8317          tabs: [
8318            {
8319              title: 'General',
8320              name: 'general',
8321              items: getItems$1(editor)
8322            },
8323            getAdvancedTab(editor, 'row')
8324          ]
8325        };
8326        var dialogPanel = {
8327          type: 'panel',
8328          items: [{
8329              type: 'grid',
8330              columns: 2,
8331              items: getItems$1(editor)
8332            }]
8333        };
8334        editor.windowManager.open({
8335          title: 'Row Properties',
8336          size: 'normal',
8337          body: hasAdvancedRowTab(editor) ? dialogTabPanel : dialogPanel,
8338          buttons: [
8339            {
8340              type: 'cancel',
8341              name: 'cancel',
8342              text: 'Cancel'
8343            },
8344            {
8345              type: 'submit',
8346              name: 'save',
8347              text: 'Save',
8348              primary: true
8349            }
8350          ],
8351          initialData: data,
8352          onSubmit: curry(onSubmitRowForm, editor, map$1(rows, function (r) {
8353            return r.dom;
8354          }), data)
8355        });
8356      };
8357  
8358      var getItems = function (editor, classes, insertNewTable) {
8359        var rowColCountItems = !insertNewTable ? [] : [
8360          {
8361            type: 'input',
8362            name: 'cols',
8363            label: 'Cols',
8364            inputMode: 'numeric'
8365          },
8366          {
8367            type: 'input',
8368            name: 'rows',
8369            label: 'Rows',
8370            inputMode: 'numeric'
8371          }
8372        ];
8373        var alwaysItems = [
8374          {
8375            type: 'input',
8376            name: 'width',
8377            label: 'Width'
8378          },
8379          {
8380            type: 'input',
8381            name: 'height',
8382            label: 'Height'
8383          }
8384        ];
8385        var appearanceItems = hasAppearanceOptions(editor) ? [
8386          {
8387            type: 'input',
8388            name: 'cellspacing',
8389            label: 'Cell spacing',
8390            inputMode: 'numeric'
8391          },
8392          {
8393            type: 'input',
8394            name: 'cellpadding',
8395            label: 'Cell padding',
8396            inputMode: 'numeric'
8397          },
8398          {
8399            type: 'input',
8400            name: 'border',
8401            label: 'Border width'
8402          },
8403          {
8404            type: 'label',
8405            label: 'Caption',
8406            items: [{
8407                type: 'checkbox',
8408                name: 'caption',
8409                label: 'Show caption'
8410              }]
8411          }
8412        ] : [];
8413        var alignmentItem = [{
8414            type: 'listbox',
8415            name: 'align',
8416            label: 'Alignment',
8417            items: [
8418              {
8419                text: 'None',
8420                value: ''
8421              },
8422              {
8423                text: 'Left',
8424                value: 'left'
8425              },
8426              {
8427                text: 'Center',
8428                value: 'center'
8429              },
8430              {
8431                text: 'Right',
8432                value: 'right'
8433              }
8434            ]
8435          }];
8436        var classListItem = classes.length > 0 ? [{
8437            type: 'listbox',
8438            name: 'class',
8439            label: 'Class',
8440            items: classes
8441          }] : [];
8442        return rowColCountItems.concat(alwaysItems).concat(appearanceItems).concat(alignmentItem).concat(classListItem);
8443      };
8444  
8445      var styleTDTH = function (dom, elm, name, value) {
8446        if (elm.tagName === 'TD' || elm.tagName === 'TH') {
8447          if (isString(name)) {
8448            dom.setStyle(elm, name, value);
8449          } else {
8450            dom.setStyle(elm, name);
8451          }
8452        } else {
8453          if (elm.children) {
8454            for (var i = 0; i < elm.children.length; i++) {
8455              styleTDTH(dom, elm.children[i], name, value);
8456            }
8457          }
8458        }
8459      };
8460      var applyDataToElement = function (editor, tableElm, data) {
8461        var dom = editor.dom;
8462        var attrs = {};
8463        var styles = {};
8464        attrs.class = data.class;
8465        styles.height = addPxSuffix(data.height);
8466        if (dom.getAttrib(tableElm, 'width') && !shouldStyleWithCss(editor)) {
8467          attrs.width = removePxSuffix(data.width);
8468        } else {
8469          styles.width = addPxSuffix(data.width);
8470        }
8471        if (shouldStyleWithCss(editor)) {
8472          styles['border-width'] = addPxSuffix(data.border);
8473          styles['border-spacing'] = addPxSuffix(data.cellspacing);
8474        } else {
8475          attrs.border = data.border;
8476          attrs.cellpadding = data.cellpadding;
8477          attrs.cellspacing = data.cellspacing;
8478        }
8479        if (shouldStyleWithCss(editor) && tableElm.children) {
8480          for (var i = 0; i < tableElm.children.length; i++) {
8481            styleTDTH(dom, tableElm.children[i], {
8482              'border-width': addPxSuffix(data.border),
8483              'padding': addPxSuffix(data.cellpadding)
8484            });
8485            if (hasAdvancedTableTab(editor)) {
8486              styleTDTH(dom, tableElm.children[i], { 'border-color': data.bordercolor });
8487            }
8488          }
8489        }
8490        if (hasAdvancedTableTab(editor)) {
8491          styles['background-color'] = data.backgroundcolor;
8492          styles['border-color'] = data.bordercolor;
8493          styles['border-style'] = data.borderstyle;
8494        }
8495        attrs.style = dom.serializeStyle(__assign(__assign({}, getDefaultStyles(editor)), styles));
8496        dom.setAttribs(tableElm, __assign(__assign({}, getDefaultAttributes(editor)), attrs));
8497      };
8498      var onSubmitTableForm = function (editor, tableElm, oldData, api) {
8499        var dom = editor.dom;
8500        var data = api.getData();
8501        var modifiedData = filter$1(data, function (value, key) {
8502          return oldData[key] !== value;
8503        });
8504        api.close();
8505        if (data.class === '') {
8506          delete data.class;
8507        }
8508        editor.undoManager.transact(function () {
8509          if (!tableElm) {
8510            var cols = parseInt(data.cols, 10) || 1;
8511            var rows = parseInt(data.rows, 10) || 1;
8512            tableElm = insert(editor, cols, rows, 0, 0);
8513          }
8514          if (size(modifiedData) > 0) {
8515            applyDataToElement(editor, tableElm, data);
8516            var captionElm = dom.select('caption', tableElm)[0];
8517            if (captionElm && !data.caption || !captionElm && data.caption) {
8518              editor.execCommand('mceTableToggleCaption');
8519            }
8520            if (data.align === '') {
8521              unApplyAlign(editor, tableElm);
8522            } else {
8523              applyAlign(editor, tableElm, data.align);
8524            }
8525          }
8526          editor.focus();
8527          editor.addVisual();
8528          if (size(modifiedData) > 0) {
8529            var captionModified = has$1(modifiedData, 'caption');
8530            var styleModified = captionModified ? size(modifiedData) > 1 : true;
8531            fireTableModified(editor, tableElm, {
8532              structure: captionModified,
8533              style: styleModified
8534            });
8535          }
8536        });
8537      };
8538      var open = function (editor, insertNewTable) {
8539        var dom = editor.dom;
8540        var tableElm;
8541        var data = extractDataFromSettings(editor, hasAdvancedTableTab(editor));
8542        if (insertNewTable === false) {
8543          tableElm = dom.getParent(editor.selection.getStart(), 'table', editor.getBody());
8544          if (tableElm) {
8545            data = extractDataFromTableElement(editor, tableElm, hasAdvancedTableTab(editor));
8546          } else {
8547            if (hasAdvancedTableTab(editor)) {
8548              data.borderstyle = '';
8549              data.bordercolor = '';
8550              data.backgroundcolor = '';
8551            }
8552          }
8553        } else {
8554          data.cols = '1';
8555          data.rows = '1';
8556          if (hasAdvancedTableTab(editor)) {
8557            data.borderstyle = '';
8558            data.bordercolor = '';
8559            data.backgroundcolor = '';
8560          }
8561        }
8562        var classes = buildListItems(getTableClassList(editor));
8563        if (classes.length > 0) {
8564          if (data.class) {
8565            data.class = data.class.replace(/\s*mce\-item\-table\s*/g, '');
8566          }
8567        }
8568        var generalPanel = {
8569          type: 'grid',
8570          columns: 2,
8571          items: getItems(editor, classes, insertNewTable)
8572        };
8573        var nonAdvancedForm = function () {
8574          return {
8575            type: 'panel',
8576            items: [generalPanel]
8577          };
8578        };
8579        var advancedForm = function () {
8580          return {
8581            type: 'tabpanel',
8582            tabs: [
8583              {
8584                title: 'General',
8585                name: 'general',
8586                items: [generalPanel]
8587              },
8588              getAdvancedTab(editor, 'table')
8589            ]
8590          };
8591        };
8592        var dialogBody = hasAdvancedTableTab(editor) ? advancedForm() : nonAdvancedForm();
8593        editor.windowManager.open({
8594          title: 'Table Properties',
8595          size: 'normal',
8596          body: dialogBody,
8597          onSubmit: curry(onSubmitTableForm, editor, tableElm, data),
8598          buttons: [
8599            {
8600              type: 'cancel',
8601              name: 'cancel',
8602              text: 'Cancel'
8603            },
8604            {
8605              type: 'submit',
8606              name: 'save',
8607              text: 'Save',
8608              primary: true
8609            }
8610          ],
8611          initialData: data
8612        });
8613      };
8614  
8615      var getSelectionStartCellOrCaption = function (editor) {
8616        return getSelectionCellOrCaption(getSelectionStart(editor), getIsRoot(editor));
8617      };
8618      var getSelectionStartCell = function (editor) {
8619        return getSelectionCell(getSelectionStart(editor), getIsRoot(editor));
8620      };
8621      var registerCommands = function (editor, actions, cellSelection, selections, clipboard) {
8622        var isRoot = getIsRoot(editor);
8623        var eraseTable = function () {
8624          return getSelectionStartCellOrCaption(editor).each(function (cellOrCaption) {
8625            table(cellOrCaption, isRoot).filter(not(isRoot)).each(function (table) {
8626              var cursor = SugarElement.fromText('');
8627              after$5(table, cursor);
8628              remove$5(table);
8629              if (editor.dom.isEmpty(editor.getBody())) {
8630                editor.setContent('');
8631                editor.selection.setCursorLocation();
8632              } else {
8633                var rng = editor.dom.createRng();
8634                rng.setStart(cursor.dom, 0);
8635                rng.setEnd(cursor.dom, 0);
8636                editor.selection.setRng(rng);
8637                editor.nodeChanged();
8638              }
8639            });
8640          });
8641        };
8642        var setSizingMode = function (sizing) {
8643          return getSelectionStartCellOrCaption(editor).each(function (cellOrCaption) {
8644            var isForcedSizing = isResponsiveForced(editor) || isPixelsForced(editor) || isPercentagesForced(editor);
8645            if (!isForcedSizing) {
8646              table(cellOrCaption, isRoot).each(function (table) {
8647                if (sizing === 'relative' && !isPercentSizing(table)) {
8648                  enforcePercentage(table);
8649                } else if (sizing === 'fixed' && !isPixelSizing(table)) {
8650                  enforcePixels(table);
8651                } else if (sizing === 'responsive' && !isNoneSizing(table)) {
8652                  enforceNone(table);
8653                }
8654                removeDataStyle(table);
8655                fireTableModified(editor, table.dom, structureModified);
8656              });
8657            }
8658          });
8659        };
8660        var getTableFromCell = function (cell) {
8661          return table(cell, isRoot);
8662        };
8663        var performActionOnSelection = function (action) {
8664          return getSelectionStartCell(editor).bind(function (cell) {
8665            return getTableFromCell(cell).map(function (table) {
8666              return action(table, cell);
8667            });
8668          });
8669        };
8670        var toggleTableClass = function (_ui, clazz) {
8671          performActionOnSelection(function (table) {
8672            editor.formatter.toggle('tableclass', { value: clazz }, table.dom);
8673            fireTableModified(editor, table.dom, styleModified);
8674          });
8675        };
8676        var toggleTableCellClass = function (_ui, clazz) {
8677          performActionOnSelection(function (table) {
8678            var selectedCells = getCellsFromSelection(selections);
8679            var allHaveClass = forall(selectedCells, function (cell) {
8680              return editor.formatter.match('tablecellclass', { value: clazz }, cell.dom);
8681            });
8682            var formatterAction = allHaveClass ? editor.formatter.remove : editor.formatter.apply;
8683            each$2(selectedCells, function (cell) {
8684              return formatterAction('tablecellclass', { value: clazz }, cell.dom);
8685            });
8686            fireTableModified(editor, table.dom, styleModified);
8687          });
8688        };
8689        var toggleCaption = function () {
8690          getSelectionStartCellOrCaption(editor).each(function (cellOrCaption) {
8691            table(cellOrCaption, isRoot).each(function (table) {
8692              child$1(table, 'caption').fold(function () {
8693                var caption = SugarElement.fromTag('caption');
8694                append$1(caption, SugarElement.fromText('Caption'));
8695                appendAt(table, caption, 0);
8696                editor.selection.setCursorLocation(caption.dom, 0);
8697              }, function (caption) {
8698                if (isTag('caption')(cellOrCaption)) {
8699                  one('td', table).each(function (td) {
8700                    return editor.selection.setCursorLocation(td.dom, 0);
8701                  });
8702                }
8703                remove$5(caption);
8704              });
8705              fireTableModified(editor, table.dom, structureModified);
8706            });
8707          });
8708        };
8709        var postExecute = function (_data) {
8710          editor.focus();
8711        };
8712        var actOnSelection = function (execute, noEvents) {
8713          if (noEvents === void 0) {
8714            noEvents = false;
8715          }
8716          return performActionOnSelection(function (table, startCell) {
8717            var targets = forMenu(selections, table, startCell);
8718            execute(table, targets, noEvents).each(postExecute);
8719          });
8720        };
8721        var copyRowSelection = function () {
8722          return performActionOnSelection(function (table, startCell) {
8723            var targets = forMenu(selections, table, startCell);
8724            var generators = cellOperations(noop, SugarElement.fromDom(editor.getDoc()), Optional.none());
8725            return copyRows(table, targets, generators);
8726          });
8727        };
8728        var copyColSelection = function () {
8729          return performActionOnSelection(function (table, startCell) {
8730            var targets = forMenu(selections, table, startCell);
8731            return copyCols(table, targets);
8732          });
8733        };
8734        var pasteOnSelection = function (execute, getRows) {
8735          return getRows().each(function (rows) {
8736            var clonedRows = map$1(rows, function (row) {
8737              return deep(row);
8738            });
8739            performActionOnSelection(function (table, startCell) {
8740              var generators = paste$1(SugarElement.fromDom(editor.getDoc()));
8741              var targets = pasteRows(selections, startCell, clonedRows, generators);
8742              execute(table, targets).each(postExecute);
8743            });
8744          });
8745        };
8746        var actOnType = function (getAction) {
8747          return function (_ui, args) {
8748            return get$c(args, 'type').each(function (type) {
8749              actOnSelection(getAction(type), args.no_events);
8750            });
8751          };
8752        };
8753        each$1({
8754          mceTableSplitCells: function () {
8755            return actOnSelection(actions.unmergeCells);
8756          },
8757          mceTableMergeCells: function () {
8758            return actOnSelection(actions.mergeCells);
8759          },
8760          mceTableInsertRowBefore: function () {
8761            return actOnSelection(actions.insertRowsBefore);
8762          },
8763          mceTableInsertRowAfter: function () {
8764            return actOnSelection(actions.insertRowsAfter);
8765          },
8766          mceTableInsertColBefore: function () {
8767            return actOnSelection(actions.insertColumnsBefore);
8768          },
8769          mceTableInsertColAfter: function () {
8770            return actOnSelection(actions.insertColumnsAfter);
8771          },
8772          mceTableDeleteCol: function () {
8773            return actOnSelection(actions.deleteColumn);
8774          },
8775          mceTableDeleteRow: function () {
8776            return actOnSelection(actions.deleteRow);
8777          },
8778          mceTableCutCol: function () {
8779            return copyColSelection().each(function (selection) {
8780              clipboard.setColumns(selection);
8781              actOnSelection(actions.deleteColumn);
8782            });
8783          },
8784          mceTableCutRow: function () {
8785            return copyRowSelection().each(function (selection) {
8786              clipboard.setRows(selection);
8787              actOnSelection(actions.deleteRow);
8788            });
8789          },
8790          mceTableCopyCol: function () {
8791            return copyColSelection().each(function (selection) {
8792              return clipboard.setColumns(selection);
8793            });
8794          },
8795          mceTableCopyRow: function () {
8796            return copyRowSelection().each(function (selection) {
8797              return clipboard.setRows(selection);
8798            });
8799          },
8800          mceTablePasteColBefore: function () {
8801            return pasteOnSelection(actions.pasteColsBefore, clipboard.getColumns);
8802          },
8803          mceTablePasteColAfter: function () {
8804            return pasteOnSelection(actions.pasteColsAfter, clipboard.getColumns);
8805          },
8806          mceTablePasteRowBefore: function () {
8807            return pasteOnSelection(actions.pasteRowsBefore, clipboard.getRows);
8808          },
8809          mceTablePasteRowAfter: function () {
8810            return pasteOnSelection(actions.pasteRowsAfter, clipboard.getRows);
8811          },
8812          mceTableDelete: eraseTable,
8813          mceTableCellToggleClass: toggleTableCellClass,
8814          mceTableToggleClass: toggleTableClass,
8815          mceTableToggleCaption: toggleCaption,
8816          mceTableSizingMode: function (_ui, sizing) {
8817            return setSizingMode(sizing);
8818          },
8819          mceTableCellType: actOnType(function (type) {
8820            return type === 'th' ? actions.makeCellsHeader : actions.unmakeCellsHeader;
8821          }),
8822          mceTableColType: actOnType(function (type) {
8823            return type === 'th' ? actions.makeColumnsHeader : actions.unmakeColumnsHeader;
8824          }),
8825          mceTableRowType: actOnType(function (type) {
8826            switch (type) {
8827            case 'header':
8828              return actions.makeRowsHeader;
8829            case 'footer':
8830              return actions.makeRowsFooter;
8831            default:
8832              return actions.makeRowsBody;
8833            }
8834          })
8835        }, function (func, name) {
8836          return editor.addCommand(name, func);
8837        });
8838        each$1({
8839          mceTableProps: curry(open, editor, false),
8840          mceTableRowProps: curry(open$1, editor),
8841          mceTableCellProps: curry(open$2, editor, selections)
8842        }, function (func, name) {
8843          return editor.addCommand(name, function () {
8844            return func();
8845          });
8846        });
8847        editor.addCommand('mceInsertTable', function (_ui, args) {
8848          if (isObject(args) && keys(args).length > 0) {
8849            insertTableWithDataValidation(editor, args.rows, args.columns, args.options, 'Invalid values for mceInsertTable - rows and columns values are required to insert a table.');
8850          } else {
8851            open(editor, true);
8852          }
8853        });
8854        editor.addCommand('mceTableApplyCellStyle', function (_ui, args) {
8855          var getFormatName = function (style) {
8856            return 'tablecell' + style.toLowerCase().replace('-', '');
8857          };
8858          if (!isObject(args)) {
8859            return;
8860          }
8861          var cells = getCellsFromSelection(selections);
8862          if (cells.length === 0) {
8863            return;
8864          }
8865          var validArgs = filter$1(args, function (value, style) {
8866            return editor.formatter.has(getFormatName(style)) && isString(value);
8867          });
8868          if (isEmpty(validArgs)) {
8869            return;
8870          }
8871          each$1(validArgs, function (value, style) {
8872            each$2(cells, function (cell) {
8873              DomModifier.normal(editor, cell.dom).setFormat(getFormatName(style), value);
8874            });
8875          });
8876          getTableFromCell(cells[0]).each(function (table) {
8877            return fireTableModified(editor, table.dom, styleModified);
8878          });
8879        });
8880      };
8881  
8882      var registerQueryCommands = function (editor, actions, selections) {
8883        var isRoot = getIsRoot(editor);
8884        var lookupOnSelection = function (action) {
8885          return getSelectionCell(getSelectionStart(editor)).bind(function (cell) {
8886            return table(cell, isRoot).map(function (table) {
8887              var targets = forMenu(selections, table, cell);
8888              return action(table, targets);
8889            });
8890          }).getOr('');
8891        };
8892        each$1({
8893          mceTableRowType: function () {
8894            return lookupOnSelection(actions.getTableRowType);
8895          },
8896          mceTableCellType: function () {
8897            return lookupOnSelection(actions.getTableCellType);
8898          },
8899          mceTableColType: function () {
8900            return lookupOnSelection(actions.getTableColType);
8901          }
8902        }, function (func, name) {
8903          return editor.addQueryValueHandler(name, func);
8904        });
8905      };
8906  
8907      var Clipboard = function () {
8908        var rows = value();
8909        var cols = value();
8910        return {
8911          getRows: rows.get,
8912          setRows: function (r) {
8913            r.fold(rows.clear, rows.set);
8914            cols.clear();
8915          },
8916          clearRows: rows.clear,
8917          getColumns: cols.get,
8918          setColumns: function (c) {
8919            c.fold(cols.clear, cols.set);
8920            rows.clear();
8921          },
8922          clearColumns: cols.clear
8923        };
8924      };
8925  
8926      var genericBase = {
8927        remove_similar: true,
8928        inherit: false
8929      };
8930      var cellBase = __assign({ selector: 'td,th' }, genericBase);
8931      var cellFormats = {
8932        tablecellbackgroundcolor: __assign({ styles: { backgroundColor: '%value' } }, cellBase),
8933        tablecellverticalalign: __assign({ styles: { 'vertical-align': '%value' } }, cellBase),
8934        tablecellbordercolor: __assign({ styles: { borderColor: '%value' } }, cellBase),
8935        tablecellclass: __assign({ classes: ['%value'] }, cellBase),
8936        tableclass: __assign({
8937          selector: 'table',
8938          classes: ['%value']
8939        }, genericBase),
8940        tablecellborderstyle: __assign({ styles: { borderStyle: '%value' } }, cellBase),
8941        tablecellborderwidth: __assign({ styles: { borderWidth: '%value' } }, cellBase)
8942      };
8943      var registerFormats = function (editor) {
8944        editor.formatter.register(cellFormats);
8945      };
8946  
8947      var adt$5 = Adt.generate([
8948        { none: ['current'] },
8949        { first: ['current'] },
8950        {
8951          middle: [
8952            'current',
8953            'target'
8954          ]
8955        },
8956        { last: ['current'] }
8957      ]);
8958      var none = function (current) {
8959        if (current === void 0) {
8960          current = undefined;
8961        }
8962        return adt$5.none(current);
8963      };
8964      var CellLocation = __assign(__assign({}, adt$5), { none: none });
8965  
8966      var walk = function (all, current, index, direction, isEligible) {
8967        if (isEligible === void 0) {
8968          isEligible = always;
8969        }
8970        var forwards = direction === 1;
8971        if (!forwards && index <= 0) {
8972          return CellLocation.first(all[0]);
8973        } else if (forwards && index >= all.length - 1) {
8974          return CellLocation.last(all[all.length - 1]);
8975        } else {
8976          var newIndex = index + direction;
8977          var elem = all[newIndex];
8978          return isEligible(elem) ? CellLocation.middle(current, elem) : walk(all, current, newIndex, direction, isEligible);
8979        }
8980      };
8981      var detect$1 = function (current, isRoot) {
8982        return table(current, isRoot).bind(function (table) {
8983          var all = cells$1(table);
8984          var index = findIndex(all, function (x) {
8985            return eq$1(current, x);
8986          });
8987          return index.map(function (index) {
8988            return {
8989              index: index,
8990              all: all
8991            };
8992          });
8993        });
8994      };
8995      var next = function (current, isEligible, isRoot) {
8996        var detection = detect$1(current, isRoot);
8997        return detection.fold(function () {
8998          return CellLocation.none(current);
8999        }, function (info) {
9000          return walk(info.all, current, info.index, 1, isEligible);
9001        });
9002      };
9003      var prev = function (current, isEligible, isRoot) {
9004        var detection = detect$1(current, isRoot);
9005        return detection.fold(function () {
9006          return CellLocation.none();
9007        }, function (info) {
9008          return walk(info.all, current, info.index, -1, isEligible);
9009        });
9010      };
9011  
9012      var create$2 = function (start, soffset, finish, foffset) {
9013        return {
9014          start: start,
9015          soffset: soffset,
9016          finish: finish,
9017          foffset: foffset
9018        };
9019      };
9020      var SimRange = { create: create$2 };
9021  
9022      var adt$4 = Adt.generate([
9023        { before: ['element'] },
9024        {
9025          on: [
9026            'element',
9027            'offset'
9028          ]
9029        },
9030        { after: ['element'] }
9031      ]);
9032      var cata$1 = function (subject, onBefore, onOn, onAfter) {
9033        return subject.fold(onBefore, onOn, onAfter);
9034      };
9035      var getStart$1 = function (situ) {
9036        return situ.fold(identity, identity, identity);
9037      };
9038      var before$2 = adt$4.before;
9039      var on = adt$4.on;
9040      var after$3 = adt$4.after;
9041      var Situ = {
9042        before: before$2,
9043        on: on,
9044        after: after$3,
9045        cata: cata$1,
9046        getStart: getStart$1
9047      };
9048  
9049      var adt$3 = Adt.generate([
9050        { domRange: ['rng'] },
9051        {
9052          relative: [
9053            'startSitu',
9054            'finishSitu'
9055          ]
9056        },
9057        {
9058          exact: [
9059            'start',
9060            'soffset',
9061            'finish',
9062            'foffset'
9063          ]
9064        }
9065      ]);
9066      var exactFromRange = function (simRange) {
9067        return adt$3.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset);
9068      };
9069      var getStart = function (selection) {
9070        return selection.match({
9071          domRange: function (rng) {
9072            return SugarElement.fromDom(rng.startContainer);
9073          },
9074          relative: function (startSitu, _finishSitu) {
9075            return Situ.getStart(startSitu);
9076          },
9077          exact: function (start, _soffset, _finish, _foffset) {
9078            return start;
9079          }
9080        });
9081      };
9082      var domRange = adt$3.domRange;
9083      var relative = adt$3.relative;
9084      var exact = adt$3.exact;
9085      var getWin = function (selection) {
9086        var start = getStart(selection);
9087        return defaultView(start);
9088      };
9089      var range = SimRange.create;
9090      var SimSelection = {
9091        domRange: domRange,
9092        relative: relative,
9093        exact: exact,
9094        exactFromRange: exactFromRange,
9095        getWin: getWin,
9096        range: range
9097      };
9098  
9099      var selectNode = function (win, element) {
9100        var rng = win.document.createRange();
9101        rng.selectNode(element.dom);
9102        return rng;
9103      };
9104      var selectNodeContents = function (win, element) {
9105        var rng = win.document.createRange();
9106        selectNodeContentsUsing(rng, element);
9107        return rng;
9108      };
9109      var selectNodeContentsUsing = function (rng, element) {
9110        return rng.selectNodeContents(element.dom);
9111      };
9112      var setStart = function (rng, situ) {
9113        situ.fold(function (e) {
9114          rng.setStartBefore(e.dom);
9115        }, function (e, o) {
9116          rng.setStart(e.dom, o);
9117        }, function (e) {
9118          rng.setStartAfter(e.dom);
9119        });
9120      };
9121      var setFinish = function (rng, situ) {
9122        situ.fold(function (e) {
9123          rng.setEndBefore(e.dom);
9124        }, function (e, o) {
9125          rng.setEnd(e.dom, o);
9126        }, function (e) {
9127          rng.setEndAfter(e.dom);
9128        });
9129      };
9130      var relativeToNative = function (win, startSitu, finishSitu) {
9131        var range = win.document.createRange();
9132        setStart(range, startSitu);
9133        setFinish(range, finishSitu);
9134        return range;
9135      };
9136      var exactToNative = function (win, start, soffset, finish, foffset) {
9137        var rng = win.document.createRange();
9138        rng.setStart(start.dom, soffset);
9139        rng.setEnd(finish.dom, foffset);
9140        return rng;
9141      };
9142      var toRect = function (rect) {
9143        return {
9144          left: rect.left,
9145          top: rect.top,
9146          right: rect.right,
9147          bottom: rect.bottom,
9148          width: rect.width,
9149          height: rect.height
9150        };
9151      };
9152      var getFirstRect$1 = function (rng) {
9153        var rects = rng.getClientRects();
9154        var rect = rects.length > 0 ? rects[0] : rng.getBoundingClientRect();
9155        return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect) : Optional.none();
9156      };
9157  
9158      var adt$2 = Adt.generate([
9159        {
9160          ltr: [
9161            'start',
9162            'soffset',
9163            'finish',
9164            'foffset'
9165          ]
9166        },
9167        {
9168          rtl: [
9169            'start',
9170            'soffset',
9171            'finish',
9172            'foffset'
9173          ]
9174        }
9175      ]);
9176      var fromRange = function (win, type, range) {
9177        return type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset);
9178      };
9179      var getRanges = function (win, selection) {
9180        return selection.match({
9181          domRange: function (rng) {
9182            return {
9183              ltr: constant(rng),
9184              rtl: Optional.none
9185            };
9186          },
9187          relative: function (startSitu, finishSitu) {
9188            return {
9189              ltr: cached(function () {
9190                return relativeToNative(win, startSitu, finishSitu);
9191              }),
9192              rtl: cached(function () {
9193                return Optional.some(relativeToNative(win, finishSitu, startSitu));
9194              })
9195            };
9196          },
9197          exact: function (start, soffset, finish, foffset) {
9198            return {
9199              ltr: cached(function () {
9200                return exactToNative(win, start, soffset, finish, foffset);
9201              }),
9202              rtl: cached(function () {
9203                return Optional.some(exactToNative(win, finish, foffset, start, soffset));
9204              })
9205            };
9206          }
9207        });
9208      };
9209      var doDiagnose = function (win, ranges) {
9210        var rng = ranges.ltr();
9211        if (rng.collapsed) {
9212          var reversed = ranges.rtl().filter(function (rev) {
9213            return rev.collapsed === false;
9214          });
9215          return reversed.map(function (rev) {
9216            return adt$2.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset);
9217          }).getOrThunk(function () {
9218            return fromRange(win, adt$2.ltr, rng);
9219          });
9220        } else {
9221          return fromRange(win, adt$2.ltr, rng);
9222        }
9223      };
9224      var diagnose = function (win, selection) {
9225        var ranges = getRanges(win, selection);
9226        return doDiagnose(win, ranges);
9227      };
9228      var asLtrRange = function (win, selection) {
9229        var diagnosis = diagnose(win, selection);
9230        return diagnosis.match({
9231          ltr: function (start, soffset, finish, foffset) {
9232            var rng = win.document.createRange();
9233            rng.setStart(start.dom, soffset);
9234            rng.setEnd(finish.dom, foffset);
9235            return rng;
9236          },
9237          rtl: function (start, soffset, finish, foffset) {
9238            var rng = win.document.createRange();
9239            rng.setStart(finish.dom, foffset);
9240            rng.setEnd(start.dom, soffset);
9241            return rng;
9242          }
9243        });
9244      };
9245      adt$2.ltr;
9246      adt$2.rtl;
9247  
9248      var searchForPoint = function (rectForOffset, x, y, maxX, length) {
9249        if (length === 0) {
9250          return 0;
9251        } else if (x === maxX) {
9252          return length - 1;
9253        }
9254        var xDelta = maxX;
9255        for (var i = 1; i < length; i++) {
9256          var rect = rectForOffset(i);
9257          var curDeltaX = Math.abs(x - rect.left);
9258          if (y <= rect.bottom) {
9259            if (y < rect.top || curDeltaX > xDelta) {
9260              return i - 1;
9261            } else {
9262              xDelta = curDeltaX;
9263            }
9264          }
9265        }
9266        return 0;
9267      };
9268      var inRect = function (rect, x, y) {
9269        return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
9270      };
9271  
9272      var locateOffset = function (doc, textnode, x, y, rect) {
9273        var rangeForOffset = function (o) {
9274          var r = doc.dom.createRange();
9275          r.setStart(textnode.dom, o);
9276          r.collapse(true);
9277          return r;
9278        };
9279        var rectForOffset = function (o) {
9280          var r = rangeForOffset(o);
9281          return r.getBoundingClientRect();
9282        };
9283        var length = get$9(textnode).length;
9284        var offset = searchForPoint(rectForOffset, x, y, rect.right, length);
9285        return rangeForOffset(offset);
9286      };
9287      var locate$1 = function (doc, node, x, y) {
9288        var r = doc.dom.createRange();
9289        r.selectNode(node.dom);
9290        var rects = r.getClientRects();
9291        var foundRect = findMap(rects, function (rect) {
9292          return inRect(rect, x, y) ? Optional.some(rect) : Optional.none();
9293        });
9294        return foundRect.map(function (rect) {
9295          return locateOffset(doc, node, x, y, rect);
9296        });
9297      };
9298  
9299      var searchInChildren = function (doc, node, x, y) {
9300        var r = doc.dom.createRange();
9301        var nodes = children$3(node);
9302        return findMap(nodes, function (n) {
9303          r.selectNode(n.dom);
9304          return inRect(r.getBoundingClientRect(), x, y) ? locateNode(doc, n, x, y) : Optional.none();
9305        });
9306      };
9307      var locateNode = function (doc, node, x, y) {
9308        return isText(node) ? locate$1(doc, node, x, y) : searchInChildren(doc, node, x, y);
9309      };
9310      var locate = function (doc, node, x, y) {
9311        var r = doc.dom.createRange();
9312        r.selectNode(node.dom);
9313        var rect = r.getBoundingClientRect();
9314        var boundedX = Math.max(rect.left, Math.min(rect.right, x));
9315        var boundedY = Math.max(rect.top, Math.min(rect.bottom, y));
9316        return locateNode(doc, node, boundedX, boundedY);
9317      };
9318  
9319      var COLLAPSE_TO_LEFT = true;
9320      var COLLAPSE_TO_RIGHT = false;
9321      var getCollapseDirection = function (rect, x) {
9322        return x - rect.left < rect.right - x ? COLLAPSE_TO_LEFT : COLLAPSE_TO_RIGHT;
9323      };
9324      var createCollapsedNode = function (doc, target, collapseDirection) {
9325        var r = doc.dom.createRange();
9326        r.selectNode(target.dom);
9327        r.collapse(collapseDirection);
9328        return r;
9329      };
9330      var locateInElement = function (doc, node, x) {
9331        var cursorRange = doc.dom.createRange();
9332        cursorRange.selectNode(node.dom);
9333        var rect = cursorRange.getBoundingClientRect();
9334        var collapseDirection = getCollapseDirection(rect, x);
9335        var f = collapseDirection === COLLAPSE_TO_LEFT ? first : last$1;
9336        return f(node).map(function (target) {
9337          return createCollapsedNode(doc, target, collapseDirection);
9338        });
9339      };
9340      var locateInEmpty = function (doc, node, x) {
9341        var rect = node.dom.getBoundingClientRect();
9342        var collapseDirection = getCollapseDirection(rect, x);
9343        return Optional.some(createCollapsedNode(doc, node, collapseDirection));
9344      };
9345      var search = function (doc, node, x) {
9346        var f = children$3(node).length === 0 ? locateInEmpty : locateInElement;
9347        return f(doc, node, x);
9348      };
9349  
9350      var caretPositionFromPoint = function (doc, x, y) {
9351        var _a, _b;
9352        return Optional.from((_b = (_a = doc.dom).caretPositionFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y)).bind(function (pos) {
9353          if (pos.offsetNode === null) {
9354            return Optional.none();
9355          }
9356          var r = doc.dom.createRange();
9357          r.setStart(pos.offsetNode, pos.offset);
9358          r.collapse();
9359          return Optional.some(r);
9360        });
9361      };
9362      var caretRangeFromPoint = function (doc, x, y) {
9363        var _a, _b;
9364        return Optional.from((_b = (_a = doc.dom).caretRangeFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y));
9365      };
9366      var searchTextNodes = function (doc, node, x, y) {
9367        var r = doc.dom.createRange();
9368        r.selectNode(node.dom);
9369        var rect = r.getBoundingClientRect();
9370        var boundedX = Math.max(rect.left, Math.min(rect.right, x));
9371        var boundedY = Math.max(rect.top, Math.min(rect.bottom, y));
9372        return locate(doc, node, boundedX, boundedY);
9373      };
9374      var searchFromPoint = function (doc, x, y) {
9375        return SugarElement.fromPoint(doc, x, y).bind(function (elem) {
9376          var fallback = function () {
9377            return search(doc, elem, x);
9378          };
9379          return children$3(elem).length === 0 ? fallback() : searchTextNodes(doc, elem, x, y).orThunk(fallback);
9380        });
9381      };
9382      var availableSearch = function () {
9383        if (document.caretPositionFromPoint) {
9384          return caretPositionFromPoint;
9385        } else if (document.caretRangeFromPoint) {
9386          return caretRangeFromPoint;
9387        } else {
9388          return searchFromPoint;
9389        }
9390      }();
9391      var fromPoint = function (win, x, y) {
9392        var doc = SugarElement.fromDom(win.document);
9393        return availableSearch(doc, x, y).map(function (rng) {
9394          return SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset);
9395        });
9396      };
9397  
9398      var beforeSpecial = function (element, offset) {
9399        var name$1 = name(element);
9400        if ('input' === name$1) {
9401          return Situ.after(element);
9402        } else if (!contains$2([
9403            'br',
9404            'img'
9405          ], name$1)) {
9406          return Situ.on(element, offset);
9407        } else {
9408          return offset === 0 ? Situ.before(element) : Situ.after(element);
9409        }
9410      };
9411      var preprocessRelative = function (startSitu, finishSitu) {
9412        var start = startSitu.fold(Situ.before, beforeSpecial, Situ.after);
9413        var finish = finishSitu.fold(Situ.before, beforeSpecial, Situ.after);
9414        return SimSelection.relative(start, finish);
9415      };
9416      var preprocessExact = function (start, soffset, finish, foffset) {
9417        var startSitu = beforeSpecial(start, soffset);
9418        var finishSitu = beforeSpecial(finish, foffset);
9419        return SimSelection.relative(startSitu, finishSitu);
9420      };
9421      var preprocess = function (selection) {
9422        return selection.match({
9423          domRange: function (rng) {
9424            var start = SugarElement.fromDom(rng.startContainer);
9425            var finish = SugarElement.fromDom(rng.endContainer);
9426            return preprocessExact(start, rng.startOffset, finish, rng.endOffset);
9427          },
9428          relative: preprocessRelative,
9429          exact: preprocessExact
9430        });
9431      };
9432  
9433      var makeRange = function (start, soffset, finish, foffset) {
9434        var doc = owner(start);
9435        var rng = doc.dom.createRange();
9436        rng.setStart(start.dom, soffset);
9437        rng.setEnd(finish.dom, foffset);
9438        return rng;
9439      };
9440      var after$2 = function (start, soffset, finish, foffset) {
9441        var r = makeRange(start, soffset, finish, foffset);
9442        var same = eq$1(start, finish) && soffset === foffset;
9443        return r.collapsed && !same;
9444      };
9445  
9446      var getNativeSelection = function (win) {
9447        return Optional.from(win.getSelection());
9448      };
9449      var doSetNativeRange = function (win, rng) {
9450        getNativeSelection(win).each(function (selection) {
9451          selection.removeAllRanges();
9452          selection.addRange(rng);
9453        });
9454      };
9455      var doSetRange = function (win, start, soffset, finish, foffset) {
9456        var rng = exactToNative(win, start, soffset, finish, foffset);
9457        doSetNativeRange(win, rng);
9458      };
9459      var setLegacyRtlRange = function (win, selection, start, soffset, finish, foffset) {
9460        selection.collapse(start.dom, soffset);
9461        selection.extend(finish.dom, foffset);
9462      };
9463      var setRangeFromRelative = function (win, relative) {
9464        return diagnose(win, relative).match({
9465          ltr: function (start, soffset, finish, foffset) {
9466            doSetRange(win, start, soffset, finish, foffset);
9467          },
9468          rtl: function (start, soffset, finish, foffset) {
9469            getNativeSelection(win).each(function (selection) {
9470              if (selection.setBaseAndExtent) {
9471                selection.setBaseAndExtent(start.dom, soffset, finish.dom, foffset);
9472              } else if (selection.extend) {
9473                try {
9474                  setLegacyRtlRange(win, selection, start, soffset, finish, foffset);
9475                } catch (e) {
9476                  doSetRange(win, finish, foffset, start, soffset);
9477                }
9478              } else {
9479                doSetRange(win, finish, foffset, start, soffset);
9480              }
9481            });
9482          }
9483        });
9484      };
9485      var setExact = function (win, start, soffset, finish, foffset) {
9486        var relative = preprocessExact(start, soffset, finish, foffset);
9487        setRangeFromRelative(win, relative);
9488      };
9489      var setRelative = function (win, startSitu, finishSitu) {
9490        var relative = preprocessRelative(startSitu, finishSitu);
9491        setRangeFromRelative(win, relative);
9492      };
9493      var toNative = function (selection) {
9494        var win = SimSelection.getWin(selection).dom;
9495        var getDomRange = function (start, soffset, finish, foffset) {
9496          return exactToNative(win, start, soffset, finish, foffset);
9497        };
9498        var filtered = preprocess(selection);
9499        return diagnose(win, filtered).match({
9500          ltr: getDomRange,
9501          rtl: getDomRange
9502        });
9503      };
9504      var readRange = function (selection) {
9505        if (selection.rangeCount > 0) {
9506          var firstRng = selection.getRangeAt(0);
9507          var lastRng = selection.getRangeAt(selection.rangeCount - 1);
9508          return Optional.some(SimRange.create(SugarElement.fromDom(firstRng.startContainer), firstRng.startOffset, SugarElement.fromDom(lastRng.endContainer), lastRng.endOffset));
9509        } else {
9510          return Optional.none();
9511        }
9512      };
9513      var doGetExact = function (selection) {
9514        if (selection.anchorNode === null || selection.focusNode === null) {
9515          return readRange(selection);
9516        } else {
9517          var anchor = SugarElement.fromDom(selection.anchorNode);
9518          var focus_1 = SugarElement.fromDom(selection.focusNode);
9519          return after$2(anchor, selection.anchorOffset, focus_1, selection.focusOffset) ? Optional.some(SimRange.create(anchor, selection.anchorOffset, focus_1, selection.focusOffset)) : readRange(selection);
9520        }
9521      };
9522      var setToElement = function (win, element, selectNodeContents$1) {
9523        if (selectNodeContents$1 === void 0) {
9524          selectNodeContents$1 = true;
9525        }
9526        var rngGetter = selectNodeContents$1 ? selectNodeContents : selectNode;
9527        var rng = rngGetter(win, element);
9528        doSetNativeRange(win, rng);
9529      };
9530      var getExact = function (win) {
9531        return getNativeSelection(win).filter(function (sel) {
9532          return sel.rangeCount > 0;
9533        }).bind(doGetExact);
9534      };
9535      var get$1 = function (win) {
9536        return getExact(win).map(function (range) {
9537          return SimSelection.exact(range.start, range.soffset, range.finish, range.foffset);
9538        });
9539      };
9540      var getFirstRect = function (win, selection) {
9541        var rng = asLtrRange(win, selection);
9542        return getFirstRect$1(rng);
9543      };
9544      var getAtPoint = function (win, x, y) {
9545        return fromPoint(win, x, y);
9546      };
9547      var clear = function (win) {
9548        getNativeSelection(win).each(function (selection) {
9549          return selection.removeAllRanges();
9550        });
9551      };
9552  
9553      var global$1 = tinymce.util.Tools.resolve('tinymce.util.VK');
9554  
9555      var forward = function (editor, isRoot, cell) {
9556        return go$1(editor, isRoot, next(cell, isEditable$1));
9557      };
9558      var backward = function (editor, isRoot, cell) {
9559        return go$1(editor, isRoot, prev(cell, isEditable$1));
9560      };
9561      var getCellFirstCursorPosition = function (editor, cell) {
9562        var selection = SimSelection.exact(cell, 0, cell, 0);
9563        return toNative(selection);
9564      };
9565      var go$1 = function (editor, isRoot, cell) {
9566        return cell.fold(Optional.none, Optional.none, function (current, next) {
9567          return first(next).map(function (cell) {
9568            return getCellFirstCursorPosition(editor, cell);
9569          });
9570        }, function (current) {
9571          editor.execCommand('mceTableInsertRowAfter');
9572          return forward(editor, isRoot, current);
9573        });
9574      };
9575      var rootElements = [
9576        'table',
9577        'li',
9578        'dl'
9579      ];
9580      var handle$1 = function (event, editor, cellSelection) {
9581        if (event.keyCode === global$1.TAB) {
9582          var body_1 = getBody(editor);
9583          var isRoot_1 = function (element) {
9584            var name$1 = name(element);
9585            return eq$1(element, body_1) || contains$2(rootElements, name$1);
9586          };
9587          var rng = editor.selection.getRng();
9588          var container = SugarElement.fromDom(event.shiftKey ? rng.startContainer : rng.endContainer);
9589          cell(container, isRoot_1).each(function (cell) {
9590            event.preventDefault();
9591            table(cell, isRoot_1).each(cellSelection.clear);
9592            editor.selection.collapse(event.shiftKey);
9593            var navigation = event.shiftKey ? backward : forward;
9594            var rng = navigation(editor, isRoot_1, cell);
9595            rng.each(function (range) {
9596              editor.selection.setRng(range);
9597            });
9598          });
9599        }
9600      };
9601  
9602      var create$1 = function (selection, kill) {
9603        return {
9604          selection: selection,
9605          kill: kill
9606        };
9607      };
9608      var Response = { create: create$1 };
9609  
9610      var create = function (start, soffset, finish, foffset) {
9611        return {
9612          start: Situ.on(start, soffset),
9613          finish: Situ.on(finish, foffset)
9614        };
9615      };
9616      var Situs = { create: create };
9617  
9618      var convertToRange = function (win, selection) {
9619        var rng = asLtrRange(win, selection);
9620        return SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset);
9621      };
9622      var makeSitus = Situs.create;
9623  
9624      var sync = function (container, isRoot, start, soffset, finish, foffset, selectRange) {
9625        if (!(eq$1(start, finish) && soffset === foffset)) {
9626          return closest$1(start, 'td,th', isRoot).bind(function (s) {
9627            return closest$1(finish, 'td,th', isRoot).bind(function (f) {
9628              return detect(container, isRoot, s, f, selectRange);
9629            });
9630          });
9631        } else {
9632          return Optional.none();
9633        }
9634      };
9635      var detect = function (container, isRoot, start, finish, selectRange) {
9636        if (!eq$1(start, finish)) {
9637          return identify(start, finish, isRoot).bind(function (cellSel) {
9638            var boxes = cellSel.boxes.getOr([]);
9639            if (boxes.length > 1) {
9640              selectRange(container, boxes, cellSel.start, cellSel.finish);
9641              return Optional.some(Response.create(Optional.some(makeSitus(start, 0, start, getEnd(start))), true));
9642            } else {
9643              return Optional.none();
9644            }
9645          });
9646        } else {
9647          return Optional.none();
9648        }
9649      };
9650      var update = function (rows, columns, container, selected, annotations) {
9651        var updateSelection = function (newSels) {
9652          annotations.clearBeforeUpdate(container);
9653          annotations.selectRange(container, newSels.boxes, newSels.start, newSels.finish);
9654          return newSels.boxes;
9655        };
9656        return shiftSelection(selected, rows, columns, annotations.firstSelectedSelector, annotations.lastSelectedSelector).map(updateSelection);
9657      };
9658  
9659      var traverse = function (item, mode) {
9660        return {
9661          item: item,
9662          mode: mode
9663        };
9664      };
9665      var backtrack = function (universe, item, _direction, transition) {
9666        if (transition === void 0) {
9667          transition = sidestep;
9668        }
9669        return universe.property().parent(item).map(function (p) {
9670          return traverse(p, transition);
9671        });
9672      };
9673      var sidestep = function (universe, item, direction, transition) {
9674        if (transition === void 0) {
9675          transition = advance;
9676        }
9677        return direction.sibling(universe, item).map(function (p) {
9678          return traverse(p, transition);
9679        });
9680      };
9681      var advance = function (universe, item, direction, transition) {
9682        if (transition === void 0) {
9683          transition = advance;
9684        }
9685        var children = universe.property().children(item);
9686        var result = direction.first(children);
9687        return result.map(function (r) {
9688          return traverse(r, transition);
9689        });
9690      };
9691      var successors = [
9692        {
9693          current: backtrack,
9694          next: sidestep,
9695          fallback: Optional.none()
9696        },
9697        {
9698          current: sidestep,
9699          next: advance,
9700          fallback: Optional.some(backtrack)
9701        },
9702        {
9703          current: advance,
9704          next: advance,
9705          fallback: Optional.some(sidestep)
9706        }
9707      ];
9708      var go = function (universe, item, mode, direction, rules) {
9709        if (rules === void 0) {
9710          rules = successors;
9711        }
9712        var ruleOpt = find$1(rules, function (succ) {
9713          return succ.current === mode;
9714        });
9715        return ruleOpt.bind(function (rule) {
9716          return rule.current(universe, item, direction, rule.next).orThunk(function () {
9717            return rule.fallback.bind(function (fb) {
9718              return go(universe, item, fb, direction);
9719            });
9720          });
9721        });
9722      };
9723  
9724      var left$1 = function () {
9725        var sibling = function (universe, item) {
9726          return universe.query().prevSibling(item);
9727        };
9728        var first = function (children) {
9729          return children.length > 0 ? Optional.some(children[children.length - 1]) : Optional.none();
9730        };
9731        return {
9732          sibling: sibling,
9733          first: first
9734        };
9735      };
9736      var right$1 = function () {
9737        var sibling = function (universe, item) {
9738          return universe.query().nextSibling(item);
9739        };
9740        var first = function (children) {
9741          return children.length > 0 ? Optional.some(children[0]) : Optional.none();
9742        };
9743        return {
9744          sibling: sibling,
9745          first: first
9746        };
9747      };
9748      var Walkers = {
9749        left: left$1,
9750        right: right$1
9751      };
9752  
9753      var hone = function (universe, item, predicate, mode, direction, isRoot) {
9754        var next = go(universe, item, mode, direction);
9755        return next.bind(function (n) {
9756          if (isRoot(n.item)) {
9757            return Optional.none();
9758          } else {
9759            return predicate(n.item) ? Optional.some(n.item) : hone(universe, n.item, predicate, n.mode, direction, isRoot);
9760          }
9761        });
9762      };
9763      var left = function (universe, item, predicate, isRoot) {
9764        return hone(universe, item, predicate, sidestep, Walkers.left(), isRoot);
9765      };
9766      var right = function (universe, item, predicate, isRoot) {
9767        return hone(universe, item, predicate, sidestep, Walkers.right(), isRoot);
9768      };
9769  
9770      var isLeaf = function (universe) {
9771        return function (element) {
9772          return universe.property().children(element).length === 0;
9773        };
9774      };
9775      var before$1 = function (universe, item, isRoot) {
9776        return seekLeft$1(universe, item, isLeaf(universe), isRoot);
9777      };
9778      var after$1 = function (universe, item, isRoot) {
9779        return seekRight$1(universe, item, isLeaf(universe), isRoot);
9780      };
9781      var seekLeft$1 = left;
9782      var seekRight$1 = right;
9783  
9784      var universe = DomUniverse();
9785      var before = function (element, isRoot) {
9786        return before$1(universe, element, isRoot);
9787      };
9788      var after = function (element, isRoot) {
9789        return after$1(universe, element, isRoot);
9790      };
9791      var seekLeft = function (element, predicate, isRoot) {
9792        return seekLeft$1(universe, element, predicate, isRoot);
9793      };
9794      var seekRight = function (element, predicate, isRoot) {
9795        return seekRight$1(universe, element, predicate, isRoot);
9796      };
9797  
9798      var ancestor = function (scope, predicate, isRoot) {
9799        return ancestor$2(scope, predicate, isRoot).isSome();
9800      };
9801  
9802      var adt$1 = Adt.generate([
9803        { none: ['message'] },
9804        { success: [] },
9805        { failedUp: ['cell'] },
9806        { failedDown: ['cell'] }
9807      ]);
9808      var isOverlapping = function (bridge, before, after) {
9809        var beforeBounds = bridge.getRect(before);
9810        var afterBounds = bridge.getRect(after);
9811        return afterBounds.right > beforeBounds.left && afterBounds.left < beforeBounds.right;
9812      };
9813      var isRow = function (elem) {
9814        return closest$1(elem, 'tr');
9815      };
9816      var verify = function (bridge, before, beforeOffset, after, afterOffset, failure, isRoot) {
9817        return closest$1(after, 'td,th', isRoot).bind(function (afterCell) {
9818          return closest$1(before, 'td,th', isRoot).map(function (beforeCell) {
9819            if (!eq$1(afterCell, beforeCell)) {
9820              return sharedOne(isRow, [
9821                afterCell,
9822                beforeCell
9823              ]).fold(function () {
9824                return isOverlapping(bridge, beforeCell, afterCell) ? adt$1.success() : failure(beforeCell);
9825              }, function (_sharedRow) {
9826                return failure(beforeCell);
9827              });
9828            } else {
9829              return eq$1(after, afterCell) && getEnd(afterCell) === afterOffset ? failure(beforeCell) : adt$1.none('in same cell');
9830            }
9831          });
9832        }).getOr(adt$1.none('default'));
9833      };
9834      var cata = function (subject, onNone, onSuccess, onFailedUp, onFailedDown) {
9835        return subject.fold(onNone, onSuccess, onFailedUp, onFailedDown);
9836      };
9837      var BeforeAfter = __assign(__assign({}, adt$1), {
9838        verify: verify,
9839        cata: cata
9840      });
9841  
9842      var inParent = function (parent, children, element, index) {
9843        return {
9844          parent: parent,
9845          children: children,
9846          element: element,
9847          index: index
9848        };
9849      };
9850      var indexInParent = function (element) {
9851        return parent(element).bind(function (parent) {
9852          var children = children$3(parent);
9853          return indexOf(children, element).map(function (index) {
9854            return inParent(parent, children, element, index);
9855          });
9856        });
9857      };
9858      var indexOf = function (elements, element) {
9859        return findIndex(elements, curry(eq$1, element));
9860      };
9861  
9862      var isBr = function (elem) {
9863        return name(elem) === 'br';
9864      };
9865      var gatherer = function (cand, gather, isRoot) {
9866        return gather(cand, isRoot).bind(function (target) {
9867          return isText(target) && get$9(target).trim().length === 0 ? gatherer(target, gather, isRoot) : Optional.some(target);
9868        });
9869      };
9870      var handleBr = function (isRoot, element, direction) {
9871        return direction.traverse(element).orThunk(function () {
9872          return gatherer(element, direction.gather, isRoot);
9873        }).map(direction.relative);
9874      };
9875      var findBr = function (element, offset) {
9876        return child$3(element, offset).filter(isBr).orThunk(function () {
9877          return child$3(element, offset - 1).filter(isBr);
9878        });
9879      };
9880      var handleParent = function (isRoot, element, offset, direction) {
9881        return findBr(element, offset).bind(function (br) {
9882          return direction.traverse(br).fold(function () {
9883            return gatherer(br, direction.gather, isRoot).map(direction.relative);
9884          }, function (adjacent) {
9885            return indexInParent(adjacent).map(function (info) {
9886              return Situ.on(info.parent, info.index);
9887            });
9888          });
9889        });
9890      };
9891      var tryBr = function (isRoot, element, offset, direction) {
9892        var target = isBr(element) ? handleBr(isRoot, element, direction) : handleParent(isRoot, element, offset, direction);
9893        return target.map(function (tgt) {
9894          return {
9895            start: tgt,
9896            finish: tgt
9897          };
9898        });
9899      };
9900      var process = function (analysis) {
9901        return BeforeAfter.cata(analysis, function (_message) {
9902          return Optional.none();
9903        }, function () {
9904          return Optional.none();
9905        }, function (cell) {
9906          return Optional.some(point(cell, 0));
9907        }, function (cell) {
9908          return Optional.some(point(cell, getEnd(cell)));
9909        });
9910      };
9911  
9912      var moveDown = function (caret, amount) {
9913        return {
9914          left: caret.left,
9915          top: caret.top + amount,
9916          right: caret.right,
9917          bottom: caret.bottom + amount
9918        };
9919      };
9920      var moveUp = function (caret, amount) {
9921        return {
9922          left: caret.left,
9923          top: caret.top - amount,
9924          right: caret.right,
9925          bottom: caret.bottom - amount
9926        };
9927      };
9928      var translate = function (caret, xDelta, yDelta) {
9929        return {
9930          left: caret.left + xDelta,
9931          top: caret.top + yDelta,
9932          right: caret.right + xDelta,
9933          bottom: caret.bottom + yDelta
9934        };
9935      };
9936      var getTop = function (caret) {
9937        return caret.top;
9938      };
9939      var getBottom = function (caret) {
9940        return caret.bottom;
9941      };
9942  
9943      var getPartialBox = function (bridge, element, offset) {
9944        if (offset >= 0 && offset < getEnd(element)) {
9945          return bridge.getRangedRect(element, offset, element, offset + 1);
9946        } else if (offset > 0) {
9947          return bridge.getRangedRect(element, offset - 1, element, offset);
9948        }
9949        return Optional.none();
9950      };
9951      var toCaret = function (rect) {
9952        return {
9953          left: rect.left,
9954          top: rect.top,
9955          right: rect.right,
9956          bottom: rect.bottom
9957        };
9958      };
9959      var getElemBox = function (bridge, element) {
9960        return Optional.some(bridge.getRect(element));
9961      };
9962      var getBoxAt = function (bridge, element, offset) {
9963        if (isElement(element)) {
9964          return getElemBox(bridge, element).map(toCaret);
9965        } else if (isText(element)) {
9966          return getPartialBox(bridge, element, offset).map(toCaret);
9967        } else {
9968          return Optional.none();
9969        }
9970      };
9971      var getEntireBox = function (bridge, element) {
9972        if (isElement(element)) {
9973          return getElemBox(bridge, element).map(toCaret);
9974        } else if (isText(element)) {
9975          return bridge.getRangedRect(element, 0, element, getEnd(element)).map(toCaret);
9976        } else {
9977          return Optional.none();
9978        }
9979      };
9980  
9981      var JUMP_SIZE = 5;
9982      var NUM_RETRIES = 100;
9983      var adt = Adt.generate([
9984        { none: [] },
9985        { retry: ['caret'] }
9986      ]);
9987      var isOutside = function (caret, box) {
9988        return caret.left < box.left || Math.abs(box.right - caret.left) < 1 || caret.left > box.right;
9989      };
9990      var inOutsideBlock = function (bridge, element, caret) {
9991        return closest$2(element, isBlock).fold(never, function (cell) {
9992          return getEntireBox(bridge, cell).exists(function (box) {
9993            return isOutside(caret, box);
9994          });
9995        });
9996      };
9997      var adjustDown = function (bridge, element, guessBox, original, caret) {
9998        var lowerCaret = moveDown(caret, JUMP_SIZE);
9999        if (Math.abs(guessBox.bottom - original.bottom) < 1) {
10000          return adt.retry(lowerCaret);
10001        } else if (guessBox.top > caret.bottom) {
10002          return adt.retry(lowerCaret);
10003        } else if (guessBox.top === caret.bottom) {
10004          return adt.retry(moveDown(caret, 1));
10005        } else {
10006          return inOutsideBlock(bridge, element, caret) ? adt.retry(translate(lowerCaret, JUMP_SIZE, 0)) : adt.none();
10007        }
10008      };
10009      var adjustUp = function (bridge, element, guessBox, original, caret) {
10010        var higherCaret = moveUp(caret, JUMP_SIZE);
10011        if (Math.abs(guessBox.top - original.top) < 1) {
10012          return adt.retry(higherCaret);
10013        } else if (guessBox.bottom < caret.top) {
10014          return adt.retry(higherCaret);
10015        } else if (guessBox.bottom === caret.top) {
10016          return adt.retry(moveUp(caret, 1));
10017        } else {
10018          return inOutsideBlock(bridge, element, caret) ? adt.retry(translate(higherCaret, JUMP_SIZE, 0)) : adt.none();
10019        }
10020      };
10021      var upMovement = {
10022        point: getTop,
10023        adjuster: adjustUp,
10024        move: moveUp,
10025        gather: before
10026      };
10027      var downMovement = {
10028        point: getBottom,
10029        adjuster: adjustDown,
10030        move: moveDown,
10031        gather: after
10032      };
10033      var isAtTable = function (bridge, x, y) {
10034        return bridge.elementFromPoint(x, y).filter(function (elm) {
10035          return name(elm) === 'table';
10036        }).isSome();
10037      };
10038      var adjustForTable = function (bridge, movement, original, caret, numRetries) {
10039        return adjustTil(bridge, movement, original, movement.move(caret, JUMP_SIZE), numRetries);
10040      };
10041      var adjustTil = function (bridge, movement, original, caret, numRetries) {
10042        if (numRetries === 0) {
10043          return Optional.some(caret);
10044        }
10045        if (isAtTable(bridge, caret.left, movement.point(caret))) {
10046          return adjustForTable(bridge, movement, original, caret, numRetries - 1);
10047        }
10048        return bridge.situsFromPoint(caret.left, movement.point(caret)).bind(function (guess) {
10049          return guess.start.fold(Optional.none, function (element) {
10050            return getEntireBox(bridge, element).bind(function (guessBox) {
10051              return movement.adjuster(bridge, element, guessBox, original, caret).fold(Optional.none, function (newCaret) {
10052                return adjustTil(bridge, movement, original, newCaret, numRetries - 1);
10053              });
10054            }).orThunk(function () {
10055              return Optional.some(caret);
10056            });
10057          }, Optional.none);
10058        });
10059      };
10060      var ieTryDown = function (bridge, caret) {
10061        return bridge.situsFromPoint(caret.left, caret.bottom + JUMP_SIZE);
10062      };
10063      var ieTryUp = function (bridge, caret) {
10064        return bridge.situsFromPoint(caret.left, caret.top - JUMP_SIZE);
10065      };
10066      var checkScroll = function (movement, adjusted, bridge) {
10067        if (movement.point(adjusted) > bridge.getInnerHeight()) {
10068          return Optional.some(movement.point(adjusted) - bridge.getInnerHeight());
10069        } else if (movement.point(adjusted) < 0) {
10070          return Optional.some(-movement.point(adjusted));
10071        } else {
10072          return Optional.none();
10073        }
10074      };
10075      var retry = function (movement, bridge, caret) {
10076        var moved = movement.move(caret, JUMP_SIZE);
10077        var adjusted = adjustTil(bridge, movement, caret, moved, NUM_RETRIES).getOr(moved);
10078        return checkScroll(movement, adjusted, bridge).fold(function () {
10079          return bridge.situsFromPoint(adjusted.left, movement.point(adjusted));
10080        }, function (delta) {
10081          bridge.scrollBy(0, delta);
10082          return bridge.situsFromPoint(adjusted.left, movement.point(adjusted) - delta);
10083        });
10084      };
10085      var Retries = {
10086        tryUp: curry(retry, upMovement),
10087        tryDown: curry(retry, downMovement),
10088        ieTryUp: ieTryUp,
10089        ieTryDown: ieTryDown,
10090        getJumpSize: constant(JUMP_SIZE)
10091      };
10092  
10093      var MAX_RETRIES = 20;
10094      var findSpot = function (bridge, isRoot, direction) {
10095        return bridge.getSelection().bind(function (sel) {
10096          return tryBr(isRoot, sel.finish, sel.foffset, direction).fold(function () {
10097            return Optional.some(point(sel.finish, sel.foffset));
10098          }, function (brNeighbour) {
10099            var range = bridge.fromSitus(brNeighbour);
10100            var analysis = BeforeAfter.verify(bridge, sel.finish, sel.foffset, range.finish, range.foffset, direction.failure, isRoot);
10101            return process(analysis);
10102          });
10103        });
10104      };
10105      var scan = function (bridge, isRoot, element, offset, direction, numRetries) {
10106        if (numRetries === 0) {
10107          return Optional.none();
10108        }
10109        return tryCursor(bridge, isRoot, element, offset, direction).bind(function (situs) {
10110          var range = bridge.fromSitus(situs);
10111          var analysis = BeforeAfter.verify(bridge, element, offset, range.finish, range.foffset, direction.failure, isRoot);
10112          return BeforeAfter.cata(analysis, function () {
10113            return Optional.none();
10114          }, function () {
10115            return Optional.some(situs);
10116          }, function (cell) {
10117            if (eq$1(element, cell) && offset === 0) {
10118              return tryAgain(bridge, element, offset, moveUp, direction);
10119            } else {
10120              return scan(bridge, isRoot, cell, 0, direction, numRetries - 1);
10121            }
10122          }, function (cell) {
10123            if (eq$1(element, cell) && offset === getEnd(cell)) {
10124              return tryAgain(bridge, element, offset, moveDown, direction);
10125            } else {
10126              return scan(bridge, isRoot, cell, getEnd(cell), direction, numRetries - 1);
10127            }
10128          });
10129        });
10130      };
10131      var tryAgain = function (bridge, element, offset, move, direction) {
10132        return getBoxAt(bridge, element, offset).bind(function (box) {
10133          return tryAt(bridge, direction, move(box, Retries.getJumpSize()));
10134        });
10135      };
10136      var tryAt = function (bridge, direction, box) {
10137        var browser = detect$3().browser;
10138        if (browser.isChrome() || browser.isSafari() || browser.isFirefox() || browser.isEdge()) {
10139          return direction.otherRetry(bridge, box);
10140        } else if (browser.isIE()) {
10141          return direction.ieRetry(bridge, box);
10142        } else {
10143          return Optional.none();
10144        }
10145      };
10146      var tryCursor = function (bridge, isRoot, element, offset, direction) {
10147        return getBoxAt(bridge, element, offset).bind(function (box) {
10148          return tryAt(bridge, direction, box);
10149        });
10150      };
10151      var handle = function (bridge, isRoot, direction) {
10152        return findSpot(bridge, isRoot, direction).bind(function (spot) {
10153          return scan(bridge, isRoot, spot.element, spot.offset, direction, MAX_RETRIES).map(bridge.fromSitus);
10154        });
10155      };
10156  
10157      var inSameTable = function (elem, table) {
10158        return ancestor(elem, function (e) {
10159          return parent(e).exists(function (p) {
10160            return eq$1(p, table);
10161          });
10162        });
10163      };
10164      var simulate = function (bridge, isRoot, direction, initial, anchor) {
10165        return closest$1(initial, 'td,th', isRoot).bind(function (start) {
10166          return closest$1(start, 'table', isRoot).bind(function (table) {
10167            if (!inSameTable(anchor, table)) {
10168              return Optional.none();
10169            }
10170            return handle(bridge, isRoot, direction).bind(function (range) {
10171              return closest$1(range.finish, 'td,th', isRoot).map(function (finish) {
10172                return {
10173                  start: start,
10174                  finish: finish,
10175                  range: range
10176                };
10177              });
10178            });
10179          });
10180        });
10181      };
10182      var navigate = function (bridge, isRoot, direction, initial, anchor, precheck) {
10183        if (detect$3().browser.isIE()) {
10184          return Optional.none();
10185        } else {
10186          return precheck(initial, isRoot).orThunk(function () {
10187            return simulate(bridge, isRoot, direction, initial, anchor).map(function (info) {
10188              var range = info.range;
10189              return Response.create(Optional.some(makeSitus(range.start, range.soffset, range.finish, range.foffset)), true);
10190            });
10191          });
10192        }
10193      };
10194      var firstUpCheck = function (initial, isRoot) {
10195        return closest$1(initial, 'tr', isRoot).bind(function (startRow) {
10196          return closest$1(startRow, 'table', isRoot).bind(function (table) {
10197            var rows = descendants(table, 'tr');
10198            if (eq$1(startRow, rows[0])) {
10199              return seekLeft(table, function (element) {
10200                return last$1(element).isSome();
10201              }, isRoot).map(function (last) {
10202                var lastOffset = getEnd(last);
10203                return Response.create(Optional.some(makeSitus(last, lastOffset, last, lastOffset)), true);
10204              });
10205            } else {
10206              return Optional.none();
10207            }
10208          });
10209        });
10210      };
10211      var lastDownCheck = function (initial, isRoot) {
10212        return closest$1(initial, 'tr', isRoot).bind(function (startRow) {
10213          return closest$1(startRow, 'table', isRoot).bind(function (table) {
10214            var rows = descendants(table, 'tr');
10215            if (eq$1(startRow, rows[rows.length - 1])) {
10216              return seekRight(table, function (element) {
10217                return first(element).isSome();
10218              }, isRoot).map(function (first) {
10219                return Response.create(Optional.some(makeSitus(first, 0, first, 0)), true);
10220              });
10221            } else {
10222              return Optional.none();
10223            }
10224          });
10225        });
10226      };
10227      var select = function (bridge, container, isRoot, direction, initial, anchor, selectRange) {
10228        return simulate(bridge, isRoot, direction, initial, anchor).bind(function (info) {
10229          return detect(container, isRoot, info.start, info.finish, selectRange);
10230        });
10231      };
10232  
10233      var findCell = function (target, isRoot) {
10234        return closest$1(target, 'td,th', isRoot);
10235      };
10236      var MouseSelection = function (bridge, container, isRoot, annotations) {
10237        var cursor = value();
10238        var clearstate = cursor.clear;
10239        var applySelection = function (event) {
10240          cursor.on(function (start) {
10241            annotations.clearBeforeUpdate(container);
10242            findCell(event.target, isRoot).each(function (finish) {
10243              identify(start, finish, isRoot).each(function (cellSel) {
10244                var boxes = cellSel.boxes.getOr([]);
10245                if (boxes.length === 1) {
10246                  var singleCell = boxes[0];
10247                  var isNonEditableCell = getRaw(singleCell) === 'false';
10248                  var isCellClosestContentEditable = is(closest(event.target), singleCell, eq$1);
10249                  if (isNonEditableCell && isCellClosestContentEditable) {
10250                    annotations.selectRange(container, boxes, singleCell, singleCell);
10251                    bridge.selectContents(singleCell);
10252                  }
10253                } else if (boxes.length > 1) {
10254                  annotations.selectRange(container, boxes, cellSel.start, cellSel.finish);
10255                  bridge.selectContents(finish);
10256                }
10257              });
10258            });
10259          });
10260        };
10261        var mousedown = function (event) {
10262          annotations.clear(container);
10263          findCell(event.target, isRoot).each(cursor.set);
10264        };
10265        var mouseover = function (event) {
10266          applySelection(event);
10267        };
10268        var mouseup = function (event) {
10269          applySelection(event);
10270          clearstate();
10271        };
10272        return {
10273          clearstate: clearstate,
10274          mousedown: mousedown,
10275          mouseover: mouseover,
10276          mouseup: mouseup
10277        };
10278      };
10279  
10280      var down = {
10281        traverse: nextSibling,
10282        gather: after,
10283        relative: Situ.before,
10284        otherRetry: Retries.tryDown,
10285        ieRetry: Retries.ieTryDown,
10286        failure: BeforeAfter.failedDown
10287      };
10288      var up = {
10289        traverse: prevSibling,
10290        gather: before,
10291        relative: Situ.before,
10292        otherRetry: Retries.tryUp,
10293        ieRetry: Retries.ieTryUp,
10294        failure: BeforeAfter.failedUp
10295      };
10296  
10297      var isKey = function (key) {
10298        return function (keycode) {
10299          return keycode === key;
10300        };
10301      };
10302      var isUp = isKey(38);
10303      var isDown = isKey(40);
10304      var isNavigation = function (keycode) {
10305        return keycode >= 37 && keycode <= 40;
10306      };
10307      var ltr = {
10308        isBackward: isKey(37),
10309        isForward: isKey(39)
10310      };
10311      var rtl = {
10312        isBackward: isKey(39),
10313        isForward: isKey(37)
10314      };
10315  
10316      var get = function (_DOC) {
10317        var doc = _DOC !== undefined ? _DOC.dom : document;
10318        var x = doc.body.scrollLeft || doc.documentElement.scrollLeft;
10319        var y = doc.body.scrollTop || doc.documentElement.scrollTop;
10320        return SugarPosition(x, y);
10321      };
10322      var by = function (x, y, _DOC) {
10323        var doc = _DOC !== undefined ? _DOC.dom : document;
10324        var win = doc.defaultView;
10325        if (win) {
10326          win.scrollBy(x, y);
10327        }
10328      };
10329  
10330      var WindowBridge = function (win) {
10331        var elementFromPoint = function (x, y) {
10332          return SugarElement.fromPoint(SugarElement.fromDom(win.document), x, y);
10333        };
10334        var getRect = function (element) {
10335          return element.dom.getBoundingClientRect();
10336        };
10337        var getRangedRect = function (start, soffset, finish, foffset) {
10338          var sel = SimSelection.exact(start, soffset, finish, foffset);
10339          return getFirstRect(win, sel);
10340        };
10341        var getSelection = function () {
10342          return get$1(win).map(function (exactAdt) {
10343            return convertToRange(win, exactAdt);
10344          });
10345        };
10346        var fromSitus = function (situs) {
10347          var relative = SimSelection.relative(situs.start, situs.finish);
10348          return convertToRange(win, relative);
10349        };
10350        var situsFromPoint = function (x, y) {
10351          return getAtPoint(win, x, y).map(function (exact) {
10352            return Situs.create(exact.start, exact.soffset, exact.finish, exact.foffset);
10353          });
10354        };
10355        var clearSelection = function () {
10356          clear(win);
10357        };
10358        var collapseSelection = function (toStart) {
10359          if (toStart === void 0) {
10360            toStart = false;
10361          }
10362          get$1(win).each(function (sel) {
10363            return sel.fold(function (rng) {
10364              return rng.collapse(toStart);
10365            }, function (startSitu, finishSitu) {
10366              var situ = toStart ? startSitu : finishSitu;
10367              setRelative(win, situ, situ);
10368            }, function (start, soffset, finish, foffset) {
10369              var node = toStart ? start : finish;
10370              var offset = toStart ? soffset : foffset;
10371              setExact(win, node, offset, node, offset);
10372            });
10373          });
10374        };
10375        var selectNode = function (element) {
10376          setToElement(win, element, false);
10377        };
10378        var selectContents = function (element) {
10379          setToElement(win, element);
10380        };
10381        var setSelection = function (sel) {
10382          setExact(win, sel.start, sel.soffset, sel.finish, sel.foffset);
10383        };
10384        var setRelativeSelection = function (start, finish) {
10385          setRelative(win, start, finish);
10386        };
10387        var getInnerHeight = function () {
10388          return win.innerHeight;
10389        };
10390        var getScrollY = function () {
10391          var pos = get(SugarElement.fromDom(win.document));
10392          return pos.top;
10393        };
10394        var scrollBy = function (x, y) {
10395          by(x, y, SugarElement.fromDom(win.document));
10396        };
10397        return {
10398          elementFromPoint: elementFromPoint,
10399          getRect: getRect,
10400          getRangedRect: getRangedRect,
10401          getSelection: getSelection,
10402          fromSitus: fromSitus,
10403          situsFromPoint: situsFromPoint,
10404          clearSelection: clearSelection,
10405          collapseSelection: collapseSelection,
10406          setSelection: setSelection,
10407          setRelativeSelection: setRelativeSelection,
10408          selectNode: selectNode,
10409          selectContents: selectContents,
10410          getInnerHeight: getInnerHeight,
10411          getScrollY: getScrollY,
10412          scrollBy: scrollBy
10413        };
10414      };
10415  
10416      var rc = function (rows, cols) {
10417        return {
10418          rows: rows,
10419          cols: cols
10420        };
10421      };
10422      var mouse = function (win, container, isRoot, annotations) {
10423        var bridge = WindowBridge(win);
10424        var handlers = MouseSelection(bridge, container, isRoot, annotations);
10425        return {
10426          clearstate: handlers.clearstate,
10427          mousedown: handlers.mousedown,
10428          mouseover: handlers.mouseover,
10429          mouseup: handlers.mouseup
10430        };
10431      };
10432      var keyboard = function (win, container, isRoot, annotations) {
10433        var bridge = WindowBridge(win);
10434        var clearToNavigate = function () {
10435          annotations.clear(container);
10436          return Optional.none();
10437        };
10438        var keydown = function (event, start, soffset, finish, foffset, direction) {
10439          var realEvent = event.raw;
10440          var keycode = realEvent.which;
10441          var shiftKey = realEvent.shiftKey === true;
10442          var handler = retrieve$1(container, annotations.selectedSelector).fold(function () {
10443            if (isNavigation(keycode) && !shiftKey) {
10444              annotations.clearBeforeUpdate(container);
10445            }
10446            if (isDown(keycode) && shiftKey) {
10447              return curry(select, bridge, container, isRoot, down, finish, start, annotations.selectRange);
10448            } else if (isUp(keycode) && shiftKey) {
10449              return curry(select, bridge, container, isRoot, up, finish, start, annotations.selectRange);
10450            } else if (isDown(keycode)) {
10451              return curry(navigate, bridge, isRoot, down, finish, start, lastDownCheck);
10452            } else if (isUp(keycode)) {
10453              return curry(navigate, bridge, isRoot, up, finish, start, firstUpCheck);
10454            } else {
10455              return Optional.none;
10456            }
10457          }, function (selected) {
10458            var update$1 = function (attempts) {
10459              return function () {
10460                var navigation = findMap(attempts, function (delta) {
10461                  return update(delta.rows, delta.cols, container, selected, annotations);
10462                });
10463                return navigation.fold(function () {
10464                  return getEdges(container, annotations.firstSelectedSelector, annotations.lastSelectedSelector).map(function (edges) {
10465                    var relative = isDown(keycode) || direction.isForward(keycode) ? Situ.after : Situ.before;
10466                    bridge.setRelativeSelection(Situ.on(edges.first, 0), relative(edges.table));
10467                    annotations.clear(container);
10468                    return Response.create(Optional.none(), true);
10469                  });
10470                }, function (_) {
10471                  return Optional.some(Response.create(Optional.none(), true));
10472                });
10473              };
10474            };
10475            if (isDown(keycode) && shiftKey) {
10476              return update$1([rc(+1, 0)]);
10477            } else if (isUp(keycode) && shiftKey) {
10478              return update$1([rc(-1, 0)]);
10479            } else if (direction.isBackward(keycode) && shiftKey) {
10480              return update$1([
10481                rc(0, -1),
10482                rc(-1, 0)
10483              ]);
10484            } else if (direction.isForward(keycode) && shiftKey) {
10485              return update$1([
10486                rc(0, +1),
10487                rc(+1, 0)
10488              ]);
10489            } else if (isNavigation(keycode) && !shiftKey) {
10490              return clearToNavigate;
10491            } else {
10492              return Optional.none;
10493            }
10494          });
10495          return handler();
10496        };
10497        var keyup = function (event, start, soffset, finish, foffset) {
10498          return retrieve$1(container, annotations.selectedSelector).fold(function () {
10499            var realEvent = event.raw;
10500            var keycode = realEvent.which;
10501            var shiftKey = realEvent.shiftKey === true;
10502            if (!shiftKey) {
10503              return Optional.none();
10504            }
10505            if (isNavigation(keycode)) {
10506              return sync(container, isRoot, start, soffset, finish, foffset, annotations.selectRange);
10507            } else {
10508              return Optional.none();
10509            }
10510          }, Optional.none);
10511        };
10512        return {
10513          keydown: keydown,
10514          keyup: keyup
10515        };
10516      };
10517      var external = function (win, container, isRoot, annotations) {
10518        var bridge = WindowBridge(win);
10519        return function (start, finish) {
10520          annotations.clearBeforeUpdate(container);
10521          identify(start, finish, isRoot).each(function (cellSel) {
10522            var boxes = cellSel.boxes.getOr([]);
10523            annotations.selectRange(container, boxes, cellSel.start, cellSel.finish);
10524            bridge.selectContents(finish);
10525            bridge.collapseSelection();
10526          });
10527        };
10528      };
10529  
10530      var remove = function (element, classes) {
10531        each$2(classes, function (x) {
10532          remove$2(element, x);
10533        });
10534      };
10535  
10536      var addClass = function (clazz) {
10537        return function (element) {
10538          add(element, clazz);
10539        };
10540      };
10541      var removeClasses = function (classes) {
10542        return function (element) {
10543          remove(element, classes);
10544        };
10545      };
10546  
10547      var byClass = function (ephemera) {
10548        var addSelectionClass = addClass(ephemera.selected);
10549        var removeSelectionClasses = removeClasses([
10550          ephemera.selected,
10551          ephemera.lastSelected,
10552          ephemera.firstSelected
10553        ]);
10554        var clear = function (container) {
10555          var sels = descendants(container, ephemera.selectedSelector);
10556          each$2(sels, removeSelectionClasses);
10557        };
10558        var selectRange = function (container, cells, start, finish) {
10559          clear(container);
10560          each$2(cells, addSelectionClass);
10561          add(start, ephemera.firstSelected);
10562          add(finish, ephemera.lastSelected);
10563        };
10564        return {
10565          clearBeforeUpdate: clear,
10566          clear: clear,
10567          selectRange: selectRange,
10568          selectedSelector: ephemera.selectedSelector,
10569          firstSelectedSelector: ephemera.firstSelectedSelector,
10570          lastSelectedSelector: ephemera.lastSelectedSelector
10571        };
10572      };
10573      var byAttr = function (ephemera, onSelection, onClear) {
10574        var removeSelectionAttributes = function (element) {
10575          remove$7(element, ephemera.selected);
10576          remove$7(element, ephemera.firstSelected);
10577          remove$7(element, ephemera.lastSelected);
10578        };
10579        var addSelectionAttribute = function (element) {
10580          set$2(element, ephemera.selected, '1');
10581        };
10582        var clear = function (container) {
10583          clearBeforeUpdate(container);
10584          onClear();
10585        };
10586        var clearBeforeUpdate = function (container) {
10587          var sels = descendants(container, ephemera.selectedSelector + ',' + ephemera.firstSelectedSelector + ',' + ephemera.lastSelectedSelector);
10588          each$2(sels, removeSelectionAttributes);
10589        };
10590        var selectRange = function (container, cells, start, finish) {
10591          clear(container);
10592          each$2(cells, addSelectionAttribute);
10593          set$2(start, ephemera.firstSelected, '1');
10594          set$2(finish, ephemera.lastSelected, '1');
10595          onSelection(cells, start, finish);
10596        };
10597        return {
10598          clearBeforeUpdate: clearBeforeUpdate,
10599          clear: clear,
10600          selectRange: selectRange,
10601          selectedSelector: ephemera.selectedSelector,
10602          firstSelectedSelector: ephemera.firstSelectedSelector,
10603          lastSelectedSelector: ephemera.lastSelectedSelector
10604        };
10605      };
10606      var SelectionAnnotation = {
10607        byClass: byClass,
10608        byAttr: byAttr
10609      };
10610  
10611      var getUpOrLeftCells = function (grid, selectedCells) {
10612        var upGrid = grid.slice(0, selectedCells[selectedCells.length - 1].row + 1);
10613        var upDetails = toDetailList(upGrid);
10614        return bind$2(upDetails, function (detail) {
10615          var slicedCells = detail.cells.slice(0, selectedCells[selectedCells.length - 1].column + 1);
10616          return map$1(slicedCells, function (cell) {
10617            return cell.element;
10618          });
10619        });
10620      };
10621      var getDownOrRightCells = function (grid, selectedCells) {
10622        var downGrid = grid.slice(selectedCells[0].row + selectedCells[0].rowspan - 1, grid.length);
10623        var downDetails = toDetailList(downGrid);
10624        return bind$2(downDetails, function (detail) {
10625          var slicedCells = detail.cells.slice(selectedCells[0].column + selectedCells[0].colspan - 1, detail.cells.length);
10626          return map$1(slicedCells, function (cell) {
10627            return cell.element;
10628          });
10629        });
10630      };
10631      var getOtherCells = function (table, target, generators) {
10632        var warehouse = Warehouse.fromTable(table);
10633        var details = onCells(warehouse, target);
10634        return details.map(function (selectedCells) {
10635          var grid = toGrid(warehouse, generators, false);
10636          var upOrLeftCells = getUpOrLeftCells(grid, selectedCells);
10637          var downOrRightCells = getDownOrRightCells(grid, selectedCells);
10638          return {
10639            upOrLeftCells: upOrLeftCells,
10640            downOrRightCells: downOrRightCells
10641          };
10642        });
10643      };
10644  
10645      var global = tinymce.util.Tools.resolve('tinymce.Env');
10646  
10647      var hasInternalTarget = function (e) {
10648        return has(SugarElement.fromDom(e.target), 'ephox-snooker-resizer-bar') === false;
10649      };
10650      function CellSelection (editor, lazyResize, selectionTargets) {
10651        var onSelection = function (cells, start, finish) {
10652          selectionTargets.targets().each(function (targets) {
10653            var tableOpt = table(start);
10654            tableOpt.each(function (table) {
10655              var cloneFormats = getCloneElements(editor);
10656              var generators = cellOperations(noop, SugarElement.fromDom(editor.getDoc()), cloneFormats);
10657              var otherCells = getOtherCells(table, targets, generators);
10658              fireTableSelectionChange(editor, cells, start, finish, otherCells);
10659            });
10660          });
10661        };
10662        var onClear = function () {
10663          return fireTableSelectionClear(editor);
10664        };
10665        var annotations = SelectionAnnotation.byAttr(ephemera, onSelection, onClear);
10666        editor.on('init', function (_e) {
10667          var win = editor.getWin();
10668          var body = getBody(editor);
10669          var isRoot = getIsRoot(editor);
10670          var syncSelection = function () {
10671            var sel = editor.selection;
10672            var start = SugarElement.fromDom(sel.getStart());
10673            var end = SugarElement.fromDom(sel.getEnd());
10674            var shared = sharedOne(table, [
10675              start,
10676              end
10677            ]);
10678            shared.fold(function () {
10679              return annotations.clear(body);
10680            }, noop);
10681          };
10682          var mouseHandlers = mouse(win, body, isRoot, annotations);
10683          var keyHandlers = keyboard(win, body, isRoot, annotations);
10684          var external$1 = external(win, body, isRoot, annotations);
10685          var hasShiftKey = function (event) {
10686            return event.raw.shiftKey === true;
10687          };
10688          editor.on('TableSelectorChange', function (e) {
10689            return external$1(e.start, e.finish);
10690          });
10691          var handleResponse = function (event, response) {
10692            if (!hasShiftKey(event)) {
10693              return;
10694            }
10695            if (response.kill) {
10696              event.kill();
10697            }
10698            response.selection.each(function (ns) {
10699              var relative = SimSelection.relative(ns.start, ns.finish);
10700              var rng = asLtrRange(win, relative);
10701              editor.selection.setRng(rng);
10702            });
10703          };
10704          var keyup = function (event) {
10705            var wrappedEvent = fromRawEvent(event);
10706            if (wrappedEvent.raw.shiftKey && isNavigation(wrappedEvent.raw.which)) {
10707              var rng = editor.selection.getRng();
10708              var start = SugarElement.fromDom(rng.startContainer);
10709              var end = SugarElement.fromDom(rng.endContainer);
10710              keyHandlers.keyup(wrappedEvent, start, rng.startOffset, end, rng.endOffset).each(function (response) {
10711                handleResponse(wrappedEvent, response);
10712              });
10713            }
10714          };
10715          var keydown = function (event) {
10716            var wrappedEvent = fromRawEvent(event);
10717            lazyResize().each(function (resize) {
10718              return resize.hideBars();
10719            });
10720            var rng = editor.selection.getRng();
10721            var start = SugarElement.fromDom(rng.startContainer);
10722            var end = SugarElement.fromDom(rng.endContainer);
10723            var direction = onDirection(ltr, rtl)(SugarElement.fromDom(editor.selection.getStart()));
10724            keyHandlers.keydown(wrappedEvent, start, rng.startOffset, end, rng.endOffset, direction).each(function (response) {
10725              handleResponse(wrappedEvent, response);
10726            });
10727            lazyResize().each(function (resize) {
10728              return resize.showBars();
10729            });
10730          };
10731          var isLeftMouse = function (raw) {
10732            return raw.button === 0;
10733          };
10734          var isLeftButtonPressed = function (raw) {
10735            if (raw.buttons === undefined) {
10736              return true;
10737            }
10738            if (global.browser.isEdge() && raw.buttons === 0) {
10739              return true;
10740            }
10741            return (raw.buttons & 1) !== 0;
10742          };
10743          var dragStart = function (_e) {
10744            mouseHandlers.clearstate();
10745          };
10746          var mouseDown = function (e) {
10747            if (isLeftMouse(e) && hasInternalTarget(e)) {
10748              mouseHandlers.mousedown(fromRawEvent(e));
10749            }
10750          };
10751          var mouseOver = function (e) {
10752            if (isLeftButtonPressed(e) && hasInternalTarget(e)) {
10753              mouseHandlers.mouseover(fromRawEvent(e));
10754            }
10755          };
10756          var mouseUp = function (e) {
10757            if (isLeftMouse(e) && hasInternalTarget(e)) {
10758              mouseHandlers.mouseup(fromRawEvent(e));
10759            }
10760          };
10761          var getDoubleTap = function () {
10762            var lastTarget = Cell(SugarElement.fromDom(body));
10763            var lastTimeStamp = Cell(0);
10764            var touchEnd = function (t) {
10765              var target = SugarElement.fromDom(t.target);
10766              if (name(target) === 'td' || name(target) === 'th') {
10767                var lT = lastTarget.get();
10768                var lTS = lastTimeStamp.get();
10769                if (eq$1(lT, target) && t.timeStamp - lTS < 300) {
10770                  t.preventDefault();
10771                  external$1(target, target);
10772                }
10773              }
10774              lastTarget.set(target);
10775              lastTimeStamp.set(t.timeStamp);
10776            };
10777            return { touchEnd: touchEnd };
10778          };
10779          var doubleTap = getDoubleTap();
10780          editor.on('dragstart', dragStart);
10781          editor.on('mousedown', mouseDown);
10782          editor.on('mouseover', mouseOver);
10783          editor.on('mouseup', mouseUp);
10784          editor.on('touchend', doubleTap.touchEnd);
10785          editor.on('keyup', keyup);
10786          editor.on('keydown', keydown);
10787          editor.on('NodeChange', syncSelection);
10788        });
10789        return { clear: annotations.clear };
10790      }
10791  
10792      var child = function (scope, selector) {
10793        return child$1(scope, selector).isSome();
10794      };
10795  
10796      var getSelectionTargets = function (editor, selections) {
10797        var targets = Cell(Optional.none());
10798        var changeHandlers = Cell([]);
10799        var selectionDetails = Optional.none();
10800        var isCaption = isTag('caption');
10801        var isDisabledForSelection = function (key) {
10802          return selectionDetails.forall(function (details) {
10803            return !details[key];
10804          });
10805        };
10806        var getStart = function () {
10807          return getSelectionCellOrCaption(getSelectionStart(editor), getIsRoot(editor));
10808        };
10809        var getEnd = function () {
10810          return getSelectionCellOrCaption(getSelectionEnd(editor), getIsRoot(editor));
10811        };
10812        var findTargets = function () {
10813          return getStart().bind(function (startCellOrCaption) {
10814            return flatten(lift2(table(startCellOrCaption), getEnd().bind(table), function (startTable, endTable) {
10815              if (eq$1(startTable, endTable)) {
10816                if (isCaption(startCellOrCaption)) {
10817                  return Optional.some(noMenu(startCellOrCaption));
10818                } else {
10819                  return Optional.some(forMenu(selections, startTable, startCellOrCaption));
10820                }
10821              }
10822              return Optional.none();
10823            }));
10824          });
10825        };
10826        var getExtractedDetails = function (targets) {
10827          var tableOpt = table(targets.element);
10828          return tableOpt.map(function (table) {
10829            var warehouse = Warehouse.fromTable(table);
10830            var selectedCells = onCells(warehouse, targets).getOr([]);
10831            var locked = foldl(selectedCells, function (acc, cell) {
10832              if (cell.isLocked) {
10833                acc.onAny = true;
10834                if (cell.column === 0) {
10835                  acc.onFirst = true;
10836                } else if (cell.column + cell.colspan >= warehouse.grid.columns) {
10837                  acc.onLast = true;
10838                }
10839              }
10840              return acc;
10841            }, {
10842              onAny: false,
10843              onFirst: false,
10844              onLast: false
10845            });
10846            return {
10847              mergeable: onUnlockedMergable(warehouse, targets).isSome(),
10848              unmergeable: onUnlockedUnmergable(warehouse, targets).isSome(),
10849              locked: locked
10850            };
10851          });
10852        };
10853        var resetTargets = function () {
10854          targets.set(cached(findTargets)());
10855          selectionDetails = targets.get().bind(getExtractedDetails);
10856          each$2(changeHandlers.get(), function (handler) {
10857            return handler();
10858          });
10859        };
10860        var setupHandler = function (handler) {
10861          handler();
10862          changeHandlers.set(changeHandlers.get().concat([handler]));
10863          return function () {
10864            changeHandlers.set(filter$2(changeHandlers.get(), function (h) {
10865              return h !== handler;
10866            }));
10867          };
10868        };
10869        var onSetup = function (api, isDisabled) {
10870          return setupHandler(function () {
10871            return targets.get().fold(function () {
10872              api.setDisabled(true);
10873            }, function (targets) {
10874              api.setDisabled(isDisabled(targets));
10875            });
10876          });
10877        };
10878        var onSetupWithToggle = function (api, isDisabled, isActive) {
10879          return setupHandler(function () {
10880            return targets.get().fold(function () {
10881              api.setDisabled(true);
10882              api.setActive(false);
10883            }, function (targets) {
10884              api.setDisabled(isDisabled(targets));
10885              api.setActive(isActive(targets));
10886            });
10887          });
10888        };
10889        var isDisabledFromLocked = function (lockedDisable) {
10890          return selectionDetails.exists(function (details) {
10891            return details.locked[lockedDisable];
10892          });
10893        };
10894        var onSetupTable = function (api) {
10895          return onSetup(api, function (_) {
10896            return false;
10897          });
10898        };
10899        var onSetupCellOrRow = function (api) {
10900          return onSetup(api, function (targets) {
10901            return isCaption(targets.element);
10902          });
10903        };
10904        var onSetupColumn = function (lockedDisable) {
10905          return function (api) {
10906            return onSetup(api, function (targets) {
10907              return isCaption(targets.element) || isDisabledFromLocked(lockedDisable);
10908            });
10909          };
10910        };
10911        var onSetupPasteable = function (getClipboardData) {
10912          return function (api) {
10913            return onSetup(api, function (targets) {
10914              return isCaption(targets.element) || getClipboardData().isNone();
10915            });
10916          };
10917        };
10918        var onSetupPasteableColumn = function (getClipboardData, lockedDisable) {
10919          return function (api) {
10920            return onSetup(api, function (targets) {
10921              return isCaption(targets.element) || getClipboardData().isNone() || isDisabledFromLocked(lockedDisable);
10922            });
10923          };
10924        };
10925        var onSetupMergeable = function (api) {
10926          return onSetup(api, function (_targets) {
10927            return isDisabledForSelection('mergeable');
10928          });
10929        };
10930        var onSetupUnmergeable = function (api) {
10931          return onSetup(api, function (_targets) {
10932            return isDisabledForSelection('unmergeable');
10933          });
10934        };
10935        var onSetupTableWithCaption = function (api) {
10936          return onSetupWithToggle(api, never, function (targets) {
10937            var tableOpt = table(targets.element, getIsRoot(editor));
10938            return tableOpt.exists(function (table) {
10939              return child(table, 'caption');
10940            });
10941          });
10942        };
10943        var onSetupTableHeaders = function (command, headerType) {
10944          return function (api) {
10945            return onSetupWithToggle(api, function (targets) {
10946              return isCaption(targets.element);
10947            }, function () {
10948              return editor.queryCommandValue(command) === headerType;
10949            });
10950          };
10951        };
10952        var onSetupTableRowHeaders = onSetupTableHeaders('mceTableRowType', 'header');
10953        var onSetupTableColumnHeaders = onSetupTableHeaders('mceTableColType', 'th');
10954        editor.on('NodeChange ExecCommand TableSelectorChange', resetTargets);
10955        return {
10956          onSetupTable: onSetupTable,
10957          onSetupCellOrRow: onSetupCellOrRow,
10958          onSetupColumn: onSetupColumn,
10959          onSetupPasteable: onSetupPasteable,
10960          onSetupPasteableColumn: onSetupPasteableColumn,
10961          onSetupMergeable: onSetupMergeable,
10962          onSetupUnmergeable: onSetupUnmergeable,
10963          resetTargets: resetTargets,
10964          onSetupTableWithCaption: onSetupTableWithCaption,
10965          onSetupTableRowHeaders: onSetupTableRowHeaders,
10966          onSetupTableColumnHeaders: onSetupTableColumnHeaders,
10967          targets: targets.get
10968        };
10969      };
10970  
10971      var addButtons = function (editor, selections, selectionTargets, clipboard) {
10972        editor.ui.registry.addMenuButton('table', {
10973          tooltip: 'Table',
10974          icon: 'table',
10975          fetch: function (callback) {
10976            return callback('inserttable | cell row column | advtablesort | tableprops deletetable');
10977          }
10978        });
10979        var cmd = function (command) {
10980          return function () {
10981            return editor.execCommand(command);
10982          };
10983        };
10984        editor.ui.registry.addButton('tableprops', {
10985          tooltip: 'Table properties',
10986          onAction: cmd('mceTableProps'),
10987          icon: 'table',
10988          onSetup: selectionTargets.onSetupTable
10989        });
10990        editor.ui.registry.addButton('tabledelete', {
10991          tooltip: 'Delete table',
10992          onAction: cmd('mceTableDelete'),
10993          icon: 'table-delete-table',
10994          onSetup: selectionTargets.onSetupTable
10995        });
10996        editor.ui.registry.addButton('tablecellprops', {
10997          tooltip: 'Cell properties',
10998          onAction: cmd('mceTableCellProps'),
10999          icon: 'table-cell-properties',
11000          onSetup: selectionTargets.onSetupCellOrRow
11001        });
11002        editor.ui.registry.addButton('tablemergecells', {
11003          tooltip: 'Merge cells',
11004          onAction: cmd('mceTableMergeCells'),
11005          icon: 'table-merge-cells',
11006          onSetup: selectionTargets.onSetupMergeable
11007        });
11008        editor.ui.registry.addButton('tablesplitcells', {
11009          tooltip: 'Split cell',
11010          onAction: cmd('mceTableSplitCells'),
11011          icon: 'table-split-cells',
11012          onSetup: selectionTargets.onSetupUnmergeable
11013        });
11014        editor.ui.registry.addButton('tableinsertrowbefore', {
11015          tooltip: 'Insert row before',
11016          onAction: cmd('mceTableInsertRowBefore'),
11017          icon: 'table-insert-row-above',
11018          onSetup: selectionTargets.onSetupCellOrRow
11019        });
11020        editor.ui.registry.addButton('tableinsertrowafter', {
11021          tooltip: 'Insert row after',
11022          onAction: cmd('mceTableInsertRowAfter'),
11023          icon: 'table-insert-row-after',
11024          onSetup: selectionTargets.onSetupCellOrRow
11025        });
11026        editor.ui.registry.addButton('tabledeleterow', {
11027          tooltip: 'Delete row',
11028          onAction: cmd('mceTableDeleteRow'),
11029          icon: 'table-delete-row',
11030          onSetup: selectionTargets.onSetupCellOrRow
11031        });
11032        editor.ui.registry.addButton('tablerowprops', {
11033          tooltip: 'Row properties',
11034          onAction: cmd('mceTableRowProps'),
11035          icon: 'table-row-properties',
11036          onSetup: selectionTargets.onSetupCellOrRow
11037        });
11038        editor.ui.registry.addButton('tableinsertcolbefore', {
11039          tooltip: 'Insert column before',
11040          onAction: cmd('mceTableInsertColBefore'),
11041          icon: 'table-insert-column-before',
11042          onSetup: selectionTargets.onSetupColumn('onFirst')
11043        });
11044        editor.ui.registry.addButton('tableinsertcolafter', {
11045          tooltip: 'Insert column after',
11046          onAction: cmd('mceTableInsertColAfter'),
11047          icon: 'table-insert-column-after',
11048          onSetup: selectionTargets.onSetupColumn('onLast')
11049        });
11050        editor.ui.registry.addButton('tabledeletecol', {
11051          tooltip: 'Delete column',
11052          onAction: cmd('mceTableDeleteCol'),
11053          icon: 'table-delete-column',
11054          onSetup: selectionTargets.onSetupColumn('onAny')
11055        });
11056        editor.ui.registry.addButton('tablecutrow', {
11057          tooltip: 'Cut row',
11058          icon: 'cut-row',
11059          onAction: cmd('mceTableCutRow'),
11060          onSetup: selectionTargets.onSetupCellOrRow
11061        });
11062        editor.ui.registry.addButton('tablecopyrow', {
11063          tooltip: 'Copy row',
11064          icon: 'duplicate-row',
11065          onAction: cmd('mceTableCopyRow'),
11066          onSetup: selectionTargets.onSetupCellOrRow
11067        });
11068        editor.ui.registry.addButton('tablepasterowbefore', {
11069          tooltip: 'Paste row before',
11070          icon: 'paste-row-before',
11071          onAction: cmd('mceTablePasteRowBefore'),
11072          onSetup: selectionTargets.onSetupPasteable(clipboard.getRows)
11073        });
11074        editor.ui.registry.addButton('tablepasterowafter', {
11075          tooltip: 'Paste row after',
11076          icon: 'paste-row-after',
11077          onAction: cmd('mceTablePasteRowAfter'),
11078          onSetup: selectionTargets.onSetupPasteable(clipboard.getRows)
11079        });
11080        editor.ui.registry.addButton('tablecutcol', {
11081          tooltip: 'Cut column',
11082          icon: 'cut-column',
11083          onAction: cmd('mceTableCutCol'),
11084          onSetup: selectionTargets.onSetupColumn('onAny')
11085        });
11086        editor.ui.registry.addButton('tablecopycol', {
11087          tooltip: 'Copy column',
11088          icon: 'duplicate-column',
11089          onAction: cmd('mceTableCopyCol'),
11090          onSetup: selectionTargets.onSetupColumn('onAny')
11091        });
11092        editor.ui.registry.addButton('tablepastecolbefore', {
11093          tooltip: 'Paste column before',
11094          icon: 'paste-column-before',
11095          onAction: cmd('mceTablePasteColBefore'),
11096          onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onFirst')
11097        });
11098        editor.ui.registry.addButton('tablepastecolafter', {
11099          tooltip: 'Paste column after',
11100          icon: 'paste-column-after',
11101          onAction: cmd('mceTablePasteColAfter'),
11102          onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onLast')
11103        });
11104        editor.ui.registry.addButton('tableinsertdialog', {
11105          tooltip: 'Insert table',
11106          onAction: cmd('mceInsertTable'),
11107          icon: 'table'
11108        });
11109        var tableClassList = filterNoneItem(getTableClassList(editor));
11110        if (tableClassList.length !== 0) {
11111          editor.ui.registry.addMenuButton('tableclass', {
11112            icon: 'table-classes',
11113            tooltip: 'Table styles',
11114            fetch: generateMenuItemsCallback(editor, selections, tableClassList, 'tableclass', function (value) {
11115              return editor.execCommand('mceTableToggleClass', false, value);
11116            }),
11117            onSetup: selectionTargets.onSetupTable
11118          });
11119        }
11120        var tableCellClassList = filterNoneItem(getCellClassList(editor));
11121        if (tableCellClassList.length !== 0) {
11122          editor.ui.registry.addMenuButton('tablecellclass', {
11123            icon: 'table-cell-classes',
11124            tooltip: 'Cell styles',
11125            fetch: generateMenuItemsCallback(editor, selections, tableCellClassList, 'tablecellclass', function (value) {
11126              return editor.execCommand('mceTableCellToggleClass', false, value);
11127            }),
11128            onSetup: selectionTargets.onSetupCellOrRow
11129          });
11130        }
11131        editor.ui.registry.addMenuButton('tablecellvalign', {
11132          icon: 'vertical-align',
11133          tooltip: 'Vertical align',
11134          fetch: generateMenuItemsCallback(editor, selections, verticalAlignValues, 'tablecellverticalalign', applyTableCellStyle(editor, 'vertical-align')),
11135          onSetup: selectionTargets.onSetupCellOrRow
11136        });
11137        editor.ui.registry.addMenuButton('tablecellborderwidth', {
11138          icon: 'border-width',
11139          tooltip: 'Border width',
11140          fetch: generateMenuItemsCallback(editor, selections, getTableBorderWidths(editor), 'tablecellborderwidth', applyTableCellStyle(editor, 'border-width')),
11141          onSetup: selectionTargets.onSetupCellOrRow
11142        });
11143        editor.ui.registry.addMenuButton('tablecellborderstyle', {
11144          icon: 'border-style',
11145          tooltip: 'Border style',
11146          fetch: generateMenuItemsCallback(editor, selections, getTableBorderStyles(editor), 'tablecellborderstyle', applyTableCellStyle(editor, 'border-style')),
11147          onSetup: selectionTargets.onSetupCellOrRow
11148        });
11149        editor.ui.registry.addToggleButton('tablecaption', {
11150          tooltip: 'Table caption',
11151          onAction: cmd('mceTableToggleCaption'),
11152          icon: 'table-caption',
11153          onSetup: selectionTargets.onSetupTableWithCaption
11154        });
11155        editor.ui.registry.addMenuButton('tablecellbackgroundcolor', {
11156          icon: 'cell-background-color',
11157          tooltip: 'Background color',
11158          fetch: function (callback) {
11159            return callback(buildColorMenu(editor, getTableBackgroundColorMap(editor), 'background-color'));
11160          },
11161          onSetup: selectionTargets.onSetupCellOrRow
11162        });
11163        editor.ui.registry.addMenuButton('tablecellbordercolor', {
11164          icon: 'cell-border-color',
11165          tooltip: 'Border color',
11166          fetch: function (callback) {
11167            return callback(buildColorMenu(editor, getTableBorderColorMap(editor), 'border-color'));
11168          },
11169          onSetup: selectionTargets.onSetupCellOrRow
11170        });
11171        editor.ui.registry.addToggleButton('tablerowheader', {
11172          tooltip: 'Row header',
11173          icon: 'table-top-header',
11174          onAction: changeRowHeader(editor),
11175          onSetup: selectionTargets.onSetupTableRowHeaders
11176        });
11177        editor.ui.registry.addToggleButton('tablecolheader', {
11178          tooltip: 'Column header',
11179          icon: 'table-left-header',
11180          onAction: changeColumnHeader(editor),
11181          onSetup: selectionTargets.onSetupTableColumnHeaders
11182        });
11183      };
11184      var addToolbars = function (editor) {
11185        var isTable = function (table) {
11186          return editor.dom.is(table, 'table') && editor.getBody().contains(table);
11187        };
11188        var toolbar = getToolbar(editor);
11189        if (toolbar.length > 0) {
11190          editor.ui.registry.addContextToolbar('table', {
11191            predicate: isTable,
11192            items: toolbar,
11193            scope: 'node',
11194            position: 'node'
11195          });
11196        }
11197      };
11198  
11199      var addMenuItems = function (editor, selections, selectionTargets, clipboard) {
11200        var cmd = function (command) {
11201          return function () {
11202            return editor.execCommand(command);
11203          };
11204        };
11205        var insertTableAction = function (data) {
11206          editor.execCommand('mceInsertTable', false, {
11207            rows: data.numRows,
11208            columns: data.numColumns
11209          });
11210        };
11211        var tableProperties = {
11212          text: 'Table properties',
11213          onSetup: selectionTargets.onSetupTable,
11214          onAction: cmd('mceTableProps')
11215        };
11216        var deleteTable = {
11217          text: 'Delete table',
11218          icon: 'table-delete-table',
11219          onSetup: selectionTargets.onSetupTable,
11220          onAction: cmd('mceTableDelete')
11221        };
11222        editor.ui.registry.addMenuItem('tableinsertrowbefore', {
11223          text: 'Insert row before',
11224          icon: 'table-insert-row-above',
11225          onAction: cmd('mceTableInsertRowBefore'),
11226          onSetup: selectionTargets.onSetupCellOrRow
11227        });
11228        editor.ui.registry.addMenuItem('tableinsertrowafter', {
11229          text: 'Insert row after',
11230          icon: 'table-insert-row-after',
11231          onAction: cmd('mceTableInsertRowAfter'),
11232          onSetup: selectionTargets.onSetupCellOrRow
11233        });
11234        editor.ui.registry.addMenuItem('tabledeleterow', {
11235          text: 'Delete row',
11236          icon: 'table-delete-row',
11237          onAction: cmd('mceTableDeleteRow'),
11238          onSetup: selectionTargets.onSetupCellOrRow
11239        });
11240        editor.ui.registry.addMenuItem('tablerowprops', {
11241          text: 'Row properties',
11242          icon: 'table-row-properties',
11243          onAction: cmd('mceTableRowProps'),
11244          onSetup: selectionTargets.onSetupCellOrRow
11245        });
11246        editor.ui.registry.addMenuItem('tablecutrow', {
11247          text: 'Cut row',
11248          icon: 'cut-row',
11249          onAction: cmd('mceTableCutRow'),
11250          onSetup: selectionTargets.onSetupCellOrRow
11251        });
11252        editor.ui.registry.addMenuItem('tablecopyrow', {
11253          text: 'Copy row',
11254          icon: 'duplicate-row',
11255          onAction: cmd('mceTableCopyRow'),
11256          onSetup: selectionTargets.onSetupCellOrRow
11257        });
11258        editor.ui.registry.addMenuItem('tablepasterowbefore', {
11259          text: 'Paste row before',
11260          icon: 'paste-row-before',
11261          onAction: cmd('mceTablePasteRowBefore'),
11262          onSetup: selectionTargets.onSetupPasteable(clipboard.getRows)
11263        });
11264        editor.ui.registry.addMenuItem('tablepasterowafter', {
11265          text: 'Paste row after',
11266          icon: 'paste-row-after',
11267          onAction: cmd('mceTablePasteRowAfter'),
11268          onSetup: selectionTargets.onSetupPasteable(clipboard.getRows)
11269        });
11270        var row = {
11271          type: 'nestedmenuitem',
11272          text: 'Row',
11273          getSubmenuItems: constant('tableinsertrowbefore tableinsertrowafter tabledeleterow tablerowprops | tablecutrow tablecopyrow tablepasterowbefore tablepasterowafter')
11274        };
11275        editor.ui.registry.addMenuItem('tableinsertcolumnbefore', {
11276          text: 'Insert column before',
11277          icon: 'table-insert-column-before',
11278          onAction: cmd('mceTableInsertColBefore'),
11279          onSetup: selectionTargets.onSetupColumn('onFirst')
11280        });
11281        editor.ui.registry.addMenuItem('tableinsertcolumnafter', {
11282          text: 'Insert column after',
11283          icon: 'table-insert-column-after',
11284          onAction: cmd('mceTableInsertColAfter'),
11285          onSetup: selectionTargets.onSetupColumn('onLast')
11286        });
11287        editor.ui.registry.addMenuItem('tabledeletecolumn', {
11288          text: 'Delete column',
11289          icon: 'table-delete-column',
11290          onAction: cmd('mceTableDeleteCol'),
11291          onSetup: selectionTargets.onSetupColumn('onAny')
11292        });
11293        editor.ui.registry.addMenuItem('tablecutcolumn', {
11294          text: 'Cut column',
11295          icon: 'cut-column',
11296          onAction: cmd('mceTableCutCol'),
11297          onSetup: selectionTargets.onSetupColumn('onAny')
11298        });
11299        editor.ui.registry.addMenuItem('tablecopycolumn', {
11300          text: 'Copy column',
11301          icon: 'duplicate-column',
11302          onAction: cmd('mceTableCopyCol'),
11303          onSetup: selectionTargets.onSetupColumn('onAny')
11304        });
11305        editor.ui.registry.addMenuItem('tablepastecolumnbefore', {
11306          text: 'Paste column before',
11307          icon: 'paste-column-before',
11308          onAction: cmd('mceTablePasteColBefore'),
11309          onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onFirst')
11310        });
11311        editor.ui.registry.addMenuItem('tablepastecolumnafter', {
11312          text: 'Paste column after',
11313          icon: 'paste-column-after',
11314          onAction: cmd('mceTablePasteColAfter'),
11315          onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onLast')
11316        });
11317        var column = {
11318          type: 'nestedmenuitem',
11319          text: 'Column',
11320          getSubmenuItems: constant('tableinsertcolumnbefore tableinsertcolumnafter tabledeletecolumn | tablecutcolumn tablecopycolumn tablepastecolumnbefore tablepastecolumnafter')
11321        };
11322        editor.ui.registry.addMenuItem('tablecellprops', {
11323          text: 'Cell properties',
11324          icon: 'table-cell-properties',
11325          onAction: cmd('mceTableCellProps'),
11326          onSetup: selectionTargets.onSetupCellOrRow
11327        });
11328        editor.ui.registry.addMenuItem('tablemergecells', {
11329          text: 'Merge cells',
11330          icon: 'table-merge-cells',
11331          onAction: cmd('mceTableMergeCells'),
11332          onSetup: selectionTargets.onSetupMergeable
11333        });
11334        editor.ui.registry.addMenuItem('tablesplitcells', {
11335          text: 'Split cell',
11336          icon: 'table-split-cells',
11337          onAction: cmd('mceTableSplitCells'),
11338          onSetup: selectionTargets.onSetupUnmergeable
11339        });
11340        var cell = {
11341          type: 'nestedmenuitem',
11342          text: 'Cell',
11343          getSubmenuItems: constant('tablecellprops tablemergecells tablesplitcells')
11344        };
11345        if (hasTableGrid(editor) === false) {
11346          editor.ui.registry.addMenuItem('inserttable', {
11347            text: 'Table',
11348            icon: 'table',
11349            onAction: cmd('mceInsertTable')
11350          });
11351        } else {
11352          editor.ui.registry.addNestedMenuItem('inserttable', {
11353            text: 'Table',
11354            icon: 'table',
11355            getSubmenuItems: function () {
11356              return [{
11357                  type: 'fancymenuitem',
11358                  fancytype: 'inserttable',
11359                  onAction: insertTableAction
11360                }];
11361            }
11362          });
11363        }
11364        editor.ui.registry.addMenuItem('inserttabledialog', {
11365          text: 'Insert table',
11366          icon: 'table',
11367          onAction: cmd('mceInsertTable')
11368        });
11369        editor.ui.registry.addMenuItem('tableprops', tableProperties);
11370        editor.ui.registry.addMenuItem('deletetable', deleteTable);
11371        editor.ui.registry.addNestedMenuItem('row', row);
11372        editor.ui.registry.addNestedMenuItem('column', column);
11373        editor.ui.registry.addNestedMenuItem('cell', cell);
11374        editor.ui.registry.addContextMenu('table', {
11375          update: function () {
11376            selectionTargets.resetTargets();
11377            return selectionTargets.targets().fold(constant(''), function (targets) {
11378              if (name(targets.element) === 'caption') {
11379                return 'tableprops deletetable';
11380              } else {
11381                return 'cell row column | advtablesort | tableprops deletetable';
11382              }
11383            });
11384          }
11385        });
11386        var tableClassList = filterNoneItem(getTableClassList(editor));
11387        if (tableClassList.length !== 0) {
11388          editor.ui.registry.addNestedMenuItem('tableclass', {
11389            icon: 'table-classes',
11390            text: 'Table styles',
11391            getSubmenuItems: function () {
11392              return buildMenuItems(editor, selections, tableClassList, 'tableclass', function (value) {
11393                return editor.execCommand('mceTableToggleClass', false, value);
11394              });
11395            },
11396            onSetup: selectionTargets.onSetupTable
11397          });
11398        }
11399        var tableCellClassList = filterNoneItem(getCellClassList(editor));
11400        if (tableCellClassList.length !== 0) {
11401          editor.ui.registry.addNestedMenuItem('tablecellclass', {
11402            icon: 'table-cell-classes',
11403            text: 'Cell styles',
11404            getSubmenuItems: function () {
11405              return buildMenuItems(editor, selections, tableCellClassList, 'tablecellclass', function (value) {
11406                return editor.execCommand('mceTableCellToggleClass', false, value);
11407              });
11408            },
11409            onSetup: selectionTargets.onSetupCellOrRow
11410          });
11411        }
11412        editor.ui.registry.addNestedMenuItem('tablecellvalign', {
11413          icon: 'vertical-align',
11414          text: 'Vertical align',
11415          getSubmenuItems: function () {
11416            return buildMenuItems(editor, selections, verticalAlignValues, 'tablecellverticalalign', applyTableCellStyle(editor, 'vertical-align'));
11417          },
11418          onSetup: selectionTargets.onSetupCellOrRow
11419        });
11420        editor.ui.registry.addNestedMenuItem('tablecellborderwidth', {
11421          icon: 'border-width',
11422          text: 'Border width',
11423          getSubmenuItems: function () {
11424            return buildMenuItems(editor, selections, getTableBorderWidths(editor), 'tablecellborderwidth', applyTableCellStyle(editor, 'border-width'));
11425          },
11426          onSetup: selectionTargets.onSetupCellOrRow
11427        });
11428        editor.ui.registry.addNestedMenuItem('tablecellborderstyle', {
11429          icon: 'border-style',
11430          text: 'Border style',
11431          getSubmenuItems: function () {
11432            return buildMenuItems(editor, selections, getTableBorderStyles(editor), 'tablecellborderstyle', applyTableCellStyle(editor, 'border-style'));
11433          },
11434          onSetup: selectionTargets.onSetupCellOrRow
11435        });
11436        editor.ui.registry.addToggleMenuItem('tablecaption', {
11437          icon: 'table-caption',
11438          text: 'Table caption',
11439          onAction: cmd('mceTableToggleCaption'),
11440          onSetup: selectionTargets.onSetupTableWithCaption
11441        });
11442        editor.ui.registry.addNestedMenuItem('tablecellbackgroundcolor', {
11443          icon: 'cell-background-color',
11444          text: 'Background color',
11445          getSubmenuItems: function () {
11446            return buildColorMenu(editor, getTableBackgroundColorMap(editor), 'background-color');
11447          },
11448          onSetup: selectionTargets.onSetupCellOrRow
11449        });
11450        editor.ui.registry.addNestedMenuItem('tablecellbordercolor', {
11451          icon: 'cell-border-color',
11452          text: 'Border color',
11453          getSubmenuItems: function () {
11454            return buildColorMenu(editor, getTableBorderColorMap(editor), 'border-color');
11455          },
11456          onSetup: selectionTargets.onSetupCellOrRow
11457        });
11458        editor.ui.registry.addToggleMenuItem('tablerowheader', {
11459          text: 'Row header',
11460          icon: 'table-top-header',
11461          onAction: changeRowHeader(editor),
11462          onSetup: selectionTargets.onSetupTableRowHeaders
11463        });
11464        editor.ui.registry.addToggleMenuItem('tablecolheader', {
11465          text: 'Column header',
11466          icon: 'table-left-header',
11467          onAction: changeColumnHeader(editor),
11468          onSetup: selectionTargets.onSetupTableColumnHeaders
11469        });
11470      };
11471  
11472      var Plugin = function (editor) {
11473        var selections = Selections(function () {
11474          return getBody(editor);
11475        }, function () {
11476          return getSelectionCell(getSelectionStart(editor), getIsRoot(editor));
11477        }, ephemera.selectedSelector);
11478        var selectionTargets = getSelectionTargets(editor, selections);
11479        var resizeHandler = getResizeHandler(editor);
11480        var cellSelection = CellSelection(editor, resizeHandler.lazyResize, selectionTargets);
11481        var actions = TableActions(editor, cellSelection, resizeHandler.lazyWire);
11482        var clipboard = Clipboard();
11483        registerCommands(editor, actions, cellSelection, selections, clipboard);
11484        registerQueryCommands(editor, actions, selections);
11485        registerEvents(editor, selections, actions);
11486        addMenuItems(editor, selections, selectionTargets, clipboard);
11487        addButtons(editor, selections, selectionTargets, clipboard);
11488        addToolbars(editor);
11489        editor.on('PreInit', function () {
11490          editor.serializer.addTempAttr(ephemera.firstSelected);
11491          editor.serializer.addTempAttr(ephemera.lastSelected);
11492          registerFormats(editor);
11493        });
11494        if (hasTabNavigation(editor)) {
11495          editor.on('keydown', function (e) {
11496            handle$1(e, editor, cellSelection);
11497          });
11498        }
11499        editor.on('remove', function () {
11500          resizeHandler.destroy();
11501        });
11502        return getApi(editor, clipboard, resizeHandler, selectionTargets);
11503      };
11504      function Plugin$1 () {
11505        global$3.add('table', Plugin);
11506      }
11507  
11508      Plugin$1();
11509  
11510  }());