Hacked By AnonymousFox
(function () {
var defs = {}; // id -> {dependencies, definition, instance (possibly undefined)}
// Used when there is no 'main' module.
// The name is probably (hopefully) unique so minification removes for releases.
var register_3795 = function (id) {
var module = dem(id);
var fragments = id.split('.');
var target = Function('return this;')();
for (var i = 0; i < fragments.length - 1; ++i) {
if (target[fragments[i]] === undefined)
target[fragments[i]] = {};
target = target[fragments[i]];
}
target[fragments[fragments.length - 1]] = module;
};
var instantiate = function (id) {
var actual = defs[id];
var dependencies = actual.deps;
var definition = actual.defn;
var len = dependencies.length;
var instances = new Array(len);
for (var i = 0; i < len; ++i)
instances[i] = dem(dependencies[i]);
var defResult = definition.apply(null, instances);
if (defResult === undefined)
throw 'module [' + id + '] returned undefined';
actual.instance = defResult;
};
var def = function (id, dependencies, definition) {
if (typeof id !== 'string')
throw 'module id must be a string';
else if (dependencies === undefined)
throw 'no dependencies for ' + id;
else if (definition === undefined)
throw 'no definition function for ' + id;
defs[id] = {
deps: dependencies,
defn: definition,
instance: undefined
};
};
var dem = function (id) {
var actual = defs[id];
if (actual === undefined)
throw 'module [' + id + '] was undefined';
else if (actual.instance === undefined)
instantiate(id);
return actual.instance;
};
var req = function (ids, callback) {
var len = ids.length;
var instances = new Array(len);
for (var i = 0; i < len; ++i)
instances.push(dem(ids[i]));
callback.apply(null, callback);
};
var ephox = {};
ephox.bolt = {
module: {
api: {
define: def,
require: req,
demand: dem
}
}
};
var define = def;
var require = req;
var demand = dem;
// this helps with minificiation when using a lot of global references
var defineGlobal = function (id, ref) {
define(id, [], function () { return ref; });
};
/*jsc
["tinymce.plugins.textpattern.Plugin","tinymce.core.PluginManager","tinymce.core.util.Delay","tinymce.core.util.VK","tinymce.plugins.textpattern.core.Formatter","tinymce.plugins.textpattern.core.KeyHandler","tinymce.plugins.textpattern.core.Settings","global!tinymce.util.Tools.resolve","tinymce.core.dom.TreeWalker","tinymce.core.util.Tools","tinymce.plugins.textpattern.core.Patterns"]
jsc*/
defineGlobal("global!tinymce.util.Tools.resolve", tinymce.util.Tools.resolve);
/**
* ResolveGlobal.js
*
* Released under LGPL License.
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
*
* License: http://www.tinymce.com/license
* Contributing: http://www.tinymce.com/contributing
*/
define(
'tinymce.core.PluginManager',
[
'global!tinymce.util.Tools.resolve'
],
function (resolve) {
return resolve('tinymce.PluginManager');
}
);
/**
* ResolveGlobal.js
*
* Released under LGPL License.
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
*
* License: http://www.tinymce.com/license
* Contributing: http://www.tinymce.com/contributing
*/
define(
'tinymce.core.util.Delay',
[
'global!tinymce.util.Tools.resolve'
],
function (resolve) {
return resolve('tinymce.util.Delay');
}
);
/**
* ResolveGlobal.js
*
* Released under LGPL License.
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
*
* License: http://www.tinymce.com/license
* Contributing: http://www.tinymce.com/contributing
*/
define(
'tinymce.core.util.VK',
[
'global!tinymce.util.Tools.resolve'
],
function (resolve) {
return resolve('tinymce.util.VK');
}
);
/**
* ResolveGlobal.js
*
* Released under LGPL License.
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
*
* License: http://www.tinymce.com/license
* Contributing: http://www.tinymce.com/contributing
*/
define(
'tinymce.core.dom.TreeWalker',
[
'global!tinymce.util.Tools.resolve'
],
function (resolve) {
return resolve('tinymce.dom.TreeWalker');
}
);
/**
* ResolveGlobal.js
*
* Released under LGPL License.
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
*
* License: http://www.tinymce.com/license
* Contributing: http://www.tinymce.com/contributing
*/
define(
'tinymce.core.util.Tools',
[
'global!tinymce.util.Tools.resolve'
],
function (resolve) {
return resolve('tinymce.util.Tools');
}
);
define(
'tinymce.plugins.textpattern.core.Patterns',
[
],
function () {
// Returns a sorted patterns list, ordered descending by start length
var sortPatterns = function (patterns) {
return patterns.sort(function (a, b) {
if (a.start.length > b.start.length) {
return -1;
}
if (a.start.length < b.start.length) {
return 1;
}
return 0;
});
};
// Finds a matching pattern to the specified text
var findPattern = function (patterns, text) {
for (var i = 0; i < patterns.length; i++) {
if (text.indexOf(patterns[i].start) !== 0) {
continue;
}
if (patterns[i].end && text.lastIndexOf(patterns[i].end) !== (text.length - patterns[i].end.length)) {
continue;
}
return patterns[i];
}
};
var isMatchingPattern = function (pattern, text, offset, delta) {
var textEnd = text.substr(offset - pattern.end.length - delta, pattern.end.length);
return textEnd === pattern.end;
};
var hasContent = function (offset, delta, pattern) {
return (offset - delta - pattern.end.length - pattern.start.length) > 0;
};
// Finds the best matching end pattern
var findEndPattern = function (patterns, text, offset, delta) {
var pattern, i;
var sortedPatterns = sortPatterns(patterns);
// Find best matching end
for (i = 0; i < sortedPatterns.length; i++) {
pattern = sortedPatterns[i];
if (pattern.end !== undefined && isMatchingPattern(pattern, text, offset, delta) && hasContent(offset, delta, pattern)) {
return pattern;
}
}
};
return {
findPattern: findPattern,
findEndPattern: findEndPattern
};
}
);
define(
'tinymce.plugins.textpattern.core.Formatter',
[
'tinymce.core.dom.TreeWalker',
'tinymce.core.util.Tools',
'tinymce.plugins.textpattern.core.Patterns'
],
function (TreeWalker, Tools, Patterns) {
var splitContainer = function (container, pattern, offset, startOffset, delta) {
// Split text node and remove start/end from text node
container = startOffset > 0 ? container.splitText(startOffset) : container;
container.splitText(offset - startOffset - delta);
container.deleteData(0, pattern.start.length);
container.deleteData(container.data.length - pattern.end.length, pattern.end.length);
return container;
};
// Handles inline formats like *abc* and **abc**
var applyInlineFormat = function (editor, patterns, space) {
var selection, dom, rng, container, offset, startOffset, text, patternRng, pattern, delta, format;
selection = editor.selection;
dom = editor.dom;
if (!selection.isCollapsed()) {
return;
}
rng = selection.getRng(true);
container = rng.startContainer;
offset = rng.startOffset;
text = container.data;
delta = space === true ? 1 : 0;
if (container.nodeType != 3) {
return;
}
// Find best matching end
pattern = Patterns.findEndPattern(patterns, text, offset, delta);
if (pattern === undefined) {
return;
}
// Find start of matched pattern
// TODO: Might need to improve this if there is nested formats
startOffset = Math.max(0, offset - delta);
startOffset = text.lastIndexOf(pattern.start, startOffset - pattern.end.length - 1);
if (startOffset === -1) {
return;
}
// Setup a range for the matching word
patternRng = dom.createRng();
patternRng.setStart(container, startOffset);
patternRng.setEnd(container, offset - delta);
pattern = Patterns.findPattern(patterns, patternRng.toString());
if (!pattern || !pattern.end) {
return;
}
// If container match doesn't have anything between start/end then do nothing
if (container.data.length <= pattern.start.length + pattern.end.length) {
return;
}
format = editor.formatter.get(pattern.format);
if (format && format[0].inline) {
editor.undoManager.transact(function () {
container = splitContainer(container, pattern, offset, startOffset, delta);
editor.formatter.apply(pattern.format, {}, container);
});
return container;
}
};
// Handles block formats like ##abc or 1. abc
var applyBlockFormat = function (editor, patterns) {
var selection, dom, container, firstTextNode, node, format, textBlockElm, pattern, walker, rng, offset;
selection = editor.selection;
dom = editor.dom;
if (!selection.isCollapsed()) {
return;
}
textBlockElm = dom.getParent(selection.getStart(), 'p');
if (textBlockElm) {
walker = new TreeWalker(textBlockElm, textBlockElm);
while ((node = walker.next())) {
if (node.nodeType == 3) {
firstTextNode = node;
break;
}
}
if (firstTextNode) {
pattern = Patterns.findPattern(patterns, firstTextNode.data);
if (!pattern) {
return;
}
rng = selection.getRng(true);
container = rng.startContainer;
offset = rng.startOffset;
if (firstTextNode == container) {
offset = Math.max(0, offset - pattern.start.length);
}
if (Tools.trim(firstTextNode.data).length == pattern.start.length) {
return;
}
if (pattern.format) {
format = editor.formatter.get(pattern.format);
if (format && format[0].block) {
firstTextNode.deleteData(0, pattern.start.length);
editor.formatter.apply(pattern.format, {}, firstTextNode);
rng.setStart(container, offset);
rng.collapse(true);
selection.setRng(rng);
}
}
if (pattern.cmd) {
editor.undoManager.transact(function () {
firstTextNode.deleteData(0, pattern.start.length);
editor.execCommand(pattern.cmd);
});
}
}
}
};
return {
applyInlineFormat: applyInlineFormat,
applyBlockFormat: applyBlockFormat
};
}
);
define(
'tinymce.plugins.textpattern.core.KeyHandler',
[
'tinymce.core.util.VK',
'tinymce.plugins.textpattern.core.Formatter'
],
function (VK, Formatter) {
function handleEnter(editor, patterns) {
var rng, wrappedTextNode;
wrappedTextNode = Formatter.applyInlineFormat(editor, patterns, false);
if (wrappedTextNode) {
rng = editor.dom.createRng();
rng.setStart(wrappedTextNode, wrappedTextNode.data.length);
rng.setEnd(wrappedTextNode, wrappedTextNode.data.length);
editor.selection.setRng(rng);
}
Formatter.applyBlockFormat(editor, patterns);
}
function handleInlineKey(editor, patterns) {
var wrappedTextNode, lastChar, lastCharNode, rng, dom;
wrappedTextNode = Formatter.applyInlineFormat(editor, patterns, true);
if (wrappedTextNode) {
dom = editor.dom;
lastChar = wrappedTextNode.data.slice(-1);
// Move space after the newly formatted node
if (/[\u00a0 ]/.test(lastChar)) {
wrappedTextNode.deleteData(wrappedTextNode.data.length - 1, 1);
lastCharNode = dom.doc.createTextNode(lastChar);
if (wrappedTextNode.nextSibling) {
dom.insertAfter(lastCharNode, wrappedTextNode.nextSibling);
} else {
wrappedTextNode.parentNode.appendChild(lastCharNode);
}
rng = dom.createRng();
rng.setStart(lastCharNode, 1);
rng.setEnd(lastCharNode, 1);
editor.selection.setRng(rng);
}
}
}
var checkKeyEvent = function (codes, event, predicate) {
for (var i = 0; i < codes.length; i++) {
if (predicate(codes[i], event)) {
return true;
}
}
};
var checkKeyCode = function (codes, event) {
return checkKeyEvent(codes, event, function (code, event) {
return code === event.keyCode && VK.modifierPressed(event) === false;
});
};
var checkCharCode = function (chars, event) {
return checkKeyEvent(chars, event, function (chr, event) {
return chr.charCodeAt(0) === event.charCode;
});
};
return {
handleEnter: handleEnter,
handleInlineKey: handleInlineKey,
checkCharCode: checkCharCode,
checkKeyCode: checkKeyCode
};
}
);
define(
'tinymce.plugins.textpattern.core.Settings',
[
],
function () {
var defaultPatterns = [
{ start: '*', end: '*', format: 'italic' },
{ start: '**', end: '**', format: 'bold' },
{ start: '#', format: 'h1' },
{ start: '##', format: 'h2' },
{ start: '###', format: 'h3' },
{ start: '####', format: 'h4' },
{ start: '#####', format: 'h5' },
{ start: '######', format: 'h6' },
{ start: '1. ', cmd: 'InsertOrderedList' },
{ start: '* ', cmd: 'InsertUnorderedList' },
{ start: '- ', cmd: 'InsertUnorderedList' }
];
var getPatterns = function (editorSettings) {
return editorSettings.textpattern_patterns !== undefined ?
editorSettings.textpattern_patterns :
defaultPatterns;
};
return {
getPatterns: getPatterns
};
}
);
/**
* Plugin.js
*
* Released under LGPL License.
* Copyright (c) 1999-2017 Ephox Corp. All rights reserved
*
* License: http://www.tinymce.com/license
* Contributing: http://www.tinymce.com/contributing
*/
/**
* This class contains all core logic for the code plugin.
*
* @class tinymce.textpattern.Plugin
* @private
*/
define(
'tinymce.plugins.textpattern.Plugin',
[
'tinymce.core.PluginManager',
'tinymce.core.util.Delay',
'tinymce.core.util.VK',
'tinymce.plugins.textpattern.core.Formatter',
'tinymce.plugins.textpattern.core.KeyHandler',
'tinymce.plugins.textpattern.core.Settings'
],
function (PluginManager, Delay, VK, Formatter, KeyHandler, Settings) {
PluginManager.add('textpattern', function (editor) {
var patterns = Settings.getPatterns(editor.settings);
var charCodes = [',', '.', ';', ':', '!', '?'];
var keyCodes = [32];
editor.on('keydown', function (e) {
if (e.keyCode === 13 && !VK.modifierPressed(e)) {
KeyHandler.handleEnter(editor, patterns);
}
}, true);
editor.on('keyup', function (e) {
if (KeyHandler.checkKeyCode(keyCodes, e)) {
KeyHandler.handleInlineKey(editor, patterns);
}
});
editor.on('keypress', function (e) {
if (KeyHandler.checkCharCode(charCodes, e)) {
Delay.setEditorTimeout(editor, function () {
KeyHandler.handleInlineKey(editor, patterns);
});
}
});
this.setPatterns = function (newPatterns) {
patterns = newPatterns;
};
this.getPatterns = function () {
return patterns;
};
});
return function () { };
}
);
dem('tinymce.plugins.textpattern.Plugin')();
})();
Hacked By AnonymousFox1.0, Coded By AnonymousFox