Subversion Repositories oidplus

/**

 * Copyright (c) Tiny Technologies, Inc. All rights reserved.

 * Licensed under the LGPL or a commercial license.

 * For LGPL see License.txt in the project root for license information.

 * For commercial licenses see https://www.tiny.cloud/

 *

 * Version: 5.10.9 (2023-11-15)

 */

(function () {

    'use strict';

    var Cell = function (initial) {

      var value = initial;

      var get = function () {

        return value;

      };

      var set = function (v) {

        value = v;

      };

      return {

        get: get,

        set: set

      };

    };

    var global$3 = tinymce.util.Tools.resolve('tinymce.PluginManager');

    var __assign = function () {

      __assign = Object.assign || function __assign(t) {

        for (var s, i = 1, n = arguments.length; i < n; i++) {

          s = arguments[i];

          for (var p in s)

            if (Object.prototype.hasOwnProperty.call(s, p))

              t[p] = s[p];

        }

        return t;

      };

      return __assign.apply(this, arguments);

    };

    var typeOf = function (x) {

      var t = typeof x;

      if (x === null) {

        return 'null';

      } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) {

        return 'array';

      } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) {

        return 'string';

      } else {

        return t;

      }

    };

    var isType$1 = function (type) {

      return function (value) {

        return typeOf(value) === type;

      };

    };

    var isSimpleType = function (type) {

      return function (value) {

        return typeof value === type;

      };

    };

    var isString = isType$1('string');

    var isArray = isType$1('array');

    var isBoolean = isSimpleType('boolean');

    var isNumber = isSimpleType('number');

    var noop = function () {

    };

    var constant = function (value) {

      return function () {

        return value;

      };

    };

    var identity = function (x) {

      return x;

    };

    var never = constant(false);

    var always = constant(true);

    var punctuationStr = '[!-#%-*,-\\/:;?@\\[-\\]_{}\xA1\xAB\xB7\xBB\xBF;\xB7\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1361-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u3008\u3009\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30\u2E31\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uff3f\uFF5B\uFF5D\uFF5F-\uFF65]';

    var punctuation$1 = constant(punctuationStr);

    var none = function () {

      return NONE;

    };

    var NONE = function () {

      var call = function (thunk) {

        return thunk();

      };

      var id = identity;

      var me = {

        fold: function (n, _s) {

          return n();

        },

        isSome: never,

        isNone: always,

        getOr: id,

        getOrThunk: call,

        getOrDie: function (msg) {

          throw new Error(msg || 'error: getOrDie called on none.');

        },

        getOrNull: constant(null),

        getOrUndefined: constant(undefined),

        or: id,

        orThunk: call,

        map: none,

        each: noop,

        bind: none,

        exists: never,

        forall: always,

        filter: function () {

          return none();

        },

        toArray: function () {

          return [];

        },

        toString: constant('none()')

      };

      return me;

    }();

    var some = function (a) {

      var constant_a = constant(a);

      var self = function () {

        return me;

      };

      var bind = function (f) {

        return f(a);

      };

      var me = {

        fold: function (n, s) {

          return s(a);

        },

        isSome: always,

        isNone: never,

        getOr: constant_a,

        getOrThunk: constant_a,

        getOrDie: constant_a,

        getOrNull: constant_a,

        getOrUndefined: constant_a,

        or: self,

        orThunk: self,

        map: function (f) {

          return some(f(a));

        },

        each: function (f) {

          f(a);

        },

        bind: bind,

        exists: bind,

        forall: bind,

        filter: function (f) {

          return f(a) ? me : NONE;

        },

        toArray: function () {

          return [a];

        },

        toString: function () {

          return 'some(' + a + ')';

        }

      };

      return me;

    };

    var from = function (value) {

      return value === null || value === undefined ? NONE : some(value);

    };

    var Optional = {

      some: some,

      none: none,

      from: from

    };

    var punctuation = punctuation$1;

    var global$2 = tinymce.util.Tools.resolve('tinymce.Env');

    var global$1 = tinymce.util.Tools.resolve('tinymce.util.Tools');

    var nativeSlice = Array.prototype.slice;

    var nativePush = Array.prototype.push;

    var map = function (xs, f) {

      var len = xs.length;

      var r = new Array(len);

      for (var i = 0; i < len; i++) {

        var x = xs[i];

        r[i] = f(x, i);

      }

      return r;

    };

    var each = function (xs, f) {

      for (var i = 0, len = xs.length; i < len; i++) {

        var x = xs[i];

        f(x, i);

      }

    };

    var eachr = function (xs, f) {

      for (var i = xs.length - 1; i >= 0; i--) {

        var x = xs[i];

        f(x, i);

      }

    };

    var groupBy = function (xs, f) {

      if (xs.length === 0) {

        return [];

      } else {

        var wasType = f(xs[0]);

        var r = [];

        var group = [];

        for (var i = 0, len = xs.length; i < len; i++) {

          var x = xs[i];

          var type = f(x);

          if (type !== wasType) {

            r.push(group);

            group = [];

          }

          wasType = type;

          group.push(x);

        }

        if (group.length !== 0) {

          r.push(group);

        }

        return r;

      }

    };

    var foldl = function (xs, f, acc) {

      each(xs, function (x, i) {

        acc = f(acc, x, i);

      });

      return acc;

    };

    var flatten = function (xs) {

      var r = [];

      for (var i = 0, len = xs.length; i < len; ++i) {

        if (!isArray(xs[i])) {

          throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);

        }

        nativePush.apply(r, xs[i]);

      }

      return r;

    };

    var bind = function (xs, f) {

      return flatten(map(xs, f));

    };

    var sort = function (xs, comparator) {

      var copy = nativeSlice.call(xs, 0);

      copy.sort(comparator);

      return copy;

    };

    var hasOwnProperty = Object.hasOwnProperty;

    var has = function (obj, key) {

      return hasOwnProperty.call(obj, key);

    };

    typeof window !== 'undefined' ? window : Function('return this;')();

    var DOCUMENT = 9;

    var DOCUMENT_FRAGMENT = 11;

    var ELEMENT = 1;

    var TEXT = 3;

    var type = function (element) {

      return element.dom.nodeType;

    };

    var isType = function (t) {

      return function (element) {

        return type(element) === t;

      };

    };

    var isText$1 = isType(TEXT);

    var rawSet = function (dom, key, value) {

      if (isString(value) || isBoolean(value) || isNumber(value)) {

        dom.setAttribute(key, value + '');

      } else {

        console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);

        throw new Error('Attribute value was not simple');

      }

    };

    var set = function (element, key, value) {

      rawSet(element.dom, key, value);

    };

    var compareDocumentPosition = function (a, b, match) {

      return (a.compareDocumentPosition(b) & match) !== 0;

    };

    var documentPositionPreceding = function (a, b) {

      return compareDocumentPosition(a, b, Node.DOCUMENT_POSITION_PRECEDING);

    };

    var fromHtml = function (html, scope) {

      var doc = scope || document;

      var div = doc.createElement('div');

      div.innerHTML = html;

      if (!div.hasChildNodes() || div.childNodes.length > 1) {

        console.error('HTML does not have a single root node', html);

        throw new Error('HTML must have a single root node');

      }

      return fromDom(div.childNodes[0]);

    };

    var fromTag = function (tag, scope) {

      var doc = scope || document;

      var node = doc.createElement(tag);

      return fromDom(node);

    };

    var fromText = function (text, scope) {

      var doc = scope || document;

      var node = doc.createTextNode(text);

      return fromDom(node);

    };

    var fromDom = function (node) {

      if (node === null || node === undefined) {

        throw new Error('Node cannot be null or undefined');

      }

      return { dom: node };

    };

    var fromPoint = function (docElm, x, y) {

      return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);

    };

    var SugarElement = {

      fromHtml: fromHtml,

      fromTag: fromTag,

      fromText: fromText,

      fromDom: fromDom,

      fromPoint: fromPoint

    };

    var bypassSelector = function (dom) {

      return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT || dom.childElementCount === 0;

    };

    var all = function (selector, scope) {

      var base = scope === undefined ? document : scope.dom;

      return bypassSelector(base) ? [] : map(base.querySelectorAll(selector), SugarElement.fromDom);

    };

    var parent = function (element) {

      return Optional.from(element.dom.parentNode).map(SugarElement.fromDom);

    };

    var children = function (element) {

      return map(element.dom.childNodes, SugarElement.fromDom);

    };

    var spot = function (element, offset) {

      return {

        element: element,

        offset: offset

      };

    };

    var leaf = function (element, offset) {

      var cs = children(element);

      return cs.length > 0 && offset < cs.length ? spot(cs[offset], 0) : spot(element, offset);

    };

    var before = function (marker, element) {

      var parent$1 = parent(marker);

      parent$1.each(function (v) {

        v.dom.insertBefore(element.dom, marker.dom);

      });

    };

    var append = function (parent, element) {

      parent.dom.appendChild(element.dom);

    };

    var wrap = function (element, wrapper) {

      before(element, wrapper);

      append(wrapper, element);

    };

    var NodeValue = function (is, name) {

      var get = function (element) {

        if (!is(element)) {

          throw new Error('Can only get ' + name + ' value of a ' + name + ' node');

        }

        return getOption(element).getOr('');

      };

      var getOption = function (element) {

        return is(element) ? Optional.from(element.dom.nodeValue) : Optional.none();

      };

      var set = function (element, value) {

        if (!is(element)) {

          throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node');

        }

        element.dom.nodeValue = value;

      };

      return {

        get: get,

        getOption: getOption,

        set: set

      };

    };

    var api = NodeValue(isText$1, 'text');

    var get$1 = function (element) {

      return api.get(element);

    };

    var descendants = function (scope, selector) {

      return all(selector, scope);

    };

    var global = tinymce.util.Tools.resolve('tinymce.dom.TreeWalker');

    var isSimpleBoundary = function (dom, node) {

      return dom.isBlock(node) || has(dom.schema.getShortEndedElements(), node.nodeName);

    };

    var isContentEditableFalse = function (dom, node) {

      return dom.getContentEditable(node) === 'false';

    };

    var isContentEditableTrueInCef = function (dom, node) {

      return dom.getContentEditable(node) === 'true' && dom.getContentEditableParent(node.parentNode) === 'false';

    };

    var isHidden = function (dom, node) {

      return !dom.isBlock(node) && has(dom.schema.getWhiteSpaceElements(), node.nodeName);

    };

    var isBoundary = function (dom, node) {

      return isSimpleBoundary(dom, node) || isContentEditableFalse(dom, node) || isHidden(dom, node) || isContentEditableTrueInCef(dom, node);

    };

    var isText = function (node) {

      return node.nodeType === 3;

    };

    var nuSection = function () {

      return {

        sOffset: 0,

        fOffset: 0,

        elements: []

      };

    };

    var toLeaf = function (node, offset) {

      return leaf(SugarElement.fromDom(node), offset);

    };

    var walk = function (dom, walkerFn, startNode, callbacks, endNode, skipStart) {

      if (skipStart === void 0) {

        skipStart = true;

      }

      var next = skipStart ? walkerFn(false) : startNode;

      while (next) {

        var isCefNode = isContentEditableFalse(dom, next);

        if (isCefNode || isHidden(dom, next)) {

          var stopWalking = isCefNode ? callbacks.cef(next) : callbacks.boundary(next);

          if (stopWalking) {

            break;

          } else {

            next = walkerFn(true);

            continue;

          }

        } else if (isSimpleBoundary(dom, next)) {

          if (callbacks.boundary(next)) {

            break;

          }

        } else if (isText(next)) {

          callbacks.text(next);

        }

        if (next === endNode) {

          break;

        } else {

          next = walkerFn(false);

        }

      }

    };

    var collectTextToBoundary = function (dom, section, node, rootNode, forwards) {

      if (isBoundary(dom, node)) {

        return;

      }

      var rootBlock = dom.getParent(rootNode, dom.isBlock);

      var walker = new global(node, rootBlock);

      var walkerFn = forwards ? walker.next.bind(walker) : walker.prev.bind(walker);

      walk(dom, walkerFn, node, {

        boundary: always,

        cef: always,

        text: function (next) {

          if (forwards) {

            section.fOffset += next.length;

          } else {

            section.sOffset += next.length;

          }

          section.elements.push(SugarElement.fromDom(next));

        }

      });

    };

    var collect = function (dom, rootNode, startNode, endNode, callbacks, skipStart) {

      if (skipStart === void 0) {

        skipStart = true;

      }

      var walker = new global(startNode, rootNode);

      var sections = [];

      var current = nuSection();

      collectTextToBoundary(dom, current, startNode, rootNode, false);

      var finishSection = function () {

        if (current.elements.length > 0) {

          sections.push(current);

          current = nuSection();

        }

        return false;

      };

      walk(dom, walker.next.bind(walker), startNode, {

        boundary: finishSection,

        cef: function (node) {

          finishSection();

          if (callbacks) {

            sections.push.apply(sections, callbacks.cef(node));

          }

          return false;

        },

        text: function (next) {

          current.elements.push(SugarElement.fromDom(next));

          if (callbacks) {

            callbacks.text(next, current);

          }

        }

      }, endNode, skipStart);

      if (endNode) {

        collectTextToBoundary(dom, current, endNode, rootNode, true);

      }

      finishSection();

      return sections;

    };

    var collectRangeSections = function (dom, rng) {

      var start = toLeaf(rng.startContainer, rng.startOffset);

      var startNode = start.element.dom;

      var end = toLeaf(rng.endContainer, rng.endOffset);

      var endNode = end.element.dom;

      return collect(dom, rng.commonAncestorContainer, startNode, endNode, {

        text: function (node, section) {

          if (node === endNode) {

            section.fOffset += node.length - end.offset;

          } else if (node === startNode) {

            section.sOffset += start.offset;

          }

        },

        cef: function (node) {

          var sections = bind(descendants(SugarElement.fromDom(node), '*[contenteditable=true]'), function (e) {

            var ceTrueNode = e.dom;

            return collect(dom, ceTrueNode, ceTrueNode);

          });

          return sort(sections, function (a, b) {

            return documentPositionPreceding(a.elements[0].dom, b.elements[0].dom) ? 1 : -1;

          });

        }

      }, false);

    };

    var fromRng = function (dom, rng) {

      return rng.collapsed ? [] : collectRangeSections(dom, rng);

    };

    var fromNode = function (dom, node) {

      var rng = dom.createRng();

      rng.selectNode(node);

      return fromRng(dom, rng);

    };

    var fromNodes = function (dom, nodes) {

      return bind(nodes, function (node) {

        return fromNode(dom, node);

      });

    };

    var find$2 = function (text, pattern, start, finish) {

      if (start === void 0) {

        start = 0;

      }

      if (finish === void 0) {

        finish = text.length;

      }

      var regex = pattern.regex;

      regex.lastIndex = start;

      var results = [];

      var match;

      while (match = regex.exec(text)) {

        var matchedText = match[pattern.matchIndex];

        var matchStart = match.index + match[0].indexOf(matchedText);

        var matchFinish = matchStart + matchedText.length;

        if (matchFinish > finish) {

          break;

        }

        results.push({

          start: matchStart,

          finish: matchFinish

        });

        regex.lastIndex = matchFinish;

      }

      return results;

    };

    var extract = function (elements, matches) {

      var nodePositions = foldl(elements, function (acc, element) {

        var content = get$1(element);

        var start = acc.last;

        var finish = start + content.length;

        var positions = bind(matches, function (match, matchIdx) {

          if (match.start < finish && match.finish > start) {

            return [{

                element: element,

                start: Math.max(start, match.start) - start,

                finish: Math.min(finish, match.finish) - start,

                matchId: matchIdx

              }];

          } else {

            return [];

          }

        });

        return {

          results: acc.results.concat(positions),

          last: finish

        };

      }, {

        results: [],

        last: 0

      }).results;

      return groupBy(nodePositions, function (position) {

        return position.matchId;

      });

    };

    var find$1 = function (pattern, sections) {

      return bind(sections, function (section) {

        var elements = section.elements;

        var content = map(elements, get$1).join('');

        var positions = find$2(content, pattern, section.sOffset, content.length - section.fOffset);

        return extract(elements, positions);

      });

    };

    var mark = function (matches, replacementNode) {

      eachr(matches, function (match, idx) {

        eachr(match, function (pos) {

          var wrapper = SugarElement.fromDom(replacementNode.cloneNode(false));

          set(wrapper, 'data-mce-index', idx);

          var textNode = pos.element.dom;

          if (textNode.length === pos.finish && pos.start === 0) {

            wrap(pos.element, wrapper);

          } else {

            if (textNode.length !== pos.finish) {

              textNode.splitText(pos.finish);

            }

            var matchNode = textNode.splitText(pos.start);

            wrap(SugarElement.fromDom(matchNode), wrapper);

          }

        });

      });

    };

    var findAndMark = function (dom, pattern, node, replacementNode) {

      var textSections = fromNode(dom, node);

      var matches = find$1(pattern, textSections);

      mark(matches, replacementNode);

      return matches.length;

    };

    var findAndMarkInSelection = function (dom, pattern, selection, replacementNode) {

      var bookmark = selection.getBookmark();

      var nodes = dom.select('td[data-mce-selected],th[data-mce-selected]');

      var textSections = nodes.length > 0 ? fromNodes(dom, nodes) : fromRng(dom, selection.getRng());

      var matches = find$1(pattern, textSections);

      mark(matches, replacementNode);

      selection.moveToBookmark(bookmark);

      return matches.length;

    };

    var getElmIndex = function (elm) {

      var value = elm.getAttribute('data-mce-index');

      if (typeof value === 'number') {

        return '' + value;

      }

      return value;

    };

    var markAllMatches = function (editor, currentSearchState, pattern, inSelection) {

      var marker = editor.dom.create('span', { 'data-mce-bogus': 1 });

      marker.className = 'mce-match-marker';