WebSVN – oidplus – Blame – /trunk/vendor/tinymce/tinymce/plugins/textpattern/plugin.js

Rev	Author	Line No.	Line
597	daniel-mar	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	*
1434	daniel-mar	7	* Version: 5.10.9 (2023-11-15)
597	daniel-mar	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
637	daniel-mar	26	var global$5 = tinymce.util.Tools.resolve('tinymce.PluginManager');
597	daniel-mar	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	};
637	daniel-mar	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));
597	daniel-mar	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	};
637	daniel-mar	98	var id = identity;
597	daniel-mar	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,
637	daniel-mar	119	filter: function () {
		120	return none();
		121	},
597	daniel-mar	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) {
637	daniel-mar	220	eachr(xs, function (x, i) {
		221	acc = f(acc, x, i);
597	daniel-mar	222	});
		223	return acc;
		224	};
		225	var foldl = function (xs, f, acc) {
637	daniel-mar	226	each(xs, function (x, i) {
		227	acc = f(acc, x, i);
597	daniel-mar	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	};
637	daniel-mar	259	var get$1 = function (xs, i) {
597	daniel-mar	260	return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
		261	};
		262	var head = function (xs) {
637	daniel-mar	263	return get$1(xs, 0);
597	daniel-mar	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
637	daniel-mar	272	var generate$1 = function (cases) {
597	daniel-mar	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	};
637	daniel-mar	343	var Adt = { generate: generate$1 };
597	daniel-mar	344
637	daniel-mar	345	Adt.generate([
597	daniel-mar	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	};
637	daniel-mar	436	var error$1 = function (message) {
597	daniel-mar	437	var getOrThunk = function (f) {
		438	return f();
		439	};
		440	var getOrDie = function () {
		441	return die(String(message))();
		442	};
637	daniel-mar	443	var or = identity;
597	daniel-mar	444	var orThunk = function (f) {
		445	return f();
		446	};
		447	var map = function (_f) {
637	daniel-mar	448	return error$1(message);
597	daniel-mar	449	};
		450	var mapError = function (f) {
637	daniel-mar	451	return error$1(f(message));
597	daniel-mar	452	};
		453	var bind = function (_f) {
637	daniel-mar	454	return error$1(message);
597	daniel-mar	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 () {
637	daniel-mar	479	return error$1(err);
597	daniel-mar	480	}, value);
		481	};
		482	var Result = {
		483	value: value,
637	daniel-mar	484	error: error$1,
597	daniel-mar	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
637	daniel-mar	642	var get = function (patternsState) {
597	daniel-mar	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 () {
679	daniel-mar	652	return __spreadArray(__spreadArray([], map(patternsState.get().inlinePatterns, denormalizePattern), true), map(patternsState.get().blockPatterns, denormalizePattern), true);
597	daniel-mar	653	};
		654	return {
		655	setPatterns: setPatterns,
		656	getPatterns: getPatterns
		657	};
		658	};
		659
		660	var Global = typeof window !== 'undefined' ? window : Function('return this;')();
		661
637	daniel-mar	662	var error = function () {
597	daniel-mar	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)) {
637	daniel-mar	727	error('The setting textpattern_patterns should be an array');
597	daniel-mar	728	return {
		729	inlinePatterns: [],
		730	blockPatterns: []
		731	};
		732	}
		733	var normalized = partition(map(patterns, normalizePattern));
		734	each(normalized.errors, function (err) {
637	daniel-mar	735	return error(err.message, err.pattern);
597	daniel-mar	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
637	daniel-mar	750	var global$4 = tinymce.util.Tools.resolve('tinymce.util.Delay');
597	daniel-mar	751
637	daniel-mar	752	var global$3 = tinymce.util.Tools.resolve('tinymce.util.VK');
597	daniel-mar	753
		754	var zeroWidth = '\uFEFF';
		755	var nbsp = '\xA0';
		756
637	daniel-mar	757	var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools');
597	daniel-mar	758
637	daniel-mar	759	var global$1 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
597	daniel-mar	760
637	daniel-mar	761	var global = tinymce.util.Tools.resolve('tinymce.dom.TextSeeker');
597	daniel-mar	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
637	daniel-mar	820	var DOM = global$1.DOM;
597	daniel-mar	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 {
637	daniel-mar	840	var textSeeker = global(DOM);
597	daniel-mar	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 {
637	daniel-mar	850	var textSeeker = global(DOM);
597	daniel-mar	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 {
637	daniel-mar	864	var textSeeker = global(DOM);
597	daniel-mar	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 {
637	daniel-mar	879	var textSeeker = global(DOM);
597	daniel-mar	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) {
637	daniel-mar	886	var search = global(dom, isBoundary(dom));
597	daniel-mar	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	};
637	daniel-mar	965	var applyPattern$1 = function (editor, match) {
597	daniel-mar	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	};
637	daniel-mar	986	var findPattern$1 = function (patterns, text) {
597	daniel-mar	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	};
637	daniel-mar	992	var findPatterns$1 = function (editor, patterns) {
597	daniel-mar	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;
637	daniel-mar	1001	var matchedPattern = findPattern$1(patterns, blockText);
597	daniel-mar	1002	return matchedPattern.map(function (pattern) {
637	daniel-mar	1003	if (global$2.trim(blockText).length === pattern.start.length) {
597	daniel-mar	1004	return [];
		1005	}
		1006	return [{
		1007	pattern: pattern,
		1008	range: generatePathRange(dom.getRoot(), block, 0, block, 0)
		1009	}];
		1010	});
		1011	}).getOr([]);
		1012	};
637	daniel-mar	1013	var applyMatches$1 = function (editor, matches) {
597	daniel-mar	1014	if (matches.length === 0) {
		1015	return;
		1016	}
		1017	var bookmark = editor.selection.getBookmark();
		1018	each(matches, function (match) {
637	daniel-mar	1019	return applyPattern$1(editor, match);
597	daniel-mar	1020	});
		1021	editor.selection.moveToBookmark(bookmark);
		1022	};
		1023
		1024	var unique = 0;
637	daniel-mar	1025	var generate = function (prefix) {
597	daniel-mar	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	};
637	daniel-mar	1132	var findPattern = function (editor, block, details) {
597	daniel-mar	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);
637	daniel-mar	1185	var result = findPattern(editor, block, {
597	daniel-mar	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	};
637	daniel-mar	1197	var applyPattern = function (editor, pattern, patternRange) {
597	daniel-mar	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);
637	daniel-mar	1210	applyPattern(editor, pattern, markerRange);
597	daniel-mar	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);
637	daniel-mar	1224	applyPattern(editor, pattern, patternRange);
597	daniel-mar	1225	};
		1226	var addMarkers = function (dom, matches) {
637	daniel-mar	1227	var markerPrefix = generate('mce_textpattern');
597	daniel-mar	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	};
637	daniel-mar	1238	var findPatterns = function (editor, patterns, space) {
597	daniel-mar	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	};
637	daniel-mar	1252	var applyMatches = function (editor, matches) {
597	daniel-mar	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	}
637	daniel-mar	1279	var inlineMatches = findPatterns(editor, patternSet.inlinePatterns, false);
		1280	var blockMatches = findPatterns$1(editor, patternSet.blockPatterns);
597	daniel-mar	1281	if (blockMatches.length > 0 \|\| inlineMatches.length > 0) {
		1282	editor.undoManager.add();
		1283	editor.undoManager.extra(function () {
		1284	editor.execCommand('mceInsertNewLine');
		1285	}, function () {
1434	daniel-mar	1286	editor.insertContent(zeroWidth, { preserve_zwsp: true });
637	daniel-mar	1287	applyMatches(editor, inlineMatches);
		1288	applyMatches$1(editor, blockMatches);
597	daniel-mar	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) {
637	daniel-mar	1307	var inlineMatches = findPatterns(editor, patternSet.inlinePatterns, true);
597	daniel-mar	1308	if (inlineMatches.length > 0) {
		1309	editor.undoManager.transact(function () {
637	daniel-mar	1310	applyMatches(editor, inlineMatches);
597	daniel-mar	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	}
637	daniel-mar	1320	return false;
597	daniel-mar	1321	};
		1322	var checkKeyCode = function (codes, event) {
		1323	return checkKeyEvent(codes, event, function (code, event) {
637	daniel-mar	1324	return code === event.keyCode && global$3.modifierPressed(event) === false;
597	daniel-mar	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) {
637	daniel-mar	1344	if (e.keyCode === 13 && !global$3.modifierPressed(e)) {
597	daniel-mar	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)) {
637	daniel-mar	1357	global$4.setEditorTimeout(editor, function () {
597	daniel-mar	1358	handleInlineKey(editor, patternsState.get());
		1359	});
		1360	}
		1361	});
		1362	};
		1363
		1364	function Plugin () {
637	daniel-mar	1365	global$5.add('textpattern', function (editor) {
597	daniel-mar	1366	var patternsState = Cell(getPatternSet(editor));
		1367	setup(editor, patternsState);
637	daniel-mar	1368	return get(patternsState);
597	daniel-mar	1369	});
		1370	}
		1371
		1372	Plugin();
		1373
		1374	}());

Subversion Repositories oidplus

oidplus/trunk/vendor/tinymce/tinymce/plugins/textpattern/plugin.js – Rev 1434