[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 Cell = function (initial) {
  13        var value = initial;
  14        var get = function () {
  15          return value;
  16        };
  17        var set = function (v) {
  18          value = v;
  19        };
  20        return {
  21          get: get,
  22          set: set
  23        };
  24      };
  25  
  26      var global$5 = tinymce.util.Tools.resolve('tinymce.PluginManager');
  27  
  28      var __assign = function () {
  29        __assign = Object.assign || function __assign(t) {
  30          for (var s, i = 1, n = arguments.length; i < n; i++) {
  31            s = arguments[i];
  32            for (var p in s)
  33              if (Object.prototype.hasOwnProperty.call(s, p))
  34                t[p] = s[p];
  35          }
  36          return t;
  37        };
  38        return __assign.apply(this, arguments);
  39      };
  40      function __spreadArray(to, from, pack) {
  41        if (pack || arguments.length === 2)
  42          for (var i = 0, l = from.length, ar; i < l; i++) {
  43            if (ar || !(i in from)) {
  44              if (!ar)
  45                ar = Array.prototype.slice.call(from, 0, i);
  46              ar[i] = from[i];
  47            }
  48          }
  49        return to.concat(ar || Array.prototype.slice.call(from));
  50      }
  51  
  52      var typeOf = function (x) {
  53        var t = typeof x;
  54        if (x === null) {
  55          return 'null';
  56        } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {
  57          return 'array';
  58        } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {
  59          return 'string';
  60        } else {
  61          return t;
  62        }
  63      };
  64      var isType = function (type) {
  65        return function (value) {
  66          return typeOf(value) === type;
  67        };
  68      };
  69      var isString = isType('string');
  70      var isObject = isType('object');
  71      var isArray = isType('array');
  72  
  73      var noop = function () {
  74      };
  75      var constant = function (value) {
  76        return function () {
  77          return value;
  78        };
  79      };
  80      var identity = function (x) {
  81        return x;
  82      };
  83      var die = function (msg) {
  84        return function () {
  85          throw new Error(msg);
  86        };
  87      };
  88      var never = constant(false);
  89      var always = constant(true);
  90  
  91      var none = function () {
  92        return NONE;
  93      };
  94      var NONE = function () {
  95        var call = function (thunk) {
  96          return thunk();
  97        };
  98        var id = identity;
  99        var me = {
 100          fold: function (n, _s) {
 101            return n();
 102          },
 103          isSome: never,
 104          isNone: always,
 105          getOr: id,
 106          getOrThunk: call,
 107          getOrDie: function (msg) {
 108            throw new Error(msg || 'error: getOrDie called on none.');
 109          },
 110          getOrNull: constant(null),
 111          getOrUndefined: constant(undefined),
 112          or: id,
 113          orThunk: call,
 114          map: none,
 115          each: noop,
 116          bind: none,
 117          exists: never,
 118          forall: always,
 119          filter: function () {
 120            return none();
 121          },
 122          toArray: function () {
 123            return [];
 124          },
 125          toString: constant('none()')
 126        };
 127        return me;
 128      }();
 129      var some = function (a) {
 130        var constant_a = constant(a);
 131        var self = function () {
 132          return me;
 133        };
 134        var bind = function (f) {
 135          return f(a);
 136        };
 137        var me = {
 138          fold: function (n, s) {
 139            return s(a);
 140          },
 141          isSome: always,
 142          isNone: never,
 143          getOr: constant_a,
 144          getOrThunk: constant_a,
 145          getOrDie: constant_a,
 146          getOrNull: constant_a,
 147          getOrUndefined: constant_a,
 148          or: self,
 149          orThunk: self,
 150          map: function (f) {
 151            return some(f(a));
 152          },
 153          each: function (f) {
 154            f(a);
 155          },
 156          bind: bind,
 157          exists: bind,
 158          forall: bind,
 159          filter: function (f) {
 160            return f(a) ? me : NONE;
 161          },
 162          toArray: function () {
 163            return [a];
 164          },
 165          toString: function () {
 166            return 'some(' + a + ')';
 167          }
 168        };
 169        return me;
 170      };
 171      var from = function (value) {
 172        return value === null || value === undefined ? NONE : some(value);
 173      };
 174      var Optional = {
 175        some: some,
 176        none: none,
 177        from: from
 178      };
 179  
 180      var nativeSlice = Array.prototype.slice;
 181      var nativeIndexOf = Array.prototype.indexOf;
 182      var rawIndexOf = function (ts, t) {
 183        return nativeIndexOf.call(ts, t);
 184      };
 185      var contains = function (xs, x) {
 186        return rawIndexOf(xs, x) > -1;
 187      };
 188      var map = function (xs, f) {
 189        var len = xs.length;
 190        var r = new Array(len);
 191        for (var i = 0; i < len; i++) {
 192          var x = xs[i];
 193          r[i] = f(x, i);
 194        }
 195        return r;
 196      };
 197      var each = function (xs, f) {
 198        for (var i = 0, len = xs.length; i < len; i++) {
 199          var x = xs[i];
 200          f(x, i);
 201        }
 202      };
 203      var eachr = function (xs, f) {
 204        for (var i = xs.length - 1; i >= 0; i--) {
 205          var x = xs[i];
 206          f(x, i);
 207        }
 208      };
 209      var filter = function (xs, pred) {
 210        var r = [];
 211        for (var i = 0, len = xs.length; i < len; i++) {
 212          var x = xs[i];
 213          if (pred(x, i)) {
 214            r.push(x);
 215          }
 216        }
 217        return r;
 218      };
 219      var foldr = function (xs, f, acc) {
 220        eachr(xs, function (x, i) {
 221          acc = f(acc, x, i);
 222        });
 223        return acc;
 224      };
 225      var foldl = function (xs, f, acc) {
 226        each(xs, function (x, i) {
 227          acc = f(acc, x, i);
 228        });
 229        return acc;
 230      };
 231      var findUntil = function (xs, pred, until) {
 232        for (var i = 0, len = xs.length; i < len; i++) {
 233          var x = xs[i];
 234          if (pred(x, i)) {
 235            return Optional.some(x);
 236          } else if (until(x, i)) {
 237            break;
 238          }
 239        }
 240        return Optional.none();
 241      };
 242      var find = function (xs, pred) {
 243        return findUntil(xs, pred, never);
 244      };
 245      var forall = function (xs, pred) {
 246        for (var i = 0, len = xs.length; i < len; ++i) {
 247          var x = xs[i];
 248          if (pred(x, i) !== true) {
 249            return false;
 250          }
 251        }
 252        return true;
 253      };
 254      var sort = function (xs, comparator) {
 255        var copy = nativeSlice.call(xs, 0);
 256        copy.sort(comparator);
 257        return copy;
 258      };
 259      var get$1 = function (xs, i) {
 260        return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
 261      };
 262      var head = function (xs) {
 263        return get$1(xs, 0);
 264      };
 265  
 266      var keys = Object.keys;
 267      var hasOwnProperty = Object.hasOwnProperty;
 268      var has = function (obj, key) {
 269        return hasOwnProperty.call(obj, key);
 270      };
 271  
 272      var generate$1 = function (cases) {
 273        if (!isArray(cases)) {
 274          throw new Error('cases must be an array');
 275        }
 276        if (cases.length === 0) {
 277          throw new Error('there must be at least one case');
 278        }
 279        var constructors = [];
 280        var adt = {};
 281        each(cases, function (acase, count) {
 282          var keys$1 = keys(acase);
 283          if (keys$1.length !== 1) {
 284            throw new Error('one and only one name per case');
 285          }
 286          var key = keys$1[0];
 287          var value = acase[key];
 288          if (adt[key] !== undefined) {
 289            throw new Error('duplicate key detected:' + key);
 290          } else if (key === 'cata') {
 291            throw new Error('cannot have a case named cata (sorry)');
 292          } else if (!isArray(value)) {
 293            throw new Error('case arguments must be an array');
 294          }
 295          constructors.push(key);
 296          adt[key] = function () {
 297            var args = [];
 298            for (var _i = 0; _i < arguments.length; _i++) {
 299              args[_i] = arguments[_i];
 300            }
 301            var argLength = args.length;
 302            if (argLength !== value.length) {
 303              throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength);
 304            }
 305            var match = function (branches) {
 306              var branchKeys = keys(branches);
 307              if (constructors.length !== branchKeys.length) {
 308                throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(','));
 309              }
 310              var allReqd = forall(constructors, function (reqKey) {
 311                return contains(branchKeys, reqKey);
 312              });
 313              if (!allReqd) {
 314                throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', '));
 315              }
 316              return branches[key].apply(null, args);
 317            };
 318            return {
 319              fold: function () {
 320                var foldArgs = [];
 321                for (var _i = 0; _i < arguments.length; _i++) {
 322                  foldArgs[_i] = arguments[_i];
 323                }
 324                if (foldArgs.length !== cases.length) {
 325                  throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length);
 326                }
 327                var target = foldArgs[count];
 328                return target.apply(null, args);
 329              },
 330              match: match,
 331              log: function (label) {
 332                console.log(label, {
 333                  constructors: constructors,
 334                  constructor: key,
 335                  params: args
 336                });
 337              }
 338            };
 339          };
 340        });
 341        return adt;
 342      };
 343      var Adt = { generate: generate$1 };
 344  
 345      Adt.generate([
 346        {
 347          bothErrors: [
 348            'error1',
 349            'error2'
 350          ]
 351        },
 352        {
 353          firstError: [
 354            'error1',
 355            'value2'
 356          ]
 357        },
 358        {
 359          secondError: [
 360            'value1',
 361            'error2'
 362          ]
 363        },
 364        {
 365          bothValues: [
 366            'value1',
 367            'value2'
 368          ]
 369        }
 370      ]);
 371      var partition = function (results) {
 372        var errors = [];
 373        var values = [];
 374        each(results, function (result) {
 375          result.fold(function (err) {
 376            errors.push(err);
 377          }, function (value) {
 378            values.push(value);
 379          });
 380        });
 381        return {
 382          errors: errors,
 383          values: values
 384        };
 385      };
 386  
 387      var value = function (o) {
 388        var or = function (_opt) {
 389          return value(o);
 390        };
 391        var orThunk = function (_f) {
 392          return value(o);
 393        };
 394        var map = function (f) {
 395          return value(f(o));
 396        };
 397        var mapError = function (_f) {
 398          return value(o);
 399        };
 400        var each = function (f) {
 401          f(o);
 402        };
 403        var bind = function (f) {
 404          return f(o);
 405        };
 406        var fold = function (_, onValue) {
 407          return onValue(o);
 408        };
 409        var exists = function (f) {
 410          return f(o);
 411        };
 412        var forall = function (f) {
 413          return f(o);
 414        };
 415        var toOptional = function () {
 416          return Optional.some(o);
 417        };
 418        return {
 419          isValue: always,
 420          isError: never,
 421          getOr: constant(o),
 422          getOrThunk: constant(o),
 423          getOrDie: constant(o),
 424          or: or,
 425          orThunk: orThunk,
 426          fold: fold,
 427          map: map,
 428          mapError: mapError,
 429          each: each,
 430          bind: bind,
 431          exists: exists,
 432          forall: forall,
 433          toOptional: toOptional
 434        };
 435      };
 436      var error$1 = function (message) {
 437        var getOrThunk = function (f) {
 438          return f();
 439        };
 440        var getOrDie = function () {
 441          return die(String(message))();
 442        };
 443        var or = identity;
 444        var orThunk = function (f) {
 445          return f();
 446        };
 447        var map = function (_f) {
 448          return error$1(message);
 449        };
 450        var mapError = function (f) {
 451          return error$1(f(message));
 452        };
 453        var bind = function (_f) {
 454          return error$1(message);
 455        };
 456        var fold = function (onError, _) {
 457          return onError(message);
 458        };
 459        return {
 460          isValue: never,
 461          isError: always,
 462          getOr: identity,
 463          getOrThunk: getOrThunk,
 464          getOrDie: getOrDie,
 465          or: or,
 466          orThunk: orThunk,
 467          fold: fold,
 468          map: map,
 469          mapError: mapError,
 470          each: noop,
 471          bind: bind,
 472          exists: never,
 473          forall: always,
 474          toOptional: Optional.none
 475        };
 476      };
 477      var fromOption = function (opt, err) {
 478        return opt.fold(function () {
 479          return error$1(err);
 480        }, value);
 481      };
 482      var Result = {
 483        value: value,
 484        error: error$1,
 485        fromOption: fromOption
 486      };
 487  
 488      var isInlinePattern = function (pattern) {
 489        return pattern.type === 'inline-command' || pattern.type === 'inline-format';
 490      };
 491      var isBlockPattern = function (pattern) {
 492        return pattern.type === 'block-command' || pattern.type === 'block-format';
 493      };
 494      var sortPatterns = function (patterns) {
 495        return sort(patterns, function (a, b) {
 496          if (a.start.length === b.start.length) {
 497            return 0;
 498          }
 499          return a.start.length > b.start.length ? -1 : 1;
 500        });
 501      };
 502      var normalizePattern = function (pattern) {
 503        var err = function (message) {
 504          return Result.error({
 505            message: message,
 506            pattern: pattern
 507          });
 508        };
 509        var formatOrCmd = function (name, onFormat, onCommand) {
 510          if (pattern.format !== undefined) {
 511            var formats = void 0;
 512            if (isArray(pattern.format)) {
 513              if (!forall(pattern.format, isString)) {
 514                return err(name + ' pattern has non-string items in the `format` array');
 515              }
 516              formats = pattern.format;
 517            } else if (isString(pattern.format)) {
 518              formats = [pattern.format];
 519            } else {
 520              return err(name + ' pattern has non-string `format` parameter');
 521            }
 522            return Result.value(onFormat(formats));
 523          } else if (pattern.cmd !== undefined) {
 524            if (!isString(pattern.cmd)) {
 525              return err(name + ' pattern has non-string `cmd` parameter');
 526            }
 527            return Result.value(onCommand(pattern.cmd, pattern.value));
 528          } else {
 529            return err(name + ' pattern is missing both `format` and `cmd` parameters');
 530          }
 531        };
 532        if (!isObject(pattern)) {
 533          return err('Raw pattern is not an object');
 534        }
 535        if (!isString(pattern.start)) {
 536          return err('Raw pattern is missing `start` parameter');
 537        }
 538        if (pattern.end !== undefined) {
 539          if (!isString(pattern.end)) {
 540            return err('Inline pattern has non-string `end` parameter');
 541          }
 542          if (pattern.start.length === 0 && pattern.end.length === 0) {
 543            return err('Inline pattern has empty `start` and `end` parameters');
 544          }
 545          var start_1 = pattern.start;
 546          var end_1 = pattern.end;
 547          if (end_1.length === 0) {
 548            end_1 = start_1;
 549            start_1 = '';
 550          }
 551          return formatOrCmd('Inline', function (format) {
 552            return {
 553              type: 'inline-format',
 554              start: start_1,
 555              end: end_1,
 556              format: format
 557            };
 558          }, function (cmd, value) {
 559            return {
 560              type: 'inline-command',
 561              start: start_1,
 562              end: end_1,
 563              cmd: cmd,
 564              value: value
 565            };
 566          });
 567        } else if (pattern.replacement !== undefined) {
 568          if (!isString(pattern.replacement)) {
 569            return err('Replacement pattern has non-string `replacement` parameter');
 570          }
 571          if (pattern.start.length === 0) {
 572            return err('Replacement pattern has empty `start` parameter');
 573          }
 574          return Result.value({
 575            type: 'inline-command',
 576            start: '',
 577            end: pattern.start,
 578            cmd: 'mceInsertContent',
 579            value: pattern.replacement
 580          });
 581        } else {
 582          if (pattern.start.length === 0) {
 583            return err('Block pattern has empty `start` parameter');
 584          }
 585          return formatOrCmd('Block', function (formats) {
 586            return {
 587              type: 'block-format',
 588              start: pattern.start,
 589              format: formats[0]
 590            };
 591          }, function (command, commandValue) {
 592            return {
 593              type: 'block-command',
 594              start: pattern.start,
 595              cmd: command,
 596              value: commandValue
 597            };
 598          });
 599        }
 600      };
 601      var denormalizePattern = function (pattern) {
 602        if (pattern.type === 'block-command') {
 603          return {
 604            start: pattern.start,
 605            cmd: pattern.cmd,
 606            value: pattern.value
 607          };
 608        } else if (pattern.type === 'block-format') {
 609          return {
 610            start: pattern.start,
 611            format: pattern.format
 612          };
 613        } else if (pattern.type === 'inline-command') {
 614          if (pattern.cmd === 'mceInsertContent' && pattern.start === '') {
 615            return {
 616              start: pattern.end,
 617              replacement: pattern.value
 618            };
 619          } else {
 620            return {
 621              start: pattern.start,
 622              end: pattern.end,
 623              cmd: pattern.cmd,
 624              value: pattern.value
 625            };
 626          }
 627        } else if (pattern.type === 'inline-format') {
 628          return {
 629            start: pattern.start,
 630            end: pattern.end,
 631            format: pattern.format.length === 1 ? pattern.format[0] : pattern.format
 632          };
 633        }
 634      };
 635      var createPatternSet = function (patterns) {
 636        return {
 637          inlinePatterns: filter(patterns, isInlinePattern),
 638          blockPatterns: sortPatterns(filter(patterns, isBlockPattern))
 639        };
 640      };
 641  
 642      var get = function (patternsState) {
 643        var setPatterns = function (newPatterns) {
 644          var normalized = partition(map(newPatterns, normalizePattern));
 645          if (normalized.errors.length > 0) {
 646            var firstError = normalized.errors[0];
 647            throw new Error(firstError.message + ':\n' + JSON.stringify(firstError.pattern, null, 2));
 648          }
 649          patternsState.set(createPatternSet(normalized.values));
 650        };
 651        var getPatterns = function () {
 652          return __spreadArray(__spreadArray([], map(patternsState.get().inlinePatterns, denormalizePattern), true), map(patternsState.get().blockPatterns, denormalizePattern), true);
 653        };
 654        return {
 655          setPatterns: setPatterns,
 656          getPatterns: getPatterns
 657        };
 658      };
 659  
 660      var Global = typeof window !== 'undefined' ? window : Function('return this;')();
 661  
 662      var error = function () {
 663        var args = [];
 664        for (var _i = 0; _i < arguments.length; _i++) {
 665          args[_i] = arguments[_i];
 666        }
 667        var console = Global.console;
 668        if (console) {
 669          if (console.error) {
 670            console.error.apply(console, args);
 671          } else {
 672            console.log.apply(console, args);
 673          }
 674        }
 675      };
 676      var defaultPatterns = [
 677        {
 678          start: '*',
 679          end: '*',
 680          format: 'italic'
 681        },
 682        {
 683          start: '**',
 684          end: '**',
 685          format: 'bold'
 686        },
 687        {
 688          start: '#',
 689          format: 'h1'
 690        },
 691        {
 692          start: '##',
 693          format: 'h2'
 694        },
 695        {
 696          start: '###',
 697          format: 'h3'
 698        },
 699        {
 700          start: '####',
 701          format: 'h4'
 702        },
 703        {
 704          start: '#####',
 705          format: 'h5'
 706        },
 707        {
 708          start: '######',
 709          format: 'h6'
 710        },
 711        {
 712          start: '1. ',
 713          cmd: 'InsertOrderedList'
 714        },
 715        {
 716          start: '* ',
 717          cmd: 'InsertUnorderedList'
 718        },
 719        {
 720          start: '- ',
 721          cmd: 'InsertUnorderedList'
 722        }
 723      ];
 724      var getPatternSet = function (editor) {
 725        var patterns = editor.getParam('textpattern_patterns', defaultPatterns, 'array');
 726        if (!isArray(patterns)) {
 727          error('The setting textpattern_patterns should be an array');
 728          return {
 729            inlinePatterns: [],
 730            blockPatterns: []
 731          };
 732        }
 733        var normalized = partition(map(patterns, normalizePattern));
 734        each(normalized.errors, function (err) {
 735          return error(err.message, err.pattern);
 736        });
 737        return createPatternSet(normalized.values);
 738      };
 739      var getForcedRootBlock = function (editor) {
 740        var block = editor.getParam('forced_root_block', 'p');
 741        if (block === false) {
 742          return '';
 743        } else if (block === true) {
 744          return 'p';
 745        } else {
 746          return block;
 747        }
 748      };
 749  
 750      var global$4 = tinymce.util.Tools.resolve('tinymce.util.Delay');
 751  
 752      var global$3 = tinymce.util.Tools.resolve('tinymce.util.VK');
 753  
 754      var zeroWidth = '\uFEFF';
 755      var nbsp = '\xA0';
 756  
 757      var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');
 758  
 759      var global$1 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
 760  
 761      var global = tinymce.util.Tools.resolve('tinymce.dom.TextSeeker');
 762  
 763      var point = function (container, offset) {
 764        return {
 765          container: container,
 766          offset: offset
 767        };
 768      };
 769  
 770      var isText = function (node) {
 771        return node.nodeType === Node.TEXT_NODE;
 772      };
 773      var cleanEmptyNodes = function (dom, node, isRoot) {
 774        if (node && dom.isEmpty(node) && !isRoot(node)) {
 775          var parent_1 = node.parentNode;
 776          dom.remove(node);
 777          cleanEmptyNodes(dom, parent_1, isRoot);
 778        }
 779      };
 780      var deleteRng = function (dom, rng, isRoot, clean) {
 781        if (clean === void 0) {
 782          clean = true;
 783        }
 784        var startParent = rng.startContainer.parentNode;
 785        var endParent = rng.endContainer.parentNode;
 786        rng.deleteContents();
 787        if (clean && !isRoot(rng.startContainer)) {
 788          if (isText(rng.startContainer) && rng.startContainer.data.length === 0) {
 789            dom.remove(rng.startContainer);
 790          }
 791          if (isText(rng.endContainer) && rng.endContainer.data.length === 0) {
 792            dom.remove(rng.endContainer);
 793          }
 794          cleanEmptyNodes(dom, startParent, isRoot);
 795          if (startParent !== endParent) {
 796            cleanEmptyNodes(dom, endParent, isRoot);
 797          }
 798        }
 799      };
 800      var isBlockFormatName = function (name, formatter) {
 801        var formatSet = formatter.get(name);
 802        return isArray(formatSet) && head(formatSet).exists(function (format) {
 803          return has(format, 'block');
 804        });
 805      };
 806      var isReplacementPattern = function (pattern) {
 807        return pattern.start.length === 0;
 808      };
 809      var getParentBlock = function (editor, rng) {
 810        var parentBlockOpt = Optional.from(editor.dom.getParent(rng.startContainer, editor.dom.isBlock));
 811        if (getForcedRootBlock(editor) === '') {
 812          return parentBlockOpt.orThunk(function () {
 813            return Optional.some(editor.getBody());
 814          });
 815        } else {
 816          return parentBlockOpt;
 817        }
 818      };
 819  
 820      var DOM = global$1.DOM;
 821      var alwaysNext = function (startNode) {
 822        return function (node) {
 823          return startNode === node ? -1 : 0;
 824        };
 825      };
 826      var isBoundary = function (dom) {
 827        return function (node) {
 828          return dom.isBlock(node) || contains([
 829            'BR',
 830            'IMG',
 831            'HR',
 832            'INPUT'
 833          ], node.nodeName) || dom.getContentEditable(node) === 'false';
 834        };
 835      };
 836      var textBefore = function (node, offset, rootNode) {
 837        if (isText(node) && offset >= 0) {
 838          return Optional.some(point(node, offset));
 839        } else {
 840          var textSeeker = global(DOM);
 841          return Optional.from(textSeeker.backwards(node, offset, alwaysNext(node), rootNode)).map(function (prev) {
 842            return point(prev.container, prev.container.data.length);
 843          });
 844        }
 845      };
 846      var textAfter = function (node, offset, rootNode) {
 847        if (isText(node) && offset >= node.length) {
 848          return Optional.some(point(node, offset));
 849        } else {
 850          var textSeeker = global(DOM);
 851          return Optional.from(textSeeker.forwards(node, offset, alwaysNext(node), rootNode)).map(function (prev) {
 852            return point(prev.container, 0);
 853          });
 854        }
 855      };
 856      var scanLeft = function (node, offset, rootNode) {
 857        if (!isText(node)) {
 858          return Optional.none();
 859        }
 860        var text = node.textContent;
 861        if (offset >= 0 && offset <= text.length) {
 862          return Optional.some(point(node, offset));
 863        } else {
 864          var textSeeker = global(DOM);
 865          return Optional.from(textSeeker.backwards(node, offset, alwaysNext(node), rootNode)).bind(function (prev) {
 866            var prevText = prev.container.data;
 867            return scanLeft(prev.container, offset + prevText.length, rootNode);
 868          });
 869        }
 870      };
 871      var scanRight = function (node, offset, rootNode) {
 872        if (!isText(node)) {
 873          return Optional.none();
 874        }
 875        var text = node.textContent;
 876        if (offset <= text.length) {
 877          return Optional.some(point(node, offset));
 878        } else {
 879          var textSeeker = global(DOM);
 880          return Optional.from(textSeeker.forwards(node, offset, alwaysNext(node), rootNode)).bind(function (next) {
 881            return scanRight(next.container, offset - text.length, rootNode);
 882          });
 883        }
 884      };
 885      var repeatLeft = function (dom, node, offset, process, rootNode) {
 886        var search = global(dom, isBoundary(dom));
 887        return Optional.from(search.backwards(node, offset, process, rootNode));
 888      };
 889  
 890      var generatePath = function (root, node, offset) {
 891        if (isText(node) && (offset < 0 || offset > node.data.length)) {
 892          return [];
 893        }
 894        var p = [offset];
 895        var current = node;
 896        while (current !== root && current.parentNode) {
 897          var parent_1 = current.parentNode;
 898          for (var i = 0; i < parent_1.childNodes.length; i++) {
 899            if (parent_1.childNodes[i] === current) {
 900              p.push(i);
 901              break;
 902            }
 903          }
 904          current = parent_1;
 905        }
 906        return current === root ? p.reverse() : [];
 907      };
 908      var generatePathRange = function (root, startNode, startOffset, endNode, endOffset) {
 909        var start = generatePath(root, startNode, startOffset);
 910        var end = generatePath(root, endNode, endOffset);
 911        return {
 912          start: start,
 913          end: end
 914        };
 915      };
 916      var resolvePath = function (root, path) {
 917        var nodePath = path.slice();
 918        var offset = nodePath.pop();
 919        var resolvedNode = foldl(nodePath, function (optNode, index) {
 920          return optNode.bind(function (node) {
 921            return Optional.from(node.childNodes[index]);
 922          });
 923        }, Optional.some(root));
 924        return resolvedNode.bind(function (node) {
 925          if (isText(node) && (offset < 0 || offset > node.data.length)) {
 926            return Optional.none();
 927          } else {
 928            return Optional.some({
 929              node: node,
 930              offset: offset
 931            });
 932          }
 933        });
 934      };
 935      var resolvePathRange = function (root, range) {
 936        return resolvePath(root, range.start).bind(function (_a) {
 937          var startNode = _a.node, startOffset = _a.offset;
 938          return resolvePath(root, range.end).map(function (_a) {
 939            var endNode = _a.node, endOffset = _a.offset;
 940            var rng = document.createRange();
 941            rng.setStart(startNode, startOffset);
 942            rng.setEnd(endNode, endOffset);
 943            return rng;
 944          });
 945        });
 946      };
 947      var generatePathRangeFromRange = function (root, range) {
 948        return generatePathRange(root, range.startContainer, range.startOffset, range.endContainer, range.endOffset);
 949      };
 950  
 951      var stripPattern = function (dom, block, pattern) {
 952        var firstTextNode = textAfter(block, 0, block);
 953        firstTextNode.each(function (spot) {
 954          var node = spot.container;
 955          scanRight(node, pattern.start.length, block).each(function (end) {
 956            var rng = dom.createRng();
 957            rng.setStart(node, 0);
 958            rng.setEnd(end.container, end.offset);
 959            deleteRng(dom, rng, function (e) {
 960              return e === block;
 961            });
 962          });
 963        });
 964      };
 965      var applyPattern$1 = function (editor, match) {
 966        var dom = editor.dom;
 967        var pattern = match.pattern;
 968        var rng = resolvePathRange(dom.getRoot(), match.range).getOrDie('Unable to resolve path range');
 969        getParentBlock(editor, rng).each(function (block) {
 970          if (pattern.type === 'block-format') {
 971            if (isBlockFormatName(pattern.format, editor.formatter)) {
 972              editor.undoManager.transact(function () {
 973                stripPattern(editor.dom, block, pattern);
 974                editor.formatter.apply(pattern.format);
 975              });
 976            }
 977          } else if (pattern.type === 'block-command') {
 978            editor.undoManager.transact(function () {
 979              stripPattern(editor.dom, block, pattern);
 980              editor.execCommand(pattern.cmd, false, pattern.value);
 981            });
 982          }
 983        });
 984        return true;
 985      };
 986      var findPattern$1 = function (patterns, text) {
 987        var nuText = text.replace(nbsp, ' ');
 988        return find(patterns, function (pattern) {
 989          return text.indexOf(pattern.start) === 0 || nuText.indexOf(pattern.start) === 0;
 990        });
 991      };
 992      var findPatterns$1 = function (editor, patterns) {
 993        var dom = editor.dom;
 994        var rng = editor.selection.getRng();
 995        return getParentBlock(editor, rng).filter(function (block) {
 996          var forcedRootBlock = getForcedRootBlock(editor);
 997          var matchesForcedRootBlock = forcedRootBlock === '' && dom.is(block, 'body') || dom.is(block, forcedRootBlock);
 998          return block !== null && matchesForcedRootBlock;
 999        }).bind(function (block) {
1000          var blockText = block.textContent;
1001          var matchedPattern = findPattern$1(patterns, blockText);
1002          return matchedPattern.map(function (pattern) {
1003            if (global$2.trim(blockText).length === pattern.start.length) {
1004              return [];
1005            }
1006            return [{
1007                pattern: pattern,
1008                range: generatePathRange(dom.getRoot(), block, 0, block, 0)
1009              }];
1010          });
1011        }).getOr([]);
1012      };
1013      var applyMatches$1 = function (editor, matches) {
1014        if (matches.length === 0) {
1015          return;
1016        }
1017        var bookmark = editor.selection.getBookmark();
1018        each(matches, function (match) {
1019          return applyPattern$1(editor, match);
1020        });
1021        editor.selection.moveToBookmark(bookmark);
1022      };
1023  
1024      var unique = 0;
1025      var generate = function (prefix) {
1026        var date = new Date();
1027        var time = date.getTime();
1028        var random = Math.floor(Math.random() * 1000000000);
1029        unique++;
1030        return prefix + '_' + random + unique + String(time);
1031      };
1032  
1033      var checkRange = function (str, substr, start) {
1034        return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr;
1035      };
1036      var endsWith = function (str, suffix) {
1037        return checkRange(str, suffix, str.length - suffix.length);
1038      };
1039  
1040      var newMarker = function (dom, id) {
1041        return dom.create('span', {
1042          'data-mce-type': 'bookmark',
1043          id: id
1044        });
1045      };
1046      var rangeFromMarker = function (dom, marker) {
1047        var rng = dom.createRng();
1048        rng.setStartAfter(marker.start);
1049        rng.setEndBefore(marker.end);
1050        return rng;
1051      };
1052      var createMarker = function (dom, markerPrefix, pathRange) {
1053        var rng = resolvePathRange(dom.getRoot(), pathRange).getOrDie('Unable to resolve path range');
1054        var startNode = rng.startContainer;
1055        var endNode = rng.endContainer;
1056        var textEnd = rng.endOffset === 0 ? endNode : endNode.splitText(rng.endOffset);
1057        var textStart = rng.startOffset === 0 ? startNode : startNode.splitText(rng.startOffset);
1058        return {
1059          prefix: markerPrefix,
1060          end: textEnd.parentNode.insertBefore(newMarker(dom, markerPrefix + '-end'), textEnd),
1061          start: textStart.parentNode.insertBefore(newMarker(dom, markerPrefix + '-start'), textStart)
1062        };
1063      };
1064      var removeMarker = function (dom, marker, isRoot) {
1065        cleanEmptyNodes(dom, dom.get(marker.prefix + '-end'), isRoot);
1066        cleanEmptyNodes(dom, dom.get(marker.prefix + '-start'), isRoot);
1067      };
1068  
1069      var matchesPattern = function (dom, block, patternContent) {
1070        return function (element, offset) {
1071          var text = element.data;
1072          var searchText = text.substring(0, offset);
1073          var startEndIndex = searchText.lastIndexOf(patternContent.charAt(patternContent.length - 1));
1074          var startIndex = searchText.lastIndexOf(patternContent);
1075          if (startIndex !== -1) {
1076            return startIndex + patternContent.length;
1077          } else if (startEndIndex !== -1) {
1078            return startEndIndex + 1;
1079          } else {
1080            return -1;
1081          }
1082        };
1083      };
1084      var findPatternStartFromSpot = function (dom, pattern, block, spot) {
1085        var startPattern = pattern.start;
1086        var startSpot = repeatLeft(dom, spot.container, spot.offset, matchesPattern(dom, block, startPattern), block);
1087        return startSpot.bind(function (spot) {
1088          if (spot.offset >= startPattern.length) {
1089            var rng = dom.createRng();
1090            rng.setStart(spot.container, spot.offset - startPattern.length);
1091            rng.setEnd(spot.container, spot.offset);
1092            return Optional.some(rng);
1093          } else {
1094            var offset = spot.offset - startPattern.length;
1095            return scanLeft(spot.container, offset, block).map(function (nextSpot) {
1096              var rng = dom.createRng();
1097              rng.setStart(nextSpot.container, nextSpot.offset);
1098              rng.setEnd(spot.container, spot.offset);
1099              return rng;
1100            }).filter(function (rng) {
1101              return rng.toString() === startPattern;
1102            }).orThunk(function () {
1103              return findPatternStartFromSpot(dom, pattern, block, point(spot.container, 0));
1104            });
1105          }
1106        });
1107      };
1108      var findPatternStart = function (dom, pattern, node, offset, block, requireGap) {
1109        if (requireGap === void 0) {
1110          requireGap = false;
1111        }
1112        if (pattern.start.length === 0 && !requireGap) {
1113          var rng = dom.createRng();
1114          rng.setStart(node, offset);
1115          rng.setEnd(node, offset);
1116          return Optional.some(rng);
1117        }
1118        return textBefore(node, offset, block).bind(function (spot) {
1119          var start = findPatternStartFromSpot(dom, pattern, block, spot);
1120          return start.bind(function (startRange) {
1121            if (requireGap) {
1122              if (startRange.endContainer === spot.container && startRange.endOffset === spot.offset) {
1123                return Optional.none();
1124              } else if (spot.offset === 0 && startRange.endContainer.textContent.length === startRange.endOffset) {
1125                return Optional.none();
1126              }
1127            }
1128            return Optional.some(startRange);
1129          });
1130        });
1131      };
1132      var findPattern = function (editor, block, details) {
1133        var dom = editor.dom;
1134        var root = dom.getRoot();
1135        var pattern = details.pattern;
1136        var endNode = details.position.container;
1137        var endOffset = details.position.offset;
1138        return scanLeft(endNode, endOffset - details.pattern.end.length, block).bind(function (spot) {
1139          var endPathRng = generatePathRange(root, spot.container, spot.offset, endNode, endOffset);
1140          if (isReplacementPattern(pattern)) {
1141            return Optional.some({
1142              matches: [{
1143                  pattern: pattern,
1144                  startRng: endPathRng,
1145                  endRng: endPathRng
1146                }],
1147              position: spot
1148            });
1149          } else {
1150            var resultsOpt = findPatternsRec(editor, details.remainingPatterns, spot.container, spot.offset, block);
1151            var results_1 = resultsOpt.getOr({
1152              matches: [],
1153              position: spot
1154            });
1155            var pos = results_1.position;
1156            var start = findPatternStart(dom, pattern, pos.container, pos.offset, block, resultsOpt.isNone());
1157            return start.map(function (startRng) {
1158              var startPathRng = generatePathRangeFromRange(root, startRng);
1159              return {
1160                matches: results_1.matches.concat([{
1161                    pattern: pattern,
1162                    startRng: startPathRng,
1163                    endRng: endPathRng
1164                  }]),
1165                position: point(startRng.startContainer, startRng.startOffset)
1166              };
1167            });
1168          }
1169        });
1170      };
1171      var findPatternsRec = function (editor, patterns, node, offset, block) {
1172        var dom = editor.dom;
1173        return textBefore(node, offset, dom.getRoot()).bind(function (endSpot) {
1174          var rng = dom.createRng();
1175          rng.setStart(block, 0);
1176          rng.setEnd(node, offset);
1177          var text = rng.toString();
1178          for (var i = 0; i < patterns.length; i++) {
1179            var pattern = patterns[i];
1180            if (!endsWith(text, pattern.end)) {
1181              continue;
1182            }
1183            var patternsWithoutCurrent = patterns.slice();
1184            patternsWithoutCurrent.splice(i, 1);
1185            var result = findPattern(editor, block, {
1186              pattern: pattern,
1187              remainingPatterns: patternsWithoutCurrent,
1188              position: endSpot
1189            });
1190            if (result.isSome()) {
1191              return result;
1192            }
1193          }
1194          return Optional.none();
1195        });
1196      };
1197      var applyPattern = function (editor, pattern, patternRange) {
1198        editor.selection.setRng(patternRange);
1199        if (pattern.type === 'inline-format') {
1200          each(pattern.format, function (format) {
1201            editor.formatter.apply(format);
1202          });
1203        } else {
1204          editor.execCommand(pattern.cmd, false, pattern.value);
1205        }
1206      };
1207      var applyReplacementPattern = function (editor, pattern, marker, isRoot) {
1208        var markerRange = rangeFromMarker(editor.dom, marker);
1209        deleteRng(editor.dom, markerRange, isRoot);
1210        applyPattern(editor, pattern, markerRange);
1211      };
1212      var applyPatternWithContent = function (editor, pattern, startMarker, endMarker, isRoot) {
1213        var dom = editor.dom;
1214        var markerEndRange = rangeFromMarker(dom, endMarker);
1215        var markerStartRange = rangeFromMarker(dom, startMarker);
1216        deleteRng(dom, markerStartRange, isRoot);
1217        deleteRng(dom, markerEndRange, isRoot);
1218        var patternMarker = {
1219          prefix: startMarker.prefix,
1220          start: startMarker.end,
1221          end: endMarker.start
1222        };
1223        var patternRange = rangeFromMarker(dom, patternMarker);
1224        applyPattern(editor, pattern, patternRange);
1225      };
1226      var addMarkers = function (dom, matches) {
1227        var markerPrefix = generate('mce_textpattern');
1228        var matchesWithEnds = foldr(matches, function (acc, match) {
1229          var endMarker = createMarker(dom, markerPrefix + ('_end' + acc.length), match.endRng);
1230          return acc.concat([__assign(__assign({}, match), { endMarker: endMarker })]);
1231        }, []);
1232        return foldr(matchesWithEnds, function (acc, match) {
1233          var idx = matchesWithEnds.length - acc.length - 1;
1234          var startMarker = isReplacementPattern(match.pattern) ? match.endMarker : createMarker(dom, markerPrefix + ('_start' + idx), match.startRng);
1235          return acc.concat([__assign(__assign({}, match), { startMarker: startMarker })]);
1236        }, []);
1237      };
1238      var findPatterns = function (editor, patterns, space) {
1239        var rng = editor.selection.getRng();
1240        if (rng.collapsed === false) {
1241          return [];
1242        }
1243        return getParentBlock(editor, rng).bind(function (block) {
1244          var offset = rng.startOffset - (space ? 1 : 0);
1245          return findPatternsRec(editor, patterns, rng.startContainer, offset, block);
1246        }).fold(function () {
1247          return [];
1248        }, function (result) {
1249          return result.matches;
1250        });
1251      };
1252      var applyMatches = function (editor, matches) {
1253        if (matches.length === 0) {
1254          return;
1255        }
1256        var dom = editor.dom;
1257        var bookmark = editor.selection.getBookmark();
1258        var matchesWithMarkers = addMarkers(dom, matches);
1259        each(matchesWithMarkers, function (match) {
1260          var block = dom.getParent(match.startMarker.start, dom.isBlock);
1261          var isRoot = function (node) {
1262            return node === block;
1263          };
1264          if (isReplacementPattern(match.pattern)) {
1265            applyReplacementPattern(editor, match.pattern, match.endMarker, isRoot);
1266          } else {
1267            applyPatternWithContent(editor, match.pattern, match.startMarker, match.endMarker, isRoot);
1268          }
1269          removeMarker(dom, match.endMarker, isRoot);
1270          removeMarker(dom, match.startMarker, isRoot);
1271        });
1272        editor.selection.moveToBookmark(bookmark);
1273      };
1274  
1275      var handleEnter = function (editor, patternSet) {
1276        if (!editor.selection.isCollapsed()) {
1277          return false;
1278        }
1279        var inlineMatches = findPatterns(editor, patternSet.inlinePatterns, false);
1280        var blockMatches = findPatterns$1(editor, patternSet.blockPatterns);
1281        if (blockMatches.length > 0 || inlineMatches.length > 0) {
1282          editor.undoManager.add();
1283          editor.undoManager.extra(function () {
1284            editor.execCommand('mceInsertNewLine');
1285          }, function () {
1286            editor.insertContent(zeroWidth);
1287            applyMatches(editor, inlineMatches);
1288            applyMatches$1(editor, blockMatches);
1289            var range = editor.selection.getRng();
1290            var spot = textBefore(range.startContainer, range.startOffset, editor.dom.getRoot());
1291            editor.execCommand('mceInsertNewLine');
1292            spot.each(function (s) {
1293              var node = s.container;
1294              if (node.data.charAt(s.offset - 1) === zeroWidth) {
1295                node.deleteData(s.offset - 1, 1);
1296                cleanEmptyNodes(editor.dom, node.parentNode, function (e) {
1297                  return e === editor.dom.getRoot();
1298                });
1299              }
1300            });
1301          });
1302          return true;
1303        }
1304        return false;
1305      };
1306      var handleInlineKey = function (editor, patternSet) {
1307        var inlineMatches = findPatterns(editor, patternSet.inlinePatterns, true);
1308        if (inlineMatches.length > 0) {
1309          editor.undoManager.transact(function () {
1310            applyMatches(editor, inlineMatches);
1311          });
1312        }
1313      };
1314      var checkKeyEvent = function (codes, event, predicate) {
1315        for (var i = 0; i < codes.length; i++) {
1316          if (predicate(codes[i], event)) {
1317            return true;
1318          }
1319        }
1320        return false;
1321      };
1322      var checkKeyCode = function (codes, event) {
1323        return checkKeyEvent(codes, event, function (code, event) {
1324          return code === event.keyCode && global$3.modifierPressed(event) === false;
1325        });
1326      };
1327      var checkCharCode = function (chars, event) {
1328        return checkKeyEvent(chars, event, function (chr, event) {
1329          return chr.charCodeAt(0) === event.charCode;
1330        });
1331      };
1332  
1333      var setup = function (editor, patternsState) {
1334        var charCodes = [
1335          ',',
1336          '.',
1337          ';',
1338          ':',
1339          '!',
1340          '?'
1341        ];
1342        var keyCodes = [32];
1343        editor.on('keydown', function (e) {
1344          if (e.keyCode === 13 && !global$3.modifierPressed(e)) {
1345            if (handleEnter(editor, patternsState.get())) {
1346              e.preventDefault();
1347            }
1348          }
1349        }, true);
1350        editor.on('keyup', function (e) {
1351          if (checkKeyCode(keyCodes, e)) {
1352            handleInlineKey(editor, patternsState.get());
1353          }
1354        });
1355        editor.on('keypress', function (e) {
1356          if (checkCharCode(charCodes, e)) {
1357            global$4.setEditorTimeout(editor, function () {
1358              handleInlineKey(editor, patternsState.get());
1359            });
1360          }
1361        });
1362      };
1363  
1364      function Plugin () {
1365        global$5.add('textpattern', function (editor) {
1366          var patternsState = Cell(getPatternSet(editor));
1367          setup(editor, patternsState);
1368          return get(patternsState);
1369        });
1370      }
1371  
1372      Plugin();
1373  
1374  }());