Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/prismjs/components/prism-markup-templating.js
f646e1f695a7paginated-inlines

prism-markup-templating.js
View Options

			(function (Prism) {

			/**
			* Returns the placeholder for the given language id and index.
			*
			* @param {string} language
			* @param {string\|number} index
			* @returns {string}
			*/
			function getPlaceholder(language, index) {
			return '___' + language.toUpperCase() + index + '___';
			}

			Object.defineProperties(Prism.languages['markup-templating'] = {}, {
			buildPlaceholders: {
			/**
			* Tokenize all inline templating expressions matching `placeholderPattern`.
			*
			* If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
			* `true` will be replaced.
			*
			* @param {object} env The environment of the `before-tokenize` hook.
			* @param {string} language The language id.
			* @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
			* @param {(match: string) => boolean} [replaceFilter]
			*/
			value: function (env, language, placeholderPattern, replaceFilter) {
			if (env.language !== language) {
			return;
			}

			var tokenStack = env.tokenStack = [];

			env.code = env.code.replace(placeholderPattern, function (match) {
			if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
			return match;
			}
			var i = tokenStack.length;
			var placeholder;

			// Check for existing strings
			while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {
			++i;
			}

			// Create a sparse array
			tokenStack[i] = match;

			return placeholder;
			});

			// Switch the grammar to markup
			env.grammar = Prism.languages.markup;
			}
			},
			tokenizePlaceholders: {
			/**
			* Replace placeholders with proper tokens after tokenizing.
			*
			* @param {object} env The environment of the `after-tokenize` hook.
			* @param {string} language The language id.
			*/
			value: function (env, language) {
			if (env.language !== language \|\| !env.tokenStack) {
			return;
			}

			// Switch the grammar back
			env.grammar = Prism.languages[language];

			var j = 0;
			var keys = Object.keys(env.tokenStack);

			function walkTokens(tokens) {
			for (var i = 0; i < tokens.length; i++) {
			// all placeholders are replaced already
			if (j >= keys.length) {
			break;
			}

			var token = tokens[i];
			if (typeof token === 'string' \|\| (token.content && typeof token.content === 'string')) {
			var k = keys[j];
			var t = env.tokenStack[k];
			var s = typeof token === 'string' ? token : token.content;
			var placeholder = getPlaceholder(language, k);

			var index = s.indexOf(placeholder);
			if (index > -1) {
			++j;

			var before = s.substring(0, index);
			var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);
			var after = s.substring(index + placeholder.length);

			var replacement = [];
			if (before) {
			replacement.push.apply(replacement, walkTokens([before]));
			}
			replacement.push(middle);
			if (after) {
			replacement.push.apply(replacement, walkTokens([after]));
			}

			if (typeof token === 'string') {
			tokens.splice.apply(tokens, [i, 1].concat(replacement));
			} else {
			token.content = replacement;
			}
			}
			} else if (token.content /* && typeof token.content !== 'string' */) {
			walkTokens(token.content);
			}
			}

			return tokens;
			}

			walkTokens(env.tokens);
			}
			}
			});

			}(Prism));