@intlayer/core/dist/cjs/markdown/parser.cjs

Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.

Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const require_markdown_constants = require('./constants.cjs');
const require_markdown_utils = require('./utils.cjs');

//#region src/markdown/parser.ts
/**
* Creates a parser for a given set of rules, with the precedence
* specified as a list of rules.
*
* @param rules - An object containing rule type -> {match, order, parse} objects
*                (lower order is higher precedence)
*
* @returns The resulting parse function
*/
const parserFor = (rules) => {
	const start = performance.now();
	const ruleList = Object.keys(rules);
	if (process.env.NODE_ENV !== "production") ruleList.forEach((type) => {
		const order = rules[type]?._order;
		if (typeof order !== "number" || !Number.isFinite(order)) console.warn(`intlayer: Invalid order for rule \`${type}\`: ${order}`);
	});
	ruleList.sort((a, b) => {
		return rules[a]._order - rules[b]._order || +a - +b;
	});
	const nestedParse = (source, state = {}) => {
		const parseStart = performance.now();
		const result = [];
		state.prevCapture = state.prevCapture || "";
		if (source.trim()) while (source) {
			let i = 0;
			while (i < ruleList.length) {
				const ruleType = ruleList[i];
				const rule = rules[ruleType];
				if (rule?._qualify && !require_markdown_utils.qualifies(source, state, rule._qualify)) {
					i++;
					continue;
				}
				const matchStart = performance.now();
				const capture = rule?._match(source, state);
				if (process.env.NODE_ENV !== "production") {
					const matchDuration = performance.now() - matchStart;
					if (matchDuration > 1) console.log(`${ruleType}._match: ${matchDuration.toFixed(3)}ms, source length: ${source.length}`);
				}
				if (capture?.[0]) {
					source = source.substring(capture[0].length);
					const ruleParseStart = performance.now();
					const parsedAny = rule?._parse(capture, nestedParse, state);
					if (process.env.NODE_ENV !== "production") {
						const ruleParseDuration = performance.now() - ruleParseStart;
						if (ruleParseDuration > 1) console.log(`${ruleType}._parse: ${ruleParseDuration.toFixed(3)}ms, capture length: ${capture[0].length}`);
					}
					state.prevCapture = (state.prevCapture || "") + capture[0];
					if (!parsedAny.type) parsedAny.type = ruleType;
					result.push(parsedAny);
					break;
				}
				i++;
			}
		}
		if (process.env.NODE_ENV === "development") {
			const parseDuration = performance.now() - parseStart;
			if (parseDuration > 1) console.log(`nestedParse: ${parseDuration.toFixed(3)}ms, source length: ${source.length}, result count: ${result.length}`);
		}
		return result;
	};
	if (process.env.NODE_ENV === "development") {
		const duration = performance.now() - start;
		if (duration > 20) console.log(`parserFor: ${duration.toFixed(3)}ms, rules count: ${ruleList.length}`);
	}
	return (source, state) => nestedParse(require_markdown_utils.normalizeWhitespace(source), state);
};

//#endregion
exports.parserFor = parserFor;
//# sourceMappingURL=parser.cjs.map