@fuzdev/fuz_code 0.37.0

package/src/lib/grammar_js.ts

@@ -0,0 +1,215 @@
+import type {AddSyntaxGrammar} from './syntax_styler.js';
+import {grammar_markup_add_attribute, grammar_markup_add_inlined} from './grammar_markup.js';
+import {class_keywords} from './grammar_clike.js';
+
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_js: AddSyntaxGrammar = (syntax_styler) => {
+	const grammar_clike = syntax_styler.get_lang('clike');
+
+	// Main JS keywords (from keyword pattern, excluding those with special lookaheads)
+	const main_keywords =
+		'class|const|debugger|delete|enum|extends|function|implements|in|instanceof|interface|let|new|null|of|package|private|protected|public|static|super|this|typeof|undefined|var|void|with';
+
+	// Keywords that are treated specially (inserted before 'function')
+	const special_keywords =
+		'as|await|break|case|catch|continue|default|do|else|export|finally|for|from|if|import|return|switch|throw|try|while|yield';
+
+	// All JS keywords (for negative lookahead in parameter pattern)
+	// Note: 'assert', 'async', 'get', 'set' have special lookahead requirements in the main keyword pattern
+	const all_js_keywords = `assert|async|${main_keywords}|get|set|${special_keywords}`;
+
+	const grammar_js = syntax_styler.add_extended_lang(
+		'clike',
+		'js',
+		{
+			class_name: [
+				...grammar_clike.class_name!,
+				{
+					pattern:
+						/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+					lookbehind: true,
+				},
+			],
+			keyword: [
+				{
+					pattern: new RegExp(
+						`(^|[^.]|\\.\\.\\.\\s*)\\b(?:assert(?=\\s*\\{)|async(?=\\s*(?:function\\b|\\*|\\(|[$\\w\\xA0-\\uFFFF]|$))|${main_keywords}|(?:get|set)(?=\\s*(?:[#[$\\w\\xA0-\\uFFFF]|$)))\\b`,
+					),
+					lookbehind: true,
+				},
+			],
+			// Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+			function:
+				/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+			number: {
+				pattern: RegExp(
+					/(^|[^\w$])/.source +
+						'(?:' +
+						// constant
+						(/NaN|Infinity/.source +
+							'|' +
+							// binary integer
+							/0[bB][01]+(?:_[01]+)*n?/.source +
+							'|' +
+							// octal integer
+							/0[oO][0-7]+(?:_[0-7]+)*n?/.source +
+							'|' +
+							// hexadecimal integer
+							/0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source +
+							'|' +
+							// decimal bigint
+							/\d+(?:_\d+)*n/.source +
+							'|' +
+							// decimal number (integer or float) but no bigint
+							/(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/
+								.source) +
+						')' +
+						/(?![\w$])/.source,
+				),
+				lookbehind: true,
+			},
+			operator:
+				/--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
+		},
+		['javascript'],
+	);
+
+	(grammar_js as any).class_name[0].pattern = new RegExp(
+		`(\\b(?:${class_keywords})\\s+)[\\w.\\\\]+`,
+	);
+
+	syntax_styler.grammar_insert_before('js', 'function', {
+		special_keyword: new RegExp(`\\b(?:${special_keywords})\\b`),
+	});
+
+	syntax_styler.grammar_insert_before('js', 'keyword', {
+		regex: {
+			pattern: RegExp(
+				// lookbehind
+				/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source +
+					// Regex pattern:
+					// There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
+					// classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
+					// with the only syntax, so we have to define 2 different regex patterns.
+					/\//.source +
+					'(?:' +
+					/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\[\r\n])+\/[dgimyus]{0,7}/.source +
+					'|' +
+					// `v` flag syntax. This supports 3 levels of nested character classes.
+					/(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/
+						.source +
+					')' +
+					// lookahead
+					/(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source,
+			),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				regex_source: {
+					pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+					lookbehind: true,
+					alias: 'lang_regex',
+					inside: syntax_styler.langs.regex, // TODO use `get_lang` after adding `regex` support
+				},
+				regex_delimiter: /^\/|\/$/,
+				regex_flags: /^[a-z]+$/,
+			},
+		},
+		// Arrow function and function expression variable names
+		// This must be declared before keyword because we use "function" inside the look-forward
+		function_variable: {
+			pattern:
+				/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+			alias: 'function',
+		},
+		parameter: [
+			{
+				pattern:
+					/(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+				lookbehind: true,
+				inside: grammar_js,
+			},
+			{
+				pattern:
+					/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+				lookbehind: true,
+				inside: grammar_js,
+			},
+			{
+				pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+				lookbehind: true,
+				inside: grammar_js,
+			},
+			{
+				pattern: new RegExp(
+					`((?:\\b|\\s|^)(?!(?:${all_js_keywords})(?![$\\w\\xA0-\\uFFFF]))(?:(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*)\\(\\s*|\\]\\s*\\(\\s*)(?!\\s)(?:[^()\\s]|\\s+(?![\\s)])|\\([^()]*\\))+(?=\\s*\\)\\s*\\{)`,
+				),
+				lookbehind: true,
+				inside: grammar_js,
+			},
+		],
+		constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/,
+		// Heuristic: treat capitalized identifiers as class names when not already matched
+		capitalized_identifier: {
+			pattern: /\b[A-Z][\w]*\b/,
+			alias: 'class_name',
+		},
+	});
+
+	syntax_styler.grammar_insert_before('js', 'string', {
+		hashbang: {
+			pattern: /^#!.*/,
+			greedy: true,
+			alias: 'comment',
+		},
+		template_string: {
+			pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+			greedy: true,
+			inside: {
+				template_punctuation: {
+					pattern: /^`|`$/,
+					alias: 'string',
+				},
+				interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+					lookbehind: true,
+					inside: {
+						interpolation_punctuation: {
+							pattern: /^\$\{|\}$/,
+							alias: 'punctuation',
+						},
+						rest: grammar_js as any, // TODO try to fix this type
+					},
+				},
+				string: /[\s\S]+/,
+			},
+		},
+		string_property: {
+			pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+			lookbehind: true,
+			greedy: true,
+			alias: 'property',
+		},
+	});
+
+	syntax_styler.grammar_insert_before('js', 'operator', {
+		literal_property: {
+			pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+			lookbehind: true,
+			alias: 'property',
+		},
+	});
+
+	grammar_markup_add_inlined(syntax_styler, 'script', 'js');
+
+	// add attribute support for all DOM events (on* attributes)
+	// https://developer.mozilla.org/en-US/docs/Web/Events#Standard_events
+	grammar_markup_add_attribute(syntax_styler, 'on\\w+', 'js');
+};

package/src/lib/grammar_json.ts

@@ -0,0 +1,38 @@
+import type {AddSyntaxGrammar, SyntaxGrammarRaw} from './syntax_styler.js';
+
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_json: AddSyntaxGrammar = (syntax_styler) => {
+	const grammar_json = {
+		property: {
+			pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+			lookbehind: true,
+			greedy: true,
+		},
+		string: {
+			pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+			lookbehind: true,
+			greedy: true,
+		},
+		comment: {
+			pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+			greedy: true,
+		},
+		number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+		punctuation: /[{}[\],]/,
+		operator: /:/,
+		boolean: /\b(?:false|true)\b/,
+		null: {
+			pattern: /\bnull\b/,
+			alias: 'keyword',
+		},
+	} satisfies SyntaxGrammarRaw;
+
+	syntax_styler.add_lang('json', grammar_json);
+};

package/src/lib/grammar_markdown.ts

@@ -0,0 +1,289 @@
+import type {
+	AddSyntaxGrammar,
+	SyntaxGrammarTokenRaw,
+	SyntaxGrammarValueRaw,
+	SyntaxStyler,
+} from './syntax_styler.js';
+
+interface LangDefinition {
+	aliases: Array<string>;
+	id: string;
+}
+
+interface FenceType {
+	backticks: string;
+	suffix: string;
+}
+
+/**
+ * Helper to create fenced code block pattern for a language
+ */
+const create_fence_pattern = (
+	backticks: string,
+	aliases: Array<string>,
+	lang_id: string,
+	syntax_styler: SyntaxStyler,
+): SyntaxGrammarTokenRaw => {
+	const aliases_pattern = aliases.join('|');
+	const pattern = new RegExp(
+		`^${backticks}(?:${aliases_pattern})[^\\n\\r]*(?:\\r?\\n|\\r)[\\s\\S]*?^${backticks}$`,
+		'm',
+	);
+	const code_fence_pattern = new RegExp(`^${backticks}[^\\n\\r]*|^${backticks}$`, 'm');
+
+	return {
+		pattern,
+		greedy: true,
+		inside: {
+			code_fence: {
+				pattern: code_fence_pattern,
+				alias: 'punctuation',
+			},
+			[`lang_${lang_id}`]: {
+				pattern: /[\s\S]+/,
+				inside: syntax_styler.get_lang(lang_id),
+			},
+		},
+	};
+};
+
+/**
+ * Helper to create catch-all fence pattern (unknown languages)
+ */
+const create_catchall_fence = (backticks: string): SyntaxGrammarTokenRaw => {
+	const pattern = new RegExp(`^${backticks}[^\\n\\r]*(?:\\r?\\n|\\r)[\\s\\S]*?^${backticks}$`, 'm');
+	const code_fence_pattern = new RegExp(`^${backticks}[^\\n\\r]*|^${backticks}$`, 'm');
+
+	return {
+		pattern,
+		greedy: true,
+		inside: {
+			code_fence: {
+				pattern: code_fence_pattern,
+				alias: 'punctuation',
+			},
+		},
+	};
+};
+
+/**
+ * Helper to create md self-reference placeholder pattern
+ */
+const create_md_placeholder = (backticks: string): SyntaxGrammarTokenRaw => {
+	const pattern = new RegExp(
+		`^${backticks}(?:md|markdown)[^\\n\\r]*(?:\\r?\\n|\\r)[\\s\\S]*?^${backticks}$`,
+		'm',
+	);
+	const code_fence_pattern = new RegExp(`^${backticks}[^\\n\\r]*|^${backticks}$`, 'm');
+
+	return {
+		pattern,
+		greedy: true,
+		inside: {
+			code_fence: {
+				pattern: code_fence_pattern,
+				alias: 'punctuation',
+			},
+			// lang_md will be added after registration
+		},
+	};
+};
+
+/**
+ * Markdown grammar extending markup.
+ * Supports: headings, fenced code blocks (3/4/5 backticks with nesting), lists, blockquotes,
+ * bold, italic, strikethrough, inline code, and links.
+ */
+export const add_grammar_markdown: AddSyntaxGrammar = (syntax_styler) => {
+	// Language definitions with aliases
+	const langs: Array<LangDefinition> = [
+		{aliases: ['ts', 'typescript'], id: 'ts'},
+		{aliases: ['js', 'javascript'], id: 'js'},
+		{aliases: ['css'], id: 'css'},
+		{aliases: ['html', 'markup'], id: 'markup'},
+		{aliases: ['json'], id: 'json'},
+		{aliases: ['svelte'], id: 'svelte'},
+	];
+
+	// Fence types: higher counts first (for proper precedence in tokenization)
+	const fence_types: Array<FenceType> = [
+		{backticks: '`````', suffix: '5tick'},
+		{backticks: '````', suffix: '4tick'},
+		{backticks: '```', suffix: ''},
+	];
+
+	// Build grammar dynamically
+	const grammar: Record<string, SyntaxGrammarValueRaw> = {};
+	const md_self_refs: Array<string> = []; // Track md patterns for later self-reference
+
+	// Generate fence patterns for each type
+	for (const {backticks, suffix} of fence_types) {
+		const token_suffix = suffix ? `_${suffix}` : '';
+
+		// md pattern (self-reference added after registration)
+		const md_key = `fenced_code${token_suffix}_md`;
+		grammar[md_key] = create_md_placeholder(backticks);
+		md_self_refs.push(md_key);
+
+		// Other language patterns (use first alias as token name for backward compatibility)
+		for (const {aliases, id} of langs) {
+			const token_name = aliases[0]; // Use first alias for token name
+			grammar[`fenced_code${token_suffix}_${token_name}`] = create_fence_pattern(
+				backticks,
+				aliases,
+				id,
+				syntax_styler,
+			);
+		}
+
+		// Catch-all fence
+		grammar[`fenced_code${token_suffix}`] = create_catchall_fence(backticks);
+	}
+
+	// Register markdown grammar first, then add self-references for md fences
+	const grammar_md = syntax_styler.add_extended_lang(
+		'markup',
+		'md',
+		{
+			...grammar,
+
+			// Headings (# through ######)
+			heading: {
+				pattern: /^#{1,6}\s+.+$/m,
+				inside: {
+					punctuation: {
+						pattern: /^#{1,6}/,
+						alias: 'heading_punctuation',
+					},
+				},
+			},
+
+			// Blockquotes (> at line start)
+			blockquote: {
+				pattern: /^>\s*.+$/m,
+				inside: {
+					punctuation: {
+						pattern: /^>/,
+						alias: 'blockquote_punctuation',
+					},
+				},
+			},
+
+			// Lists (* or - with any preceding whitespace)
+			list: {
+				pattern: /^\s*[-*]\s+.+$/m,
+				inside: {
+					punctuation: /^\s*[-*]/,
+				},
+			},
+
+			// Inline elements
+
+			// Links [text](url)
+			link: {
+				pattern: /\[[^[\]\n\r]+\]\([^)\n\r]+\)/,
+				inside: {
+					link_text_wrapper: {
+						pattern: /^\[[^\]]+\]/,
+						inside: {
+							punctuation: {
+								pattern: /^\[|\]$/,
+								alias: 'link_punctuation',
+							},
+							link_text: /[^[\]]+/,
+						},
+					},
+					url_wrapper: {
+						pattern: /\([^)]+\)$/,
+						inside: {
+							punctuation: {
+								pattern: /^\(|\)$/,
+								alias: 'link_punctuation',
+							},
+							url: /[^()]+/,
+						},
+					},
+				},
+			},
+
+			// Inline code `text`
+			inline_code: {
+				pattern: /`[^`\n\r]+`/,
+				alias: 'code',
+				inside: {
+					punctuation: {
+						pattern: /^`|`$/,
+						alias: 'code_punctuation',
+					},
+					content: /[^`]+/,
+				},
+			},
+
+			// Bold **text** or __text__
+			bold: [
+				{
+					// **text** - no asterisks inside
+					pattern: /\*\*[^\s*][^*]*[^\s*]\*\*|\*\*[^\s*]\*\*/,
+					inside: {
+						punctuation: /^\*\*|\*\*$/,
+					},
+				},
+				{
+					// __text__ - at word boundaries, no underscores inside
+					pattern: /\b__[^\s_][^_]*[^\s_]__\b|\b__[^\s_]__\b/,
+					inside: {
+						punctuation: /^__|__$/,
+					},
+				},
+			],
+
+			// Italic *text* or _text_
+			italic: [
+				{
+					// *text* - no asterisks inside
+					pattern: /\*[^\s*][^*]*[^\s*]\*|\*[^\s*]\*/,
+					inside: {
+						punctuation: /^\*|\*$/,
+					},
+				},
+				{
+					// _text_ - at word boundaries, no underscores inside
+					pattern: /\b_[^\s_][^_]*[^\s_]_\b|\b_[^\s_]_\b/,
+					inside: {
+						punctuation: /^_|_$/,
+					},
+				},
+			],
+
+			// Strikethrough ~~text~~
+			strikethrough: {
+				pattern: /~~[^\s~][^~]*[^\s~]~~|~~[^\s~]~~/,
+				inside: {
+					punctuation: /^~~|~~$/,
+				},
+			},
+		},
+		['markdown'],
+	);
+
+	// Add self-reference for markdown-in-markdown (all fence types)
+	// This must be done after registration to avoid circular dependency
+	const lang_md_inside = {
+		pattern: /[\s\S]+/,
+		inside: syntax_styler.get_lang('md'),
+	};
+	for (const key of md_self_refs) {
+		// After normalization, grammar values are arrays of SyntaxGrammarToken
+		// We need to add lang_md as a normalized array
+		const patterns = grammar_md[key]!;
+		// Manually normalize the lang_md pattern we're adding
+		const lang_md_token = {
+			pattern: lang_md_inside.pattern,
+			lookbehind: false,
+			greedy: false,
+			alias: [],
+			inside: lang_md_inside.inside,
+		};
+		patterns[0]!.inside!.lang_md = [lang_md_token];
+	}
+};