From 7086111ad4dd997e12a3220e1ee60c9b9bcf0bb8 Mon Sep 17 00:00:00 2001 From: Charles Date: Tue, 7 Jan 2020 13:06:14 +0100 Subject: Added wordpress --- .../wp-includes/js/tinymce/themes/modern/theme.js | 9636 ++++++++++++++++++++ 1 file changed, 9636 insertions(+) create mode 100644 srcs/wordpress/wp-includes/js/tinymce/themes/modern/theme.js (limited to 'srcs/wordpress/wp-includes/js/tinymce/themes/modern/theme.js') diff --git a/srcs/wordpress/wp-includes/js/tinymce/themes/modern/theme.js b/srcs/wordpress/wp-includes/js/tinymce/themes/modern/theme.js new file mode 100644 index 0000000..0f901db --- /dev/null +++ b/srcs/wordpress/wp-includes/js/tinymce/themes/modern/theme.js @@ -0,0 +1,9636 @@ +(function () { +var modern = (function (domGlobals) { + 'use strict'; + + var global = tinymce.util.Tools.resolve('tinymce.ThemeManager'); + + var global$1 = tinymce.util.Tools.resolve('tinymce.EditorManager'); + + var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools'); + + var isBrandingEnabled = function (editor) { + return editor.getParam('branding', true, 'boolean'); + }; + var hasMenubar = function (editor) { + return getMenubar(editor) !== false; + }; + var getMenubar = function (editor) { + return editor.getParam('menubar'); + }; + var hasStatusbar = function (editor) { + return editor.getParam('statusbar', true, 'boolean'); + }; + var getToolbarSize = function (editor) { + return editor.getParam('toolbar_items_size'); + }; + var isReadOnly = function (editor) { + return editor.getParam('readonly', false, 'boolean'); + }; + var getFixedToolbarContainer = function (editor) { + return editor.getParam('fixed_toolbar_container'); + }; + var getInlineToolbarPositionHandler = function (editor) { + return editor.getParam('inline_toolbar_position_handler'); + }; + var getMenu = function (editor) { + return editor.getParam('menu'); + }; + var getRemovedMenuItems = function (editor) { + return editor.getParam('removed_menuitems', ''); + }; + var getMinWidth = function (editor) { + return editor.getParam('min_width', 100, 'number'); + }; + var getMinHeight = function (editor) { + return editor.getParam('min_height', 100, 'number'); + }; + var getMaxWidth = function (editor) { + return editor.getParam('max_width', 65535, 'number'); + }; + var getMaxHeight = function (editor) { + return editor.getParam('max_height', 65535, 'number'); + }; + var isSkinDisabled = function (editor) { + return editor.settings.skin === false; + }; + var isInline = function (editor) { + return editor.getParam('inline', false, 'boolean'); + }; + var getResize = function (editor) { + var resize = editor.getParam('resize', 'vertical'); + if (resize === false) { + return 'none'; + } else if (resize === 'both') { + return 'both'; + } else { + return 'vertical'; + } + }; + var getSkinUrl = function (editor) { + var settings = editor.settings; + var skin = settings.skin; + var skinUrl = settings.skin_url; + if (skin !== false) { + var skinName = skin ? skin : 'lightgray'; + if (skinUrl) { + skinUrl = editor.documentBaseURI.toAbsolute(skinUrl); + } else { + skinUrl = global$1.baseURL + '/skins/' + skinName; + } + } + return skinUrl; + }; + var getIndexedToolbars = function (settings, defaultToolbar) { + var toolbars = []; + for (var i = 1; i < 10; i++) { + var toolbar = settings['toolbar' + i]; + if (!toolbar) { + break; + } + toolbars.push(toolbar); + } + var mainToolbar = settings.toolbar ? [settings.toolbar] : [defaultToolbar]; + return toolbars.length > 0 ? toolbars : mainToolbar; + }; + var getToolbars = function (editor) { + var toolbar = editor.getParam('toolbar'); + var defaultToolbar = 'undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image'; + if (toolbar === false) { + return []; + } else if (global$2.isArray(toolbar)) { + return global$2.grep(toolbar, function (toolbar) { + return toolbar.length > 0; + }); + } else { + return getIndexedToolbars(editor.settings, defaultToolbar); + } + }; + + var global$3 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils'); + + var global$4 = tinymce.util.Tools.resolve('tinymce.ui.Factory'); + + var global$5 = tinymce.util.Tools.resolve('tinymce.util.I18n'); + + var fireSkinLoaded = function (editor) { + return editor.fire('SkinLoaded'); + }; + var fireResizeEditor = function (editor) { + return editor.fire('ResizeEditor'); + }; + var fireBeforeRenderUI = function (editor) { + return editor.fire('BeforeRenderUI'); + }; + var Events = { + fireSkinLoaded: fireSkinLoaded, + fireResizeEditor: fireResizeEditor, + fireBeforeRenderUI: fireBeforeRenderUI + }; + + var focus = function (panel, type) { + return function () { + var item = panel.find(type)[0]; + if (item) { + item.focus(true); + } + }; + }; + var addKeys = function (editor, panel) { + editor.shortcuts.add('Alt+F9', '', focus(panel, 'menubar')); + editor.shortcuts.add('Alt+F10,F10', '', focus(panel, 'toolbar')); + editor.shortcuts.add('Alt+F11', '', focus(panel, 'elementpath')); + panel.on('cancel', function () { + editor.focus(); + }); + }; + var A11y = { addKeys: addKeys }; + + var global$6 = tinymce.util.Tools.resolve('tinymce.geom.Rect'); + + var global$7 = tinymce.util.Tools.resolve('tinymce.util.Delay'); + + var noop = function () { + }; + var constant = function (value) { + return function () { + return value; + }; + }; + var never = constant(false); + var always = constant(true); + + var never$1 = never; + var always$1 = always; + var none = function () { + return NONE; + }; + var NONE = function () { + var eq = function (o) { + return o.isNone(); + }; + var call = function (thunk) { + return thunk(); + }; + var id = function (n) { + return n; + }; + var noop = function () { + }; + var nul = function () { + return null; + }; + var undef = function () { + return undefined; + }; + var me = { + fold: function (n, s) { + return n(); + }, + is: never$1, + isSome: never$1, + isNone: always$1, + getOr: id, + getOrThunk: call, + getOrDie: function (msg) { + throw new Error(msg || 'error: getOrDie called on none.'); + }, + getOrNull: nul, + getOrUndefined: undef, + or: id, + orThunk: call, + map: none, + ap: none, + each: noop, + bind: none, + flatten: none, + exists: never$1, + forall: always$1, + filter: none, + equals: eq, + equals_: eq, + toArray: function () { + return []; + }, + toString: constant('none()') + }; + if (Object.freeze) { + Object.freeze(me); + } + return me; + }(); + var some = function (a) { + var constant_a = function () { + return a; + }; + var self = function () { + return me; + }; + var map = function (f) { + return some(f(a)); + }; + var bind = function (f) { + return f(a); + }; + var me = { + fold: function (n, s) { + return s(a); + }, + is: function (v) { + return a === v; + }, + isSome: always$1, + isNone: never$1, + getOr: constant_a, + getOrThunk: constant_a, + getOrDie: constant_a, + getOrNull: constant_a, + getOrUndefined: constant_a, + or: self, + orThunk: self, + map: map, + ap: function (optfab) { + return optfab.fold(none, function (fab) { + return some(fab(a)); + }); + }, + each: function (f) { + f(a); + }, + bind: bind, + flatten: constant_a, + exists: bind, + forall: bind, + filter: function (f) { + return f(a) ? me : NONE; + }, + equals: function (o) { + return o.is(a); + }, + equals_: function (o, elementEq) { + return o.fold(never$1, function (b) { + return elementEq(a, b); + }); + }, + toArray: function () { + return [a]; + }, + toString: function () { + return 'some(' + a + ')'; + } + }; + return me; + }; + var from = function (value) { + return value === null || value === undefined ? NONE : some(value); + }; + var Option = { + some: some, + none: none, + from: from + }; + + var getUiContainerDelta = function (ctrl) { + var uiContainer = getUiContainer(ctrl); + if (uiContainer && global$3.DOM.getStyle(uiContainer, 'position', true) !== 'static') { + var containerPos = global$3.DOM.getPos(uiContainer); + var dx = uiContainer.scrollLeft - containerPos.x; + var dy = uiContainer.scrollTop - containerPos.y; + return Option.some({ + x: dx, + y: dy + }); + } else { + return Option.none(); + } + }; + var setUiContainer = function (editor, ctrl) { + var uiContainer = global$3.DOM.select(editor.settings.ui_container)[0]; + ctrl.getRoot().uiContainer = uiContainer; + }; + var getUiContainer = function (ctrl) { + return ctrl ? ctrl.getRoot().uiContainer : null; + }; + var inheritUiContainer = function (fromCtrl, toCtrl) { + return toCtrl.uiContainer = getUiContainer(fromCtrl); + }; + var UiContainer = { + getUiContainerDelta: getUiContainerDelta, + setUiContainer: setUiContainer, + getUiContainer: getUiContainer, + inheritUiContainer: inheritUiContainer + }; + + var createToolbar = function (editor, items, size) { + var toolbarItems = []; + var buttonGroup; + if (!items) { + return; + } + global$2.each(items.split(/[ ,]/), function (item) { + var itemName; + var bindSelectorChanged = function () { + var selection = editor.selection; + if (item.settings.stateSelector) { + selection.selectorChanged(item.settings.stateSelector, function (state) { + item.active(state); + }, true); + } + if (item.settings.disabledStateSelector) { + selection.selectorChanged(item.settings.disabledStateSelector, function (state) { + item.disabled(state); + }); + } + }; + if (item === '|') { + buttonGroup = null; + } else { + if (!buttonGroup) { + buttonGroup = { + type: 'buttongroup', + items: [] + }; + toolbarItems.push(buttonGroup); + } + if (editor.buttons[item]) { + itemName = item; + item = editor.buttons[itemName]; + if (typeof item === 'function') { + item = item(); + } + item.type = item.type || 'button'; + item.size = size; + item = global$4.create(item); + buttonGroup.items.push(item); + if (editor.initialized) { + bindSelectorChanged(); + } else { + editor.on('init', bindSelectorChanged); + } + } + } + }); + return { + type: 'toolbar', + layout: 'flow', + items: toolbarItems + }; + }; + var createToolbars = function (editor, size) { + var toolbars = []; + var addToolbar = function (items) { + if (items) { + toolbars.push(createToolbar(editor, items, size)); + } + }; + global$2.each(getToolbars(editor), function (toolbar) { + addToolbar(toolbar); + }); + if (toolbars.length) { + return { + type: 'panel', + layout: 'stack', + classes: 'toolbar-grp', + ariaRoot: true, + ariaRemember: true, + items: toolbars + }; + } + }; + var Toolbar = { + createToolbar: createToolbar, + createToolbars: createToolbars + }; + + var DOM = global$3.DOM; + var toClientRect = function (geomRect) { + return { + left: geomRect.x, + top: geomRect.y, + width: geomRect.w, + height: geomRect.h, + right: geomRect.x + geomRect.w, + bottom: geomRect.y + geomRect.h + }; + }; + var hideAllFloatingPanels = function (editor) { + global$2.each(editor.contextToolbars, function (toolbar) { + if (toolbar.panel) { + toolbar.panel.hide(); + } + }); + }; + var movePanelTo = function (panel, pos) { + panel.moveTo(pos.left, pos.top); + }; + var togglePositionClass = function (panel, relPos, predicate) { + relPos = relPos ? relPos.substr(0, 2) : ''; + global$2.each({ + t: 'down', + b: 'up' + }, function (cls, pos) { + panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(0, 1))); + }); + global$2.each({ + l: 'left', + r: 'right' + }, function (cls, pos) { + panel.classes.toggle('arrow-' + cls, predicate(pos, relPos.substr(1, 1))); + }); + }; + var userConstrain = function (handler, x, y, elementRect, contentAreaRect, panelRect) { + panelRect = toClientRect({ + x: x, + y: y, + w: panelRect.w, + h: panelRect.h + }); + if (handler) { + panelRect = handler({ + elementRect: toClientRect(elementRect), + contentAreaRect: toClientRect(contentAreaRect), + panelRect: panelRect + }); + } + return panelRect; + }; + var addContextualToolbars = function (editor) { + var scrollContainer; + var getContextToolbars = function () { + return editor.contextToolbars || []; + }; + var getElementRect = function (elm) { + var pos, targetRect, root; + pos = DOM.getPos(editor.getContentAreaContainer()); + targetRect = editor.dom.getRect(elm); + root = editor.dom.getRoot(); + if (root.nodeName === 'BODY') { + targetRect.x -= root.ownerDocument.documentElement.scrollLeft || root.scrollLeft; + targetRect.y -= root.ownerDocument.documentElement.scrollTop || root.scrollTop; + } + targetRect.x += pos.x; + targetRect.y += pos.y; + return targetRect; + }; + var reposition = function (match, shouldShow) { + var relPos, panelRect, elementRect, contentAreaRect, panel, relRect, testPositions, smallElementWidthThreshold; + var handler = getInlineToolbarPositionHandler(editor); + if (editor.removed) { + return; + } + if (!match || !match.toolbar.panel) { + hideAllFloatingPanels(editor); + return; + } + testPositions = [ + 'bc-tc', + 'tc-bc', + 'tl-bl', + 'bl-tl', + 'tr-br', + 'br-tr' + ]; + panel = match.toolbar.panel; + if (shouldShow) { + panel.show(); + } + elementRect = getElementRect(match.element); + panelRect = DOM.getRect(panel.getEl()); + contentAreaRect = DOM.getRect(editor.getContentAreaContainer() || editor.getBody()); + var delta = UiContainer.getUiContainerDelta(panel).getOr({ + x: 0, + y: 0 + }); + elementRect.x += delta.x; + elementRect.y += delta.y; + panelRect.x += delta.x; + panelRect.y += delta.y; + contentAreaRect.x += delta.x; + contentAreaRect.y += delta.y; + smallElementWidthThreshold = 25; + if (DOM.getStyle(match.element, 'display', true) !== 'inline') { + var clientRect = match.element.getBoundingClientRect(); + elementRect.w = clientRect.width; + elementRect.h = clientRect.height; + } + if (!editor.inline) { + contentAreaRect.w = editor.getDoc().documentElement.offsetWidth; + } + if (editor.selection.controlSelection.isResizable(match.element) && elementRect.w < smallElementWidthThreshold) { + elementRect = global$6.inflate(elementRect, 0, 8); + } + relPos = global$6.findBestRelativePosition(panelRect, elementRect, contentAreaRect, testPositions); + elementRect = global$6.clamp(elementRect, contentAreaRect); + if (relPos) { + relRect = global$6.relativePosition(panelRect, elementRect, relPos); + movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect)); + } else { + contentAreaRect.h += panelRect.h; + elementRect = global$6.intersect(contentAreaRect, elementRect); + if (elementRect) { + relPos = global$6.findBestRelativePosition(panelRect, elementRect, contentAreaRect, [ + 'bc-tc', + 'bl-tl', + 'br-tr' + ]); + if (relPos) { + relRect = global$6.relativePosition(panelRect, elementRect, relPos); + movePanelTo(panel, userConstrain(handler, relRect.x, relRect.y, elementRect, contentAreaRect, panelRect)); + } else { + movePanelTo(panel, userConstrain(handler, elementRect.x, elementRect.y, elementRect, contentAreaRect, panelRect)); + } + } else { + panel.hide(); + } + } + togglePositionClass(panel, relPos, function (pos1, pos2) { + return pos1 === pos2; + }); + }; + var repositionHandler = function (show) { + return function () { + var execute = function () { + if (editor.selection) { + reposition(findFrontMostMatch(editor.selection.getNode()), show); + } + }; + global$7.requestAnimationFrame(execute); + }; + }; + var bindScrollEvent = function (panel) { + if (!scrollContainer) { + var reposition_1 = repositionHandler(true); + var uiContainer_1 = UiContainer.getUiContainer(panel); + scrollContainer = editor.selection.getScrollContainer() || editor.getWin(); + DOM.bind(scrollContainer, 'scroll', reposition_1); + DOM.bind(uiContainer_1, 'scroll', reposition_1); + editor.on('remove', function () { + DOM.unbind(scrollContainer, 'scroll', reposition_1); + DOM.unbind(uiContainer_1, 'scroll', reposition_1); + }); + } + }; + var showContextToolbar = function (match) { + var panel; + if (match.toolbar.panel) { + match.toolbar.panel.show(); + reposition(match); + return; + } + panel = global$4.create({ + type: 'floatpanel', + role: 'dialog', + classes: 'tinymce tinymce-inline arrow', + ariaLabel: 'Inline toolbar', + layout: 'flex', + direction: 'column', + align: 'stretch', + autohide: false, + autofix: true, + fixed: true, + border: 1, + items: Toolbar.createToolbar(editor, match.toolbar.items), + oncancel: function () { + editor.focus(); + } + }); + UiContainer.setUiContainer(editor, panel); + bindScrollEvent(panel); + match.toolbar.panel = panel; + panel.renderTo().reflow(); + reposition(match); + }; + var hideAllContextToolbars = function () { + global$2.each(getContextToolbars(), function (toolbar) { + if (toolbar.panel) { + toolbar.panel.hide(); + } + }); + }; + var findFrontMostMatch = function (targetElm) { + var i, y, parentsAndSelf; + var toolbars = getContextToolbars(); + parentsAndSelf = editor.$(targetElm).parents().add(targetElm); + for (i = parentsAndSelf.length - 1; i >= 0; i--) { + for (y = toolbars.length - 1; y >= 0; y--) { + if (toolbars[y].predicate(parentsAndSelf[i])) { + return { + toolbar: toolbars[y], + element: parentsAndSelf[i] + }; + } + } + } + return null; + }; + editor.on('click keyup setContent ObjectResized', function (e) { + if (e.type === 'setcontent' && !e.selection) { + return; + } + global$7.setEditorTimeout(editor, function () { + var match; + match = findFrontMostMatch(editor.selection.getNode()); + if (match) { + hideAllContextToolbars(); + showContextToolbar(match); + } else { + hideAllContextToolbars(); + } + }); + }); + editor.on('blur hide contextmenu', hideAllContextToolbars); + editor.on('ObjectResizeStart', function () { + var match = findFrontMostMatch(editor.selection.getNode()); + if (match && match.toolbar.panel) { + match.toolbar.panel.hide(); + } + }); + editor.on('ResizeEditor ResizeWindow', repositionHandler(true)); + editor.on('nodeChange', repositionHandler(false)); + editor.on('remove', function () { + global$2.each(getContextToolbars(), function (toolbar) { + if (toolbar.panel) { + toolbar.panel.remove(); + } + }); + editor.contextToolbars = {}; + }); + editor.shortcuts.add('ctrl+F9', '', function () { + var match = findFrontMostMatch(editor.selection.getNode()); + if (match && match.toolbar.panel) { + match.toolbar.panel.items()[0].focus(); + } + }); + }; + var ContextToolbars = { addContextualToolbars: addContextualToolbars }; + + var typeOf = function (x) { + if (x === null) { + return 'null'; + } + var t = typeof x; + if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) { + return 'array'; + } + if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) { + return 'string'; + } + return t; + }; + var isType = function (type) { + return function (value) { + return typeOf(value) === type; + }; + }; + var isArray = isType('array'); + var isFunction = isType('function'); + var isNumber = isType('number'); + + var slice = Array.prototype.slice; + var rawIndexOf = function () { + var pIndexOf = Array.prototype.indexOf; + var fastIndex = function (xs, x) { + return pIndexOf.call(xs, x); + }; + var slowIndex = function (xs, x) { + return slowIndexOf(xs, x); + }; + return pIndexOf === undefined ? slowIndex : fastIndex; + }(); + var indexOf = function (xs, x) { + var r = rawIndexOf(xs, x); + return r === -1 ? Option.none() : Option.some(r); + }; + var exists = function (xs, pred) { + return findIndex(xs, pred).isSome(); + }; + 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, xs); + } + return r; + }; + var each = function (xs, f) { + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + f(x, i, xs); + } + }; + var filter = function (xs, pred) { + var r = []; + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + if (pred(x, i, xs)) { + r.push(x); + } + } + return r; + }; + var foldl = function (xs, f, acc) { + each(xs, function (x) { + acc = f(acc, x); + }); + return acc; + }; + var find = function (xs, pred) { + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + if (pred(x, i, xs)) { + return Option.some(x); + } + } + return Option.none(); + }; + var findIndex = function (xs, pred) { + for (var i = 0, len = xs.length; i < len; i++) { + var x = xs[i]; + if (pred(x, i, xs)) { + return Option.some(i); + } + } + return Option.none(); + }; + var slowIndexOf = function (xs, x) { + for (var i = 0, len = xs.length; i < len; ++i) { + if (xs[i] === x) { + return i; + } + } + return -1; + }; + var push = Array.prototype.push; + 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); + } + push.apply(r, xs[i]); + } + return r; + }; + var from$1 = isFunction(Array.from) ? Array.from : function (x) { + return slice.call(x); + }; + + var defaultMenus = { + file: { + title: 'File', + items: 'newdocument restoredraft | preview | print' + }, + edit: { + title: 'Edit', + items: 'undo redo | cut copy paste pastetext | selectall' + }, + view: { + title: 'View', + items: 'code | visualaid visualchars visualblocks | spellchecker | preview fullscreen' + }, + insert: { + title: 'Insert', + items: 'image link media template codesample inserttable | charmap hr | pagebreak nonbreaking anchor toc | insertdatetime' + }, + format: { + title: 'Format', + items: 'bold italic underline strikethrough superscript subscript codeformat | blockformats align | removeformat' + }, + tools: { + title: 'Tools', + items: 'spellchecker spellcheckerlanguage | a11ycheck code' + }, + table: { title: 'Table' }, + help: { title: 'Help' } + }; + var delimiterMenuNamePair = function () { + return { + name: '|', + item: { text: '|' } + }; + }; + var createMenuNameItemPair = function (name, item) { + var menuItem = item ? { + name: name, + item: item + } : null; + return name === '|' ? delimiterMenuNamePair() : menuItem; + }; + var hasItemName = function (namedMenuItems, name) { + return findIndex(namedMenuItems, function (namedMenuItem) { + return namedMenuItem.name === name; + }).isSome(); + }; + var isSeparator = function (namedMenuItem) { + return namedMenuItem && namedMenuItem.item.text === '|'; + }; + var cleanupMenu = function (namedMenuItems, removedMenuItems) { + var menuItemsPass1 = filter(namedMenuItems, function (namedMenuItem) { + return removedMenuItems.hasOwnProperty(namedMenuItem.name) === false; + }); + var menuItemsPass2 = filter(menuItemsPass1, function (namedMenuItem, i, namedMenuItems) { + return !isSeparator(namedMenuItem) || !isSeparator(namedMenuItems[i - 1]); + }); + return filter(menuItemsPass2, function (namedMenuItem, i, namedMenuItems) { + return !isSeparator(namedMenuItem) || i > 0 && i < namedMenuItems.length - 1; + }); + }; + var createMenu = function (editorMenuItems, menus, removedMenuItems, context) { + var menuButton, menu, namedMenuItems, isUserDefined; + if (menus) { + menu = menus[context]; + isUserDefined = true; + } else { + menu = defaultMenus[context]; + } + if (menu) { + menuButton = { text: menu.title }; + namedMenuItems = []; + global$2.each((menu.items || '').split(/[ ,]/), function (name) { + var namedMenuItem = createMenuNameItemPair(name, editorMenuItems[name]); + if (namedMenuItem) { + namedMenuItems.push(namedMenuItem); + } + }); + if (!isUserDefined) { + global$2.each(editorMenuItems, function (item, name) { + if (item.context === context && !hasItemName(namedMenuItems, name)) { + if (item.separator === 'before') { + namedMenuItems.push(delimiterMenuNamePair()); + } + if (item.prependToContext) { + namedMenuItems.unshift(createMenuNameItemPair(name, item)); + } else { + namedMenuItems.push(createMenuNameItemPair(name, item)); + } + if (item.separator === 'after') { + namedMenuItems.push(delimiterMenuNamePair()); + } + } + }); + } + menuButton.menu = map(cleanupMenu(namedMenuItems, removedMenuItems), function (menuItem) { + return menuItem.item; + }); + if (!menuButton.menu.length) { + return null; + } + } + return menuButton; + }; + var getDefaultMenubar = function (editor) { + var name; + var defaultMenuBar = []; + var menu = getMenu(editor); + if (menu) { + for (name in menu) { + defaultMenuBar.push(name); + } + } else { + for (name in defaultMenus) { + defaultMenuBar.push(name); + } + } + return defaultMenuBar; + }; + var createMenuButtons = function (editor) { + var menuButtons = []; + var defaultMenuBar = getDefaultMenubar(editor); + var removedMenuItems = global$2.makeMap(getRemovedMenuItems(editor).split(/[ ,]/)); + var menubar = getMenubar(editor); + var enabledMenuNames = typeof menubar === 'string' ? menubar.split(/[ ,]/) : defaultMenuBar; + for (var i = 0; i < enabledMenuNames.length; i++) { + var menuItems = enabledMenuNames[i]; + var menu = createMenu(editor.menuItems, getMenu(editor), removedMenuItems, menuItems); + if (menu) { + menuButtons.push(menu); + } + } + return menuButtons; + }; + var Menubar = { createMenuButtons: createMenuButtons }; + + var DOM$1 = global$3.DOM; + var getSize = function (elm) { + return { + width: elm.clientWidth, + height: elm.clientHeight + }; + }; + var resizeTo = function (editor, width, height) { + var containerElm, iframeElm, containerSize, iframeSize; + containerElm = editor.getContainer(); + iframeElm = editor.getContentAreaContainer().firstChild; + containerSize = getSize(containerElm); + iframeSize = getSize(iframeElm); + if (width !== null) { + width = Math.max(getMinWidth(editor), width); + width = Math.min(getMaxWidth(editor), width); + DOM$1.setStyle(containerElm, 'width', width + (containerSize.width - iframeSize.width)); + DOM$1.setStyle(iframeElm, 'width', width); + } + height = Math.max(getMinHeight(editor), height); + height = Math.min(getMaxHeight(editor), height); + DOM$1.setStyle(iframeElm, 'height', height); + Events.fireResizeEditor(editor); + }; + var resizeBy = function (editor, dw, dh) { + var elm = editor.getContentAreaContainer(); + resizeTo(editor, elm.clientWidth + dw, elm.clientHeight + dh); + }; + var Resize = { + resizeTo: resizeTo, + resizeBy: resizeBy + }; + + var global$8 = tinymce.util.Tools.resolve('tinymce.Env'); + + var api = function (elm) { + return { + element: function () { + return elm; + } + }; + }; + var trigger = function (sidebar, panel, callbackName) { + var callback = sidebar.settings[callbackName]; + if (callback) { + callback(api(panel.getEl('body'))); + } + }; + var hidePanels = function (name, container, sidebars) { + global$2.each(sidebars, function (sidebar) { + var panel = container.items().filter('#' + sidebar.name)[0]; + if (panel && panel.visible() && sidebar.name !== name) { + trigger(sidebar, panel, 'onhide'); + panel.visible(false); + } + }); + }; + var deactivateButtons = function (toolbar) { + toolbar.items().each(function (ctrl) { + ctrl.active(false); + }); + }; + var findSidebar = function (sidebars, name) { + return global$2.grep(sidebars, function (sidebar) { + return sidebar.name === name; + })[0]; + }; + var showPanel = function (editor, name, sidebars) { + return function (e) { + var btnCtrl = e.control; + var container = btnCtrl.parents().filter('panel')[0]; + var panel = container.find('#' + name)[0]; + var sidebar = findSidebar(sidebars, name); + hidePanels(name, container, sidebars); + deactivateButtons(btnCtrl.parent()); + if (panel && panel.visible()) { + trigger(sidebar, panel, 'onhide'); + panel.hide(); + btnCtrl.active(false); + } else { + if (panel) { + panel.show(); + trigger(sidebar, panel, 'onshow'); + } else { + panel = global$4.create({ + type: 'container', + name: name, + layout: 'stack', + classes: 'sidebar-panel', + html: '' + }); + container.prepend(panel); + trigger(sidebar, panel, 'onrender'); + trigger(sidebar, panel, 'onshow'); + } + btnCtrl.active(true); + } + Events.fireResizeEditor(editor); + }; + }; + var isModernBrowser = function () { + return !global$8.ie || global$8.ie >= 11; + }; + var hasSidebar = function (editor) { + return isModernBrowser() && editor.sidebars ? editor.sidebars.length > 0 : false; + }; + var createSidebar = function (editor) { + var buttons = global$2.map(editor.sidebars, function (sidebar) { + var settings = sidebar.settings; + return { + type: 'button', + icon: settings.icon, + image: settings.image, + tooltip: settings.tooltip, + onclick: showPanel(editor, sidebar.name, editor.sidebars) + }; + }); + return { + type: 'panel', + name: 'sidebar', + layout: 'stack', + classes: 'sidebar', + items: [{ + type: 'toolbar', + layout: 'stack', + classes: 'sidebar-toolbar', + items: buttons + }] + }; + }; + var Sidebar = { + hasSidebar: hasSidebar, + createSidebar: createSidebar + }; + + var fireSkinLoaded$1 = function (editor) { + var done = function () { + editor._skinLoaded = true; + Events.fireSkinLoaded(editor); + }; + return function () { + if (editor.initialized) { + done(); + } else { + editor.on('init', done); + } + }; + }; + var SkinLoaded = { fireSkinLoaded: fireSkinLoaded$1 }; + + var DOM$2 = global$3.DOM; + var switchMode = function (panel) { + return function (e) { + panel.find('*').disabled(e.mode === 'readonly'); + }; + }; + var editArea = function (border) { + return { + type: 'panel', + name: 'iframe', + layout: 'stack', + classes: 'edit-area', + border: border, + html: '' + }; + }; + var editAreaContainer = function (editor) { + return { + type: 'panel', + layout: 'stack', + classes: 'edit-aria-container', + border: '1 0 0 0', + items: [ + editArea('0'), + Sidebar.createSidebar(editor) + ] + }; + }; + var render = function (editor, theme, args) { + var panel, resizeHandleCtrl, startSize; + if (isSkinDisabled(editor) === false && args.skinUiCss) { + DOM$2.styleSheetLoader.load(args.skinUiCss, SkinLoaded.fireSkinLoaded(editor)); + } else { + SkinLoaded.fireSkinLoaded(editor)(); + } + panel = theme.panel = global$4.create({ + type: 'panel', + role: 'application', + classes: 'tinymce', + style: 'visibility: hidden', + layout: 'stack', + border: 1, + items: [ + { + type: 'container', + classes: 'top-part', + items: [ + hasMenubar(editor) === false ? null : { + type: 'menubar', + border: '0 0 1 0', + items: Menubar.createMenuButtons(editor) + }, + Toolbar.createToolbars(editor, getToolbarSize(editor)) + ] + }, + Sidebar.hasSidebar(editor) ? editAreaContainer(editor) : editArea('1 0 0 0') + ] + }); + UiContainer.setUiContainer(editor, panel); + if (getResize(editor) !== 'none') { + resizeHandleCtrl = { + type: 'resizehandle', + direction: getResize(editor), + onResizeStart: function () { + var elm = editor.getContentAreaContainer().firstChild; + startSize = { + width: elm.clientWidth, + height: elm.clientHeight + }; + }, + onResize: function (e) { + if (getResize(editor) === 'both') { + Resize.resizeTo(editor, startSize.width + e.deltaX, startSize.height + e.deltaY); + } else { + Resize.resizeTo(editor, null, startSize.height + e.deltaY); + } + } + }; + } + if (hasStatusbar(editor)) { + var linkHtml = 'Tiny'; + var html = global$5.translate([ + 'Powered by {0}', + linkHtml + ]); + var brandingLabel = isBrandingEnabled(editor) ? { + type: 'label', + classes: 'branding', + html: ' ' + html + } : null; + panel.add({ + type: 'panel', + name: 'statusbar', + classes: 'statusbar', + layout: 'flow', + border: '1 0 0 0', + ariaRoot: true, + items: [ + { + type: 'elementpath', + editor: editor + }, + resizeHandleCtrl, + brandingLabel + ] + }); + } + Events.fireBeforeRenderUI(editor); + editor.on('SwitchMode', switchMode(panel)); + panel.renderBefore(args.targetNode).reflow(); + if (isReadOnly(editor)) { + editor.setMode('readonly'); + } + if (args.width) { + DOM$2.setStyle(panel.getEl(), 'width', args.width); + } + editor.on('remove', function () { + panel.remove(); + panel = null; + }); + A11y.addKeys(editor, panel); + ContextToolbars.addContextualToolbars(editor); + return { + iframeContainer: panel.find('#iframe')[0].getEl(), + editorContainer: panel.getEl() + }; + }; + var Iframe = { render: render }; + + var global$9 = tinymce.util.Tools.resolve('tinymce.dom.DomQuery'); + + var count = 0; + var funcs = { + id: function () { + return 'mceu_' + count++; + }, + create: function (name, attrs, children) { + var elm = domGlobals.document.createElement(name); + global$3.DOM.setAttribs(elm, attrs); + if (typeof children === 'string') { + elm.innerHTML = children; + } else { + global$2.each(children, function (child) { + if (child.nodeType) { + elm.appendChild(child); + } + }); + } + return elm; + }, + createFragment: function (html) { + return global$3.DOM.createFragment(html); + }, + getWindowSize: function () { + return global$3.DOM.getViewPort(); + }, + getSize: function (elm) { + var width, height; + if (elm.getBoundingClientRect) { + var rect = elm.getBoundingClientRect(); + width = Math.max(rect.width || rect.right - rect.left, elm.offsetWidth); + height = Math.max(rect.height || rect.bottom - rect.bottom, elm.offsetHeight); + } else { + width = elm.offsetWidth; + height = elm.offsetHeight; + } + return { + width: width, + height: height + }; + }, + getPos: function (elm, root) { + return global$3.DOM.getPos(elm, root || funcs.getContainer()); + }, + getContainer: function () { + return global$8.container ? global$8.container : domGlobals.document.body; + }, + getViewPort: function (win) { + return global$3.DOM.getViewPort(win); + }, + get: function (id) { + return domGlobals.document.getElementById(id); + }, + addClass: function (elm, cls) { + return global$3.DOM.addClass(elm, cls); + }, + removeClass: function (elm, cls) { + return global$3.DOM.removeClass(elm, cls); + }, + hasClass: function (elm, cls) { + return global$3.DOM.hasClass(elm, cls); + }, + toggleClass: function (elm, cls, state) { + return global$3.DOM.toggleClass(elm, cls, state); + }, + css: function (elm, name, value) { + return global$3.DOM.setStyle(elm, name, value); + }, + getRuntimeStyle: function (elm, name) { + return global$3.DOM.getStyle(elm, name, true); + }, + on: function (target, name, callback, scope) { + return global$3.DOM.bind(target, name, callback, scope); + }, + off: function (target, name, callback) { + return global$3.DOM.unbind(target, name, callback); + }, + fire: function (target, name, args) { + return global$3.DOM.fire(target, name, args); + }, + innerHtml: function (elm, html) { + global$3.DOM.setHTML(elm, html); + } + }; + + var isStatic = function (elm) { + return funcs.getRuntimeStyle(elm, 'position') === 'static'; + }; + var isFixed = function (ctrl) { + return ctrl.state.get('fixed'); + }; + function calculateRelativePosition(ctrl, targetElm, rel) { + var ctrlElm, pos, x, y, selfW, selfH, targetW, targetH, viewport, size; + viewport = getWindowViewPort(); + pos = funcs.getPos(targetElm, UiContainer.getUiContainer(ctrl)); + x = pos.x; + y = pos.y; + if (isFixed(ctrl) && isStatic(domGlobals.document.body)) { + x -= viewport.x; + y -= viewport.y; + } + ctrlElm = ctrl.getEl(); + size = funcs.getSize(ctrlElm); + selfW = size.width; + selfH = size.height; + size = funcs.getSize(targetElm); + targetW = size.width; + targetH = size.height; + rel = (rel || '').split(''); + if (rel[0] === 'b') { + y += targetH; + } + if (rel[1] === 'r') { + x += targetW; + } + if (rel[0] === 'c') { + y += Math.round(targetH / 2); + } + if (rel[1] === 'c') { + x += Math.round(targetW / 2); + } + if (rel[3] === 'b') { + y -= selfH; + } + if (rel[4] === 'r') { + x -= selfW; + } + if (rel[3] === 'c') { + y -= Math.round(selfH / 2); + } + if (rel[4] === 'c') { + x -= Math.round(selfW / 2); + } + return { + x: x, + y: y, + w: selfW, + h: selfH + }; + } + var getUiContainerViewPort = function (customUiContainer) { + return { + x: 0, + y: 0, + w: customUiContainer.scrollWidth - 1, + h: customUiContainer.scrollHeight - 1 + }; + }; + var getWindowViewPort = function () { + var win = domGlobals.window; + var x = Math.max(win.pageXOffset, domGlobals.document.body.scrollLeft, domGlobals.document.documentElement.scrollLeft); + var y = Math.max(win.pageYOffset, domGlobals.document.body.scrollTop, domGlobals.document.documentElement.scrollTop); + var w = win.innerWidth || domGlobals.document.documentElement.clientWidth; + var h = win.innerHeight || domGlobals.document.documentElement.clientHeight; + return { + x: x, + y: y, + w: w, + h: h + }; + }; + var getViewPortRect = function (ctrl) { + var customUiContainer = UiContainer.getUiContainer(ctrl); + return customUiContainer && !isFixed(ctrl) ? getUiContainerViewPort(customUiContainer) : getWindowViewPort(); + }; + var Movable = { + testMoveRel: function (elm, rels) { + var viewPortRect = getViewPortRect(this); + for (var i = 0; i < rels.length; i++) { + var pos = calculateRelativePosition(this, elm, rels[i]); + if (isFixed(this)) { + if (pos.x > 0 && pos.x + pos.w < viewPortRect.w && pos.y > 0 && pos.y + pos.h < viewPortRect.h) { + return rels[i]; + } + } else { + if (pos.x > viewPortRect.x && pos.x + pos.w < viewPortRect.w + viewPortRect.x && pos.y > viewPortRect.y && pos.y + pos.h < viewPortRect.h + viewPortRect.y) { + return rels[i]; + } + } + } + return rels[0]; + }, + moveRel: function (elm, rel) { + if (typeof rel !== 'string') { + rel = this.testMoveRel(elm, rel); + } + var pos = calculateRelativePosition(this, elm, rel); + return this.moveTo(pos.x, pos.y); + }, + moveBy: function (dx, dy) { + var self = this, rect = self.layoutRect(); + self.moveTo(rect.x + dx, rect.y + dy); + return self; + }, + moveTo: function (x, y) { + var self = this; + function constrain(value, max, size) { + if (value < 0) { + return 0; + } + if (value + size > max) { + value = max - size; + return value < 0 ? 0 : value; + } + return value; + } + if (self.settings.constrainToViewport) { + var viewPortRect = getViewPortRect(this); + var layoutRect = self.layoutRect(); + x = constrain(x, viewPortRect.w + viewPortRect.x, layoutRect.w); + y = constrain(y, viewPortRect.h + viewPortRect.y, layoutRect.h); + } + var uiContainer = UiContainer.getUiContainer(self); + if (uiContainer && isStatic(uiContainer) && !isFixed(self)) { + x -= uiContainer.scrollLeft; + y -= uiContainer.scrollTop; + } + if (uiContainer) { + x += 1; + y += 1; + } + if (self.state.get('rendered')) { + self.layoutRect({ + x: x, + y: y + }).repaint(); + } else { + self.settings.x = x; + self.settings.y = y; + } + self.fire('move', { + x: x, + y: y + }); + return self; + } + }; + + var global$a = tinymce.util.Tools.resolve('tinymce.util.Class'); + + var global$b = tinymce.util.Tools.resolve('tinymce.util.EventDispatcher'); + + var BoxUtils = { + parseBox: function (value) { + var len; + var radix = 10; + if (!value) { + return; + } + if (typeof value === 'number') { + value = value || 0; + return { + top: value, + left: value, + bottom: value, + right: value + }; + } + value = value.split(' '); + len = value.length; + if (len === 1) { + value[1] = value[2] = value[3] = value[0]; + } else if (len === 2) { + value[2] = value[0]; + value[3] = value[1]; + } else if (len === 3) { + value[3] = value[1]; + } + return { + top: parseInt(value[0], radix) || 0, + right: parseInt(value[1], radix) || 0, + bottom: parseInt(value[2], radix) || 0, + left: parseInt(value[3], radix) || 0 + }; + }, + measureBox: function (elm, prefix) { + function getStyle(name) { + var defaultView = elm.ownerDocument.defaultView; + if (defaultView) { + var computedStyle = defaultView.getComputedStyle(elm, null); + if (computedStyle) { + name = name.replace(/[A-Z]/g, function (a) { + return '-' + a; + }); + return computedStyle.getPropertyValue(name); + } else { + return null; + } + } + return elm.currentStyle[name]; + } + function getSide(name) { + var val = parseFloat(getStyle(name)); + return isNaN(val) ? 0 : val; + } + return { + top: getSide(prefix + 'TopWidth'), + right: getSide(prefix + 'RightWidth'), + bottom: getSide(prefix + 'BottomWidth'), + left: getSide(prefix + 'LeftWidth') + }; + } + }; + + function noop$1() { + } + function ClassList(onchange) { + this.cls = []; + this.cls._map = {}; + this.onchange = onchange || noop$1; + this.prefix = ''; + } + global$2.extend(ClassList.prototype, { + add: function (cls) { + if (cls && !this.contains(cls)) { + this.cls._map[cls] = true; + this.cls.push(cls); + this._change(); + } + return this; + }, + remove: function (cls) { + if (this.contains(cls)) { + var i = void 0; + for (i = 0; i < this.cls.length; i++) { + if (this.cls[i] === cls) { + break; + } + } + this.cls.splice(i, 1); + delete this.cls._map[cls]; + this._change(); + } + return this; + }, + toggle: function (cls, state) { + var curState = this.contains(cls); + if (curState !== state) { + if (curState) { + this.remove(cls); + } else { + this.add(cls); + } + this._change(); + } + return this; + }, + contains: function (cls) { + return !!this.cls._map[cls]; + }, + _change: function () { + delete this.clsValue; + this.onchange.call(this); + } + }); + ClassList.prototype.toString = function () { + var value; + if (this.clsValue) { + return this.clsValue; + } + value = ''; + for (var i = 0; i < this.cls.length; i++) { + if (i > 0) { + value += ' '; + } + value += this.prefix + this.cls[i]; + } + return value; + }; + + function unique(array) { + var uniqueItems = []; + var i = array.length, item; + while (i--) { + item = array[i]; + if (!item.__checked) { + uniqueItems.push(item); + item.__checked = 1; + } + } + i = uniqueItems.length; + while (i--) { + delete uniqueItems[i].__checked; + } + return uniqueItems; + } + var expression = /^([\w\\*]+)?(?:#([\w\-\\]+))?(?:\.([\w\\\.]+))?(?:\[\@?([\w\\]+)([\^\$\*!~]?=)([\w\\]+)\])?(?:\:(.+))?/i; + var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g; + var whiteSpace = /^\s*|\s*$/g; + var Collection; + var Selector = global$a.extend({ + init: function (selector) { + var match = this.match; + function compileNameFilter(name) { + if (name) { + name = name.toLowerCase(); + return function (item) { + return name === '*' || item.type === name; + }; + } + } + function compileIdFilter(id) { + if (id) { + return function (item) { + return item._name === id; + }; + } + } + function compileClassesFilter(classes) { + if (classes) { + classes = classes.split('.'); + return function (item) { + var i = classes.length; + while (i--) { + if (!item.classes.contains(classes[i])) { + return false; + } + } + return true; + }; + } + } + function compileAttrFilter(name, cmp, check) { + if (name) { + return function (item) { + var value = item[name] ? item[name]() : ''; + return !cmp ? !!check : cmp === '=' ? value === check : cmp === '*=' ? value.indexOf(check) >= 0 : cmp === '~=' ? (' ' + value + ' ').indexOf(' ' + check + ' ') >= 0 : cmp === '!=' ? value !== check : cmp === '^=' ? value.indexOf(check) === 0 : cmp === '$=' ? value.substr(value.length - check.length) === check : false; + }; + } + } + function compilePsuedoFilter(name) { + var notSelectors; + if (name) { + name = /(?:not\((.+)\))|(.+)/i.exec(name); + if (!name[1]) { + name = name[2]; + return function (item, index, length) { + return name === 'first' ? index === 0 : name === 'last' ? index === length - 1 : name === 'even' ? index % 2 === 0 : name === 'odd' ? index % 2 === 1 : item[name] ? item[name]() : false; + }; + } + notSelectors = parseChunks(name[1], []); + return function (item) { + return !match(item, notSelectors); + }; + } + } + function compile(selector, filters, direct) { + var parts; + function add(filter) { + if (filter) { + filters.push(filter); + } + } + parts = expression.exec(selector.replace(whiteSpace, '')); + add(compileNameFilter(parts[1])); + add(compileIdFilter(parts[2])); + add(compileClassesFilter(parts[3])); + add(compileAttrFilter(parts[4], parts[5], parts[6])); + add(compilePsuedoFilter(parts[7])); + filters.pseudo = !!parts[7]; + filters.direct = direct; + return filters; + } + function parseChunks(selector, selectors) { + var parts = []; + var extra, matches, i; + do { + chunker.exec(''); + matches = chunker.exec(selector); + if (matches) { + selector = matches[3]; + parts.push(matches[1]); + if (matches[2]) { + extra = matches[3]; + break; + } + } + } while (matches); + if (extra) { + parseChunks(extra, selectors); + } + selector = []; + for (i = 0; i < parts.length; i++) { + if (parts[i] !== '>') { + selector.push(compile(parts[i], [], parts[i - 1] === '>')); + } + } + selectors.push(selector); + return selectors; + } + this._selectors = parseChunks(selector, []); + }, + match: function (control, selectors) { + var i, l, si, sl, selector, fi, fl, filters, index, length, siblings, count, item; + selectors = selectors || this._selectors; + for (i = 0, l = selectors.length; i < l; i++) { + selector = selectors[i]; + sl = selector.length; + item = control; + count = 0; + for (si = sl - 1; si >= 0; si--) { + filters = selector[si]; + while (item) { + if (filters.pseudo) { + siblings = item.parent().items(); + index = length = siblings.length; + while (index--) { + if (siblings[index] === item) { + break; + } + } + } + for (fi = 0, fl = filters.length; fi < fl; fi++) { + if (!filters[fi](item, index, length)) { + fi = fl + 1; + break; + } + } + if (fi === fl) { + count++; + break; + } else { + if (si === sl - 1) { + break; + } + } + item = item.parent(); + } + } + if (count === sl) { + return true; + } + } + return false; + }, + find: function (container) { + var matches = [], i, l; + var selectors = this._selectors; + function collect(items, selector, index) { + var i, l, fi, fl, item; + var filters = selector[index]; + for (i = 0, l = items.length; i < l; i++) { + item = items[i]; + for (fi = 0, fl = filters.length; fi < fl; fi++) { + if (!filters[fi](item, i, l)) { + fi = fl + 1; + break; + } + } + if (fi === fl) { + if (index === selector.length - 1) { + matches.push(item); + } else { + if (item.items) { + collect(item.items(), selector, index + 1); + } + } + } else if (filters.direct) { + return; + } + if (item.items) { + collect(item.items(), selector, index); + } + } + } + if (container.items) { + for (i = 0, l = selectors.length; i < l; i++) { + collect(container.items(), selectors[i], 0); + } + if (l > 1) { + matches = unique(matches); + } + } + if (!Collection) { + Collection = Selector.Collection; + } + return new Collection(matches); + } + }); + + var Collection$1, proto; + var push$1 = Array.prototype.push, slice$1 = Array.prototype.slice; + proto = { + length: 0, + init: function (items) { + if (items) { + this.add(items); + } + }, + add: function (items) { + var self = this; + if (!global$2.isArray(items)) { + if (items instanceof Collection$1) { + self.add(items.toArray()); + } else { + push$1.call(self, items); + } + } else { + push$1.apply(self, items); + } + return self; + }, + set: function (items) { + var self = this; + var len = self.length; + var i; + self.length = 0; + self.add(items); + for (i = self.length; i < len; i++) { + delete self[i]; + } + return self; + }, + filter: function (selector) { + var self = this; + var i, l; + var matches = []; + var item, match; + if (typeof selector === 'string') { + selector = new Selector(selector); + match = function (item) { + return selector.match(item); + }; + } else { + match = selector; + } + for (i = 0, l = self.length; i < l; i++) { + item = self[i]; + if (match(item)) { + matches.push(item); + } + } + return new Collection$1(matches); + }, + slice: function () { + return new Collection$1(slice$1.apply(this, arguments)); + }, + eq: function (index) { + return index === -1 ? this.slice(index) : this.slice(index, +index + 1); + }, + each: function (callback) { + global$2.each(this, callback); + return this; + }, + toArray: function () { + return global$2.toArray(this); + }, + indexOf: function (ctrl) { + var self = this; + var i = self.length; + while (i--) { + if (self[i] === ctrl) { + break; + } + } + return i; + }, + reverse: function () { + return new Collection$1(global$2.toArray(this).reverse()); + }, + hasClass: function (cls) { + return this[0] ? this[0].classes.contains(cls) : false; + }, + prop: function (name, value) { + var self = this; + var item; + if (value !== undefined) { + self.each(function (item) { + if (item[name]) { + item[name](value); + } + }); + return self; + } + item = self[0]; + if (item && item[name]) { + return item[name](); + } + }, + exec: function (name) { + var self = this, args = global$2.toArray(arguments).slice(1); + self.each(function (item) { + if (item[name]) { + item[name].apply(item, args); + } + }); + return self; + }, + remove: function () { + var i = this.length; + while (i--) { + this[i].remove(); + } + return this; + }, + addClass: function (cls) { + return this.each(function (item) { + item.classes.add(cls); + }); + }, + removeClass: function (cls) { + return this.each(function (item) { + item.classes.remove(cls); + }); + } + }; + global$2.each('fire on off show hide append prepend before after reflow'.split(' '), function (name) { + proto[name] = function () { + var args = global$2.toArray(arguments); + this.each(function (ctrl) { + if (name in ctrl) { + ctrl[name].apply(ctrl, args); + } + }); + return this; + }; + }); + global$2.each('text name disabled active selected checked visible parent value data'.split(' '), function (name) { + proto[name] = function (value) { + return this.prop(name, value); + }; + }); + Collection$1 = global$a.extend(proto); + Selector.Collection = Collection$1; + var Collection$2 = Collection$1; + + var Binding = function (settings) { + this.create = settings.create; + }; + Binding.create = function (model, name) { + return new Binding({ + create: function (otherModel, otherName) { + var bindings; + var fromSelfToOther = function (e) { + otherModel.set(otherName, e.value); + }; + var fromOtherToSelf = function (e) { + model.set(name, e.value); + }; + otherModel.on('change:' + otherName, fromOtherToSelf); + model.on('change:' + name, fromSelfToOther); + bindings = otherModel._bindings; + if (!bindings) { + bindings = otherModel._bindings = []; + otherModel.on('destroy', function () { + var i = bindings.length; + while (i--) { + bindings[i](); + } + }); + } + bindings.push(function () { + model.off('change:' + name, fromSelfToOther); + }); + return model.get(name); + } + }); + }; + + var global$c = tinymce.util.Tools.resolve('tinymce.util.Observable'); + + function isNode(node) { + return node.nodeType > 0; + } + function isEqual(a, b) { + var k, checked; + if (a === b) { + return true; + } + if (a === null || b === null) { + return a === b; + } + if (typeof a !== 'object' || typeof b !== 'object') { + return a === b; + } + if (global$2.isArray(b)) { + if (a.length !== b.length) { + return false; + } + k = a.length; + while (k--) { + if (!isEqual(a[k], b[k])) { + return false; + } + } + } + if (isNode(a) || isNode(b)) { + return a === b; + } + checked = {}; + for (k in b) { + if (!isEqual(a[k], b[k])) { + return false; + } + checked[k] = true; + } + for (k in a) { + if (!checked[k] && !isEqual(a[k], b[k])) { + return false; + } + } + return true; + } + var ObservableObject = global$a.extend({ + Mixins: [global$c], + init: function (data) { + var name, value; + data = data || {}; + for (name in data) { + value = data[name]; + if (value instanceof Binding) { + data[name] = value.create(this, name); + } + } + this.data = data; + }, + set: function (name, value) { +