Table of Contents

Other Languages

简体中文

Introduction

The LanguageService object is created by the Parser.createLanguageService method and used for language services.

All of the following properties and methods are available in the Mini version.

🌐 Available in the Browser version.

Properties

include

🌐 Expand

version added: 1.17.1

type: boolean
Whether to parse for transclusion, default is true.

// include
(async () => {
	var lsp = Parser.createLanguageService({}),
		wikitext = `<includeonly>
{
</includeonly>`;
	assert.deepStrictEqual(
		await lsp.provideDiagnostics(wikitext),
		[
			{
				range: {
					start: {line: 1, character: 0},
					end: {line: 1, character: 1},
				},
				severity: 2,
				source: 'WikiLint',
				code: 'lonely-bracket',
				message: 'lonely "{"',
				data: [],
			},
		],
	);
	lsp.include = false;
	assert.deepStrictEqual(await lsp.provideDiagnostics(wikitext), []);
})();

lilypond

Expand

type: string
The path to the LilyPond executable.

Methods

destroy

🌐 Expand

Destroy the instance.

// destroy
var lsp = Parser.createLanguageService({});
lsp.destroy();
assert.strictEqual(lsp.provideDiagnostics, undefined);

provideDocumentColors

🌐 Expand

param: (s: string) => [number, number, number, number] | [] The function to parse the color string.
param: string The wikitext content.
returns: Promise<ColorInformation[]>
List all color references found in the document.

// provideDocumentColors
(async () => {
	const rgba = (await import('color-rgba')).default;
	const lsp = Parser.createLanguageService({}),
		wikitext = `
<p style="color: rgba(255, 0, 0, .7)">
<poem style="color: #00ff00ff"/>
{{#tag:font|color=#f000}}
{{color|rgb(0 0 255 / 50%)}}
{{color|1=hsla(0, 100%, 50%, 0.5)}}
{{{|hsl(0deg 100 50)}}}
`;
	assert.deepStrictEqual(
		await lsp.provideDocumentColors(rgba, wikitext),
		[
			{
				range: {
					start: {line: 1, character: 17},
					end: {line: 1, character: 36},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 0.7},
			},
			{
				range: {
					start: {line: 2, character: 20},
					end: {line: 2, character: 29},
				},
				color: {red: 0, green: 1, blue: 0, alpha: 1},
			},
			{
				range: {
					start: {line: 3, character: 18},
					end: {line: 3, character: 23},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 0},
			},
			{
				range: {
					start: {line: 4, character: 8},
					end: {line: 4, character: 26},
				},
				color: {red: 0, green: 0, blue: 1, alpha: 0.5},
			},
			{
				range: {
					start: {line: 5, character: 10},
					end: {line: 5, character: 33},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 0.5},
			},
			{
				range: {
					start: {line: 6, character: 4},
					end: {line: 6, character: 20},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 1},
			},
		].reverse(),
	);
})();

// provideDocumentColors (Node.js)
(async () => {
	const rgba = (await import('color-rgba')).default;
	const lsp = Parser.createLanguageService({});
	assert.deepStrictEqual(
		await lsp.provideDocumentColors(
			rgba,
			`<p style="color:<!---->blue">
{|style=color:red`,
		),
		[
			{
				range: {
					start: {line: 1, character: 14},
					end: {line: 1, character: 17},
				},
				color: {red: 1, green: 0, blue: 0, alpha: 1},
			},
			{
				range: {
					start: {line: 0, character: 23},
					end: {line: 0, character: 27},
				},
				color: {red: 0, green: 0, blue: 1, alpha: 1},
			},
		],
	);
})();

provideColorPresentations

🌐 Expand

param: ColorPresentationParams
returns: ColorPresentation[]
Obtain a list of presentations for a color value at a given location.

// provideColorPresentations
var lsp = Parser.createLanguageService({}),
	range = {
		start: {line: 0, character: 0},
		end: {line: 0, character: 1},
	};
assert.deepStrictEqual(
	lsp.provideColorPresentations({
		color: {red: 1, green: 0, blue: 0, alpha: 0.5},
		range,
	}),
	[
		{
			label: '#ff000080',
			textEdit: {range, newText: '#ff000080'},
		},
	],
);
assert.deepStrictEqual(
	lsp.provideColorPresentations({
		color: {red: 0, green: 0.9, blue: 0, alpha: 1},
		range,
	}),
	[
		{
			label: '#00e600',
			textEdit: {range, newText: '#00e600'},
		},
	],
);

provideCompletionItems

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<CompletionItem[] | undefined>
Compute completion items at a given cursor position.

// provideCompletionItems
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
<Im </Im
{{{ a }}}{{{1}}}
[[ a ]][[:AA]]
[[ : file : b ]]
{{ #Ifexp
{{ pagenamee }}{{PageNamee}}
__T
[Gi
[[ file : c | Thumbnail | 100x100px ]]
[[ file : c | 100px ]]
<poem C
<ref n
<p Da
{{ c | ca= | CC = }}
{| style="" dir=l
`;
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 1, character: 3}))
			?.filter(({label}) => label.startsWith('im')),
		[
			{
				label: 'imagemap',
				kind: 'Class',
				textEdit: {
					range: {
						start: {line: 1, character: 1},
						end: {line: 1, character: 3},
					},
					newText: 'imagemap',
				},
			},
			{
				label: 'img',
				kind: 'Class',
				textEdit: {
					range: {
						start: {line: 1, character: 1},
						end: {line: 1, character: 3},
					},
					newText: 'img',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 1, character: 8}))
			?.filter(({label}) => label.startsWith('im')),
		[
			{
				label: 'imagemap',
				kind: 'Class',
				textEdit: {
					range: {
						start: {line: 1, character: 6},
						end: {line: 1, character: 8},
					},
					newText: 'imagemap>',
				},
			},
			{
				label: 'img',
				kind: 'Class',
				textEdit: {
					range: {
						start: {line: 1, character: 6},
						end: {line: 1, character: 8},
					},
					newText: 'img>',
				},
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideCompletionItems(wikitext, {line: 2, character: 5}),
		[
			{
				label: '1',
				kind: 'Variable',
				textEdit: {
					range: {
						start: {line: 2, character: 4},
						end: {line: 2, character: 5},
					},
					newText: '1',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 3, character: 4}))
			?.filter(({label}) => /^a/iu.test(label)),
		[
			{
				label: 'AA',
				kind: 'Folder',
				textEdit: {
					range: {
						start: {line: 3, character: 3},
						end: {line: 3, character: 4},
					},
					newText: 'AA',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 4, character: 11}))
			?.filter(({label}) => /^file:/iu.test(label)),
		[
			{
				label: 'File:C',
				kind: 'Folder',
				textEdit: {
					range: {
						start: {line: 4, character: 5},
						end: {line: 4, character: 11},
					},
					newText: 'File:C',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 5, character: 9}))
			?.filter(({label}) => /^#ifexp/iu.test(label))
			.map(({label, kind, textEdit}) => ({label, kind, textEdit})),
		[
			{
				label: '#ifexpr',
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 5, character: 3},
						end: {line: 5, character: 9},
					},
					newText: '#ifexpr',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 6, character: 12}))
			?.filter(({label}) => /^pagenamee/iu.test(label))
			.map(({label, kind, textEdit}) => ({label, kind, textEdit})),
		[
			{
				label: 'PAGENAMEE',
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 6, character: 3},
						end: {line: 6, character: 12},
					},
					newText: 'PAGENAMEE',
				},
			},
			{
				label: 'PageNamee',
				kind: 'Folder',
				textEdit: {
					range: {
						start: {line: 6, character: 3},
						end: {line: 6, character: 12},
					},
					newText: 'PageNamee',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 7, character: 3}))
			?.filter(({label}) => /^__t/iu.test(label))
			.map(({label, kind, textEdit}) => ({label, kind, textEdit})),
		[
			{
				label: '__toc__',
				kind: 'Constant',
				textEdit: {
					range: {
						start: {line: 7, character: 0},
						end: {line: 7, character: 3},
					},
					newText: '__toc__',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 8, character: 3}))
			?.filter(({label}) => label.startsWith('gi')),
		[
			{
				label: 'git://',
				kind: 'Reference',
				textEdit: {
					range: {
						start: {line: 8, character: 1},
						end: {line: 8, character: 3},
					},
					newText: 'git://',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 9, character: 20}))
			?.filter(({label}) => label.startsWith('thumbn')),
		[
			{
				label: 'thumbnail',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 9, character: 14},
						end: {line: 9, character: 20},
					},
					newText: 'thumbnail',
				},
			},
			{
				label: 'thumbnail=',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 9, character: 14},
						end: {line: 9, character: 20},
					},
					newText: 'thumbnail=',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 10, character: 15}))
			?.filter(({label}) => label.startsWith('1')),
		[
			{
				label: '100x100px',
				kind: 'Unit',
				textEdit: {
					range: {
						start: {line: 10, character: 14},
						end: {line: 10, character: 15},
					},
					newText: '100x100px',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 11, character: 7}))
			?.filter(({label}) => label.startsWith('c')),
		[
			{
				label: 'compact',
				kind: 'Field',
				textEdit: {
					range: {
						start: {line: 11, character: 6},
						end: {line: 11, character: 7},
					},
					newText: 'compact',
				},
			},
			{
				label: 'class',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 11, character: 6},
						end: {line: 11, character: 7},
					},
					newText: 'class',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 12, character: 6}))
			?.filter(({label}) => label.startsWith('n')),
		[
			{
				label: 'name',
				kind: 'Field',
				textEdit: {
					range: {
						start: {line: 12, character: 5},
						end: {line: 12, character: 6},
					},
					newText: 'name',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 13, character: 5}))
			?.filter(({label}) => label.startsWith('da')),
		[
			{
				label: 'datatype',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 13, character: 3},
						end: {line: 13, character: 5},
					},
					newText: 'datatype',
				},
			},
			{
				label: 'data-',
				kind: 'Variable',
				textEdit: {
					range: {
						start: {line: 13, character: 3},
						end: {line: 13, character: 5},
					},
					newText: 'data-',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 14, character: 8}))
			?.filter(({label}) => /^c/iu.test(label)),
		[
			{
				label: 'CC',
				kind: 'Variable',
				textEdit: {
					range: {
						start: {line: 14, character: 7},
						end: {line: 14, character: 8},
					},
					newText: 'CC',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 15, character: 5}))
			?.filter(({label}) => label.startsWith('st')),
		[
			{
				label: 'style',
				kind: 'Property',
				textEdit: {
					range: {
						start: {line: 15, character: 3},
						end: {line: 15, character: 5},
					},
					newText: 'style',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 15, character: 17}))
			?.filter(({label}) => label.startsWith('l')),
		[
			{
				label: 'ltr',
				kind: 'Value',
				textEdit: {
					range: {
						start: {line: 15, character: 16},
						end: {line: 15, character: 17},
					},
					newText: 'ltr',
				},
			},
		],
	);
})();

// provideCompletionItems (Node.js)
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = String.raw`<p style=user-select:none;us>
<templatedata>{"d":""}</templatedata>
__T
{{ #Ifexp
<score>\rel</score>
<math chem>\ce</math>`;
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 0, character: 11}))
			?.filter(({label}) => label.startsWith('us'))
			.map(({label, kind, textEdit}) => ({label, kind, textEdit})),
		[
			{
				label: 'user-select',
				kind: 10,
				textEdit: {
					range: {
						start: {line: 0, character: 9},
						end: {line: 0, character: 20},
					},
					newText: 'user-select',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 0, character: 28}))
			?.filter(({label}) => label.startsWith('us'))
			.map(({label, kind, textEdit}) => ({label, kind, textEdit})),
		[
			{
				label: 'user-select',
				kind: 10,
				textEdit: {
					range: {
						start: {line: 0, character: 26},
						end: {line: 0, character: 28},
					},
					newText: 'user-select:$0;',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 0, character: 21}))
			?.filter(({label}) => label.startsWith('n'))
			.map(({label, kind, textEdit}) => ({label, kind, textEdit})),
		[
			{
				label: 'none',
				kind: 12,
				textEdit: {
					range: {
						start: {line: 0, character: 21},
						end: {line: 0, character: 25},
					},
					newText: 'none',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 1, character: 17}))
			?.filter(({label}) => label.startsWith('d'))
			.map(({label, kind, textEdit}) => ({label, kind, textEdit})),
		[
			{
				label: 'description',
				kind: 10,
				textEdit: {
					range: {
						start: {line: 1, character: 15},
						end: {line: 1, character: 18},
					},
					newText: '"description"',
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 2, character: 3}))
			?.filter(({label}) => /^__t/iu.test(label)),
		[
			{
				label: '__toc__',
				kind: 'Constant',
				textEdit: {
					range: {
						start: {line: 2, character: 0},
						end: {line: 2, character: 3},
					},
					newText: '__toc__',
				},
				documentation: {
					kind: 'markdown',
					value: `Places a table of contents at the word's current position (overriding \`__NOTOC__\`). If this is used multiple times, the table of contents will appear at the first word's position.`,
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 3, character: 9}))
			?.filter(({label}) => /^#ifexp/iu.test(label)),
		[
			{
				label: '#ifexpr',
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 3, character: 3},
						end: {line: 3, character: 9},
					},
					newText: '#ifexpr',
				},
				documentation: {
					kind: 'markdown',
					value: `This function evaluates a mathematical expression and returns one of two strings depending on the boolean value of the result.

The \`expression\` input is evaluated exactly as for \`#expr\`, with the same operators being available. The output is then evaluated as a boolean expression.

An empty input expression evaluates to \`false\`.

An empty or wrong input expression (an error message is treated as an empty string; it is not equal to zero, so we get \`value if true\`).`,
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 4, character: 11}))
			?.filter(({label}) => /^\\rel/iu.test(label)),
		[
			{
				label: String.raw`\relative`,
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 4, character: 7},
						end: {line: 4, character: 11},
					},
					newText: String.raw`\relative`,
				},
			},
		],
	);
	assert.deepStrictEqual(
		(await lsp.provideCompletionItems(wikitext, {line: 5, character: 14}))
			?.filter(({label}) => /^\\ce/iu.test(label)),
		[
			{
				label: String.raw`\centerdot`,
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 5, character: 11},
						end: {line: 5, character: 14},
					},
					newText: String.raw`\centerdot`,
				},
			},
			{
				label: String.raw`\ce`,
				kind: 'Function',
				textEdit: {
					range: {
						start: {line: 5, character: 11},
						end: {line: 5, character: 14},
					},
					newText: String.raw`\ce`,
				},
			},
		],
	);
})();

provideFoldingRanges

🌐 Expand

param: string The wikitext content.
returns: Promise<FoldingRange[]>
Return all folding ranges found in a given document.

// provideFoldingRanges
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
<!--

-->= 1 =

<!-- -->

<!-- -->== 2 ==



===== 3 ===== <!--

--> 

x {{a|
====== 4_<!--
-->2 ====== 
y }} z

== 4 ==


= 4 =

 : {|
|
=== 4 ===
 |} x

`;
	assert.deepStrictEqual(
		await lsp.provideFoldingRanges(wikitext),
		[
			{startLine: 15, endLine: 17, kind: 'region'},
			{startLine: 7, endLine: 19, kind: 'region'},
			{startLine: 11, endLine: 19, kind: 'region'},
			{startLine: 17, endLine: 19, kind: 'region'},
			{startLine: 3, endLine: 22, kind: 'region'},
			{startLine: 20, endLine: 22, kind: 'region'},
			{startLine: 25, endLine: 27, kind: 'region'},
			{startLine: 23, endLine: 30, kind: 'region'},
			{startLine: 27, endLine: 30, kind: 'region'},
		],
	);
})();

// provideFoldingRanges (Node.js)
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
{{a|
<templatedata>{
	"paramOrder": [
		"a",
		"b"
	]
}</templatedata>
}}`;
	assert.deepStrictEqual(
		await lsp.provideFoldingRanges(wikitext),
		[
			{startLine: 1, endLine: 7, kind: 'region'},
			{startLine: 3, endLine: 5, kind: 'array'},
			{startLine: 2, endLine: 6, kind: 'object'},
		],
	);
})();

provideLinks

🌐 Expand

param: string The wikitext content.
returns: Promise<DocumentLink[]>
Request the location of links in a document.

// provideLinks
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
[[ : help : a#a ]]
{{ b }}
{{ #invoke: c | c }}
RFC 1
PMID 1
ISBN 1-2-3-4-5-6-7-8-9-0
[//d d]
News:e
<templatestyles src = f />
<q cite = "HTTPS://G/G">
[[file:a|link=a]]
[[file:a|link=//a]]
{{filepath: h }}
`,
		results = [
			{
				range: {
					start: {line: 1, character: 2},
					end: {line: 1, character: 16},
				},
				target: 'https://mediawiki.org/wiki/Help%3AA#a',
			},
			{
				range: {
					start: {line: 2, character: 2},
					end: {line: 2, character: 5},
				},
				target: 'https://mediawiki.org/wiki/Template%3AB',
			},
			{
				range: {
					start: {line: 3, character: 11},
					end: {line: 3, character: 14},
				},
				target: 'https://mediawiki.org/wiki/Module%3AC',
			},
			{
				range: {
					start: {line: 4, character: 0},
					end: {line: 4, character: 5},
				},
				target: 'https://tools.ietf.org/html/rfc1',
			},
			{
				range: {
					start: {line: 5, character: 0},
					end: {line: 5, character: 6},
				},
				target: 'https://pubmed.ncbi.nlm.nih.gov/1',
			},
			{
				range: {
					start: {line: 6, character: 0},
					end: {line: 6, character: 24},
				},
				// eslint-disable-next-line @stylistic/max-len
				target: 'https://mediawiki.org/wiki/Special%3ABookSources%2F1234567890',
			},
			{
				range: {
					start: {line: 7, character: 1},
					end: {line: 7, character: 4},
				},
				target: 'https://d/',
			},
			{
				range: {
					start: {line: 8, character: 0},
					end: {line: 8, character: 6},
				},
				target: 'news:e',
			},
			{
				range: {
					start: {line: 9, character: 22},
					end: {line: 9, character: 23},
				},
				target: 'https://mediawiki.org/wiki/Template%3AF',
			},
			{
				range: {
					start: {line: 10, character: 11},
					end: {line: 10, character: 22},
				},
				target: 'https://g/G',
			},
			{
				range: {
					start: {line: 11, character: 2},
					end: {line: 11, character: 8},
				},
				target: 'https://mediawiki.org/wiki/File%3AA',
			},
			{
				range: {
					start: {line: 11, character: 14},
					end: {line: 11, character: 15},
				},
				target: 'https://mediawiki.org/wiki/A',
			},
			{
				range: {
					start: {line: 12, character: 2},
					end: {line: 12, character: 8},
				},
				target: 'https://mediawiki.org/wiki/File%3AA',
			},
			{
				range: {
					start: {line: 12, character: 14},
					end: {line: 12, character: 17},
				},
				target: 'https://a/',
			},
			{
				range: {
					start: {line: 13, character: 11},
					end: {line: 13, character: 14},
				},
				target: 'https://mediawiki.org/wiki/File%3AH',
			},
		].reverse();
	Parser.getConfig();
	Parser.config.articlePath = 'https://mediawiki.org/wiki/$1';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
	Parser.config.articlePath = 'https://mediawiki.org/wiki/';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
	Parser.config.articlePath = 'https://mediawiki.org/wiki';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
	Parser.config.articlePath = '//mediawiki.org/wiki/$1';
	assert.deepStrictEqual(await lsp.provideLinks(wikitext), results);
})();

provideReferences

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Omit<Location, 'uri'>[] | undefined>
Resolve references for the symbol denoted by the given document position.

// provideReferences
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
{{{ a }}}
{{{a|}}}
{{ b }}
{{ : template : b |b=}}
{{ PAGENAME }}
{{PAGENAME:c}}
[[ file : d | thumb ]]
[[ :file:d ]]
{{ e | e = }}
{{Template:E|e=}}
<ref group = f name = f > </ref>
<ref group = " f " extends = ' f ' />
<b ></b>
<references group = f />
[[file:g|thumbnail]]
== h ==
== i ==
`;
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 1, character: 4}),
		[
			{
				range: {
					start: {line: 1, character: 3},
					end: {line: 1, character: 6},
				},
			},
			{
				range: {
					start: {line: 2, character: 3},
					end: {line: 2, character: 4},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 3, character: 4}),
		[
			{
				range: {
					start: {line: 3, character: 2},
					end: {line: 3, character: 5},
				},
			},
			{
				range: {
					start: {line: 4, character: 2},
					end: {line: 4, character: 18},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 5, character: 4}),
		[
			{
				range: {
					start: {line: 5, character: 2},
					end: {line: 5, character: 12},
				},
			},
			{
				range: {
					start: {line: 6, character: 2},
					end: {line: 6, character: 10},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 7, character: 4}),
		[
			{
				range: {
					start: {line: 7, character: 2},
					end: {line: 7, character: 12},
				},
			},
			{
				range: {
					start: {line: 8, character: 2},
					end: {line: 8, character: 11},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 9, character: 8}),
		[
			{
				range: {
					start: {line: 9, character: 6},
					end: {line: 9, character: 11},
				},
			},
			{
				range: {
					start: {line: 10, character: 13},
					end: {line: 10, character: 15},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 4}),
		[
			{
				range: {
					start: {line: 11, character: 0},
					end: {line: 11, character: 32},
				},
			},
			{
				range: {
					start: {line: 12, character: 0},
					end: {line: 12, character: 37},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 13, character: 2}),
		[
			{
				range: {
					start: {line: 13, character: 0},
					end: {line: 13, character: 4},
				},
			},
			{
				range: {
					start: {line: 13, character: 4},
					end: {line: 13, character: 8},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 6}),
		[
			{
				range: {
					start: {line: 11, character: 5},
					end: {line: 11, character: 10},
				},
			},
			{
				range: {
					start: {line: 12, character: 5},
					end: {line: 12, character: 10},
				},
			},
			{
				range: {
					start: {line: 14, character: 12},
					end: {line: 14, character: 17},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 15, character: 10}),
		[
			{
				range: {
					start: {line: 7, character: 13},
					end: {line: 7, character: 20},
				},
			},
			{
				range: {
					start: {line: 15, character: 9},
					end: {line: 15, character: 18},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 16, character: 4}),
		[
			{
				range: {
					start: {line: 16, character: 0},
					end: {line: 16, character: 7},
				},
			},
			{
				range: {
					start: {line: 17, character: 0},
					end: {line: 17, character: 7},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 16, character: 1}),
		[
			{
				range: {
					start: {line: 16, character: 0},
					end: {line: 16, character: 7},
				},
			},
			{
				range: {
					start: {line: 17, character: 0},
					end: {line: 17, character: 7},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 23}),
		[
			{
				range: {
					start: {line: 11, character: 22},
					end: {line: 11, character: 23},
				},
			},
			{
				range: {
					start: {line: 12, character: 30},
					end: {line: 12, character: 33},
				},
			},
		].reverse(),
	);
	assert.deepStrictEqual(
		await lsp.provideReferences(wikitext, {line: 11, character: 14}),
		[
			{
				range: {
					start: {line: 11, character: 13},
					end: {line: 11, character: 14},
				},
			},
			{
				range: {
					start: {line: 12, character: 14},
					end: {line: 12, character: 17},
				},
			},
			{
				range: {
					start: {line: 14, character: 20},
					end: {line: 14, character: 21},
				},
			},
		].reverse(),
	);
})();

provideDefinition

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Omit<Location, 'uri'>[] | undefined>
Resolve the definition location of a symbol at a given document position.

// provideDefinition
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
<ref group = f name = f > </ref>
<ref name = f > </ref>
<ref name = ' f ' />
`;
	assert.deepStrictEqual(
		await lsp.provideDefinition(wikitext, {line: 3, character: 14}),
		[
			{
				range: {
					start: {line: 2, character: 15},
					end: {line: 2, character: 16},
				},
			},
		],
	);
})();

resolveRenameLocation

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Range | undefined>
Test the validity of a rename operation at a given location.

// resolveRenameLocation
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
{{{ a }}}
{{ b }}
[[ :file:d ]]
{{ e | e = }}
<ref group = f name = f > </ref>
`;
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 1, character: 4}),
		{
			start: {line: 1, character: 3},
			end: {line: 1, character: 6},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 2, character: 4}),
		{
			start: {line: 2, character: 2},
			end: {line: 2, character: 5},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 3, character: 4}),
		{
			start: {line: 3, character: 2},
			end: {line: 3, character: 11},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 4, character: 8}),
		{
			start: {line: 4, character: 6},
			end: {line: 4, character: 9},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 5, character: 23}),
		{
			start: {line: 5, character: 22},
			end: {line: 5, character: 23},
		},
	);
	assert.deepStrictEqual(
		await lsp.resolveRenameLocation(wikitext, {line: 5, character: 14}),
		{
			start: {line: 5, character: 13},
			end: {line: 5, character: 14},
		},
	);
})();

provideRenameEdits

🌐 Expand

param: string The wikitext content.
param: Position
param: string The new name.
returns: Promise<WorkspaceEdit | undefined>
Compute a change for a document-wide rename of a symbol.

// provideRenameEdits
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
{{{ a }}}
{{{a|}}}
{{ b }}
{{ : template : b |b=}}
[[ file : d | thumb ]]
[[ :file:d ]]
{{ e | e = }}
{{Template:E|e=}}
<ref group = f name = f > </ref>
<ref group = " f " extends = ' f ' /><ref name=f/>
<references group = f />
`;
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 1, character: 4}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 1, character: 3},
							end: {line: 1, character: 6},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 2, character: 3},
							end: {line: 2, character: 4},
						},
						newText: 'x',
					},
				].reverse(),
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 3, character: 4}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 3, character: 2},
							end: {line: 3, character: 5},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 4, character: 2},
							end: {line: 4, character: 18},
						},
						newText: 'x',
					},
				].reverse(),
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 6, character: 4}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 6, character: 2},
							end: {line: 6, character: 11},
						},
						newText: 'x',
					},
				],
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 7, character: 8}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 7, character: 6},
							end: {line: 7, character: 9},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 8, character: 13},
							end: {line: 8, character: 14},
						},
						newText: 'x',
					},
				].reverse(),
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 9, character: 23}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 9, character: 22},
							end: {line: 9, character: 23},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 10, character: 30},
							end: {line: 10, character: 33},
						},
						newText: 'x',
					},
				].reverse(),
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideRenameEdits(wikitext, {line: 9, character: 14}, 'x'),
		{
			changes: {
				'': [
					{
						range: {
							start: {line: 9, character: 13},
							end: {line: 9, character: 14},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 10, character: 14},
							end: {line: 10, character: 17},
						},
						newText: 'x',
					},
					{
						range: {
							start: {line: 11, character: 20},
							end: {line: 11, character: 21},
						},
						newText: 'x',
					},
				].reverse(),
			},
		},
	);
})();

provideDiagnostics

🌐 Expand

param: string The wikitext content.
param: boolean Whether to include warnings.
returns: Promise<Diagnostic[]>
Compute the syntax diagnostics for a given document.

// provideDiagnostics
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
http://a]
</p>
`;
	assert.deepStrictEqual(
		await lsp.provideDiagnostics(wikitext),
		[
			{
				range: {
					start: {line: 1, character: 8},
					end: {line: 1, character: 9},
				},
				severity: 1,
				source: 'WikiLint',
				code: 'lonely-bracket',
				message: 'lonely "]"',
				data: [
					{
						range: {
							start: {line: 1, character: 0},
							end: {line: 1, character: 0},
						},
						newText: '[',
						title: 'Fix: left bracket',
						fix: true,
					},
				],
			},
			{
				range: {
					start: {line: 2, character: 0},
					end: {line: 2, character: 4},
				},
				severity: 1,
				source: 'WikiLint',
				code: 'unmatched-tag',
				message: 'unmatched closing tag',
				data: [
					{
						range: {
							start: {line: 2, character: 0},
							end: {line: 2, character: 4},
						},
						newText: '',
						title: 'Suggestion: remove',
						fix: false,
					},
				],
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('['),
		[
			{
				range: {
					start: {line: 0, character: 0},
					end: {line: 0, character: 1},
				},
				severity: 2,
				source: 'WikiLint',
				code: 'lonely-bracket',
				message: 'lonely "["',
				data: [],
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('[', false),
		[],
	);
})();

// provideDiagnostics (Node.js)
var {execSync} = require('child_process');
(async () => {
	const lsp = Parser.createLanguageService({});
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('<templatedata>a</templatedata>'),
		[
			{
				range: {
					start: {line: 0, character: 14},
					end: {line: 0, character: 15},
				},
				severity: 1,
				source: 'json',
				code: 0,
				message: 'Expected a JSON object, array or literal.',
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('<templatedata>1</templatedata>'),
		[
			{
				range: {
					start: {line: 0, character: 14},
					end: {line: 0, character: 15},
				},
				severity: 2,
				source: 'json',
				message: 'Incorrect type. Expected "object".',
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('<br style="">'),
		[
			{
				range: {
					start: {line: 0, character: 11},
					end: {line: 0, character: 11},
				},
				severity: 2,
				source: 'css',
				code: 'emptyRules',
				message: 'Do not use empty rulesets',
				data: [],
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics('<br style=left:0;left:1>'),
		[
			{
				range: {
					start: {line: 0, character: 10},
					end: {line: 0, character: 14},
				},
				severity: 1,
				source: 'Stylelint',
				code: 'declaration-block-no-duplicate-properties',
				message: 'Unexpected duplicate "left"',
			},
			{
				range: {
					start: {line: 0, character: 22},
					end: {line: 0, character: 23},
				},
				severity: 1,
				source: 'Stylelint',
				code: 'declaration-property-value-no-unknown',
				message: 'Unexpected unknown value "1" for property "left"',
			},
		],
	);
	assert.deepStrictEqual(
		await lsp.provideDiagnostics(String.raw`<math>#\ce</math>`),
		[
			{
				range: {
					start: {line: 0, character: 7},
					end: {line: 0, character: 10},
				},
				severity: 2,
				source: 'MathJax',
				code: 'UnknownMacro',
				message:
					String.raw`Unknown macro "\ce"`,
			},
			{
				range: {
					start: {line: 0, character: 6},
					end: {line: 0, character: 10},
				},
				severity: 1,
				source: 'MathJax',
				code: 'CantUseHash1',
				message:
					"You can't use 'macro parameter character #' in math mode",
			},
		],
	);
	try {
		lsp.lilypond = execSync('which lilypond', {encoding: 'utf8'}).trim();
		assert.deepStrictEqual(
			await lsp.provideDiagnostics("<score raw>{ c'4 e'5 g' }</score>"),
			[
				{
					range: {
						start: {line: 0, character: 19},
						end: {line: 0, character: 19},
					},
					severity: 1,
					source: 'LilyPond',
					message: 'not a duration',
				},
			],
		);
		assert.deepStrictEqual(
			await lsp.provideDiagnostics(String.raw`<score>\score {
\relative c'
}</score>`),
			[
				{
					range: {
						start: {line: 0, character: 7},
						end: {line: 0, character: 7},
					},
					severity: 1,
					source: 'LilyPond',
					message: String.raw`Missing music in \score`,
				},
				{
					range: {
						start: {line: 0, character: 7},
						end: {line: 0, character: 7},
					},
					severity: 1,
					source: 'LilyPond',
					message: String.raw`syntax error, unexpected \score, expecting '}'`,
				},
			],
		);
	} catch (e) {
		if (e instanceof assert.AssertionError) {
			throw e;
		}
	}
})();

provideHover

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<Hover | undefined>
Request hover information at a given document position.

// provideHover (Node.js)
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
__NOTOC__
{{ #LEN: }}
{{ subst: NUMBEROFPAGES }}
{{ = }}
<p style=box-sizing:border-box>
<templatedata>{"description":null}</templatedata>
`;
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 1, character: 0}),
		{
			contents: {
				kind: 'markdown',
				value: 'Hides the table of contents (TOC).',
			},
			range: {
				start: {line: 1, character: 0},
				end: {line: 1, character: 9},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 2, character: 2}),
		{
			contents: {
				kind: 'markdown',
				value: `- **{{ #LEN:** *string* **}}**

The #len function returns the length of the given string.`,
			},
			range: {
				start: {line: 2, character: 2},
				end: {line: 2, character: 7},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 3, character: 10}),
		{
			contents: {
				kind: 'markdown',
				value: `- **{{ NUMBEROFPAGES** **}}**
- **{{ NUMBEROFPAGES:** R **}}**

Number of wiki pages.`,
			},
			range: {
				start: {line: 3, character: 10},
				end: {line: 3, character: 24},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 3, character: 2}),
		{
			contents: {
				kind: 'markdown',
				value: `- **{{ subst:** *xyz* **}}**

In the wikitext, the tag is substituted by the content (single-level evaluation only), see [Help:Templates](https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Templates#Usage).`,
			},
			range: {
				start: {line: 3, character: 2},
				end: {line: 3, character: 8},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 4, character: 0}),
		{
			contents: {
				kind: 'markdown',
				value: `Used to include an equal sign.

See [help](https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Extension:ParserFunctions#Raw_equal_signs) for further explanation.`,
			},
			range: {
				start: {line: 4, character: 0},
				end: {line: 4, character: 7},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 5, character: 11}),
		{
			contents: {
				kind: 'markdown',
				value: String.raw`Specifies the behavior of the 'width' and 'height' properties\.

![Baseline icon](data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTgiIGhlaWdodD0iMTAiIHZpZXdCb3g9IjAgMCA1NDAgMzAwIiBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgogIDxzdHlsZT4KICAgIC5ncmVlbi1zaGFwZSB7CiAgICAgIGZpbGw6ICNDNEVFRDA7IC8qIExpZ2h0IG1vZGUgKi8KICAgIH0KCiAgICBAbWVkaWEgKHByZWZlcnMtY29sb3Itc2NoZW1lOiBkYXJrKSB7CiAgICAgIC5ncmVlbi1zaGFwZSB7CiAgICAgICAgZmlsbDogIzEyNTIyNTsgLyogRGFyayBtb2RlICovCiAgICAgIH0KICAgIH0KICA8L3N0eWxlPgogIDxwYXRoIGQ9Ik00MjAgMzBMMzkwIDYwTDQ4MCAxNTBMMzkwIDI0MEwzMzAgMTgwTDMwMCAyMTBMMzkwIDMwMEw1NDAgMTUwTDQyMCAzMFoiIGNsYXNzPSJncmVlbi1zaGFwZSIvPgogIDxwYXRoIGQ9Ik0xNTAgMEwzMCAxMjBMNjAgMTUwTDE1MCA2MEwyMTAgMTIwTDI0MCA5MEwxNTAgMFoiIGNsYXNzPSJncmVlbi1zaGFwZSIvPgogIDxwYXRoIGQ9Ik0zOTAgMEw0MjAgMzBMMTUwIDMwMEwwIDE1MEwzMCAxMjBMMTUwIDI0MEwzOTAgMFoiIGZpbGw9IiMxRUE0NDYiLz4KPC9zdmc+) _Widely available across major browsers (Baseline since 2015)_

Syntax: content\-box | border\-box

[MDN Reference](https://developer.mozilla.org/docs/Web/CSS/box-sizing)`,
			},
			range: {
				start: {line: 5, character: 9},
				end: {line: 5, character: 30},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 6, character: 17}),
		{
			contents: [`A brief description of the template. **It must be in plain text.** Once filled, it can be displayed as caption when editing a single template and perhaps in search results when users pick one of many. The default is \`null\`.`],
			range: {
				start: {line: 6, character: 15},
				end: {line: 6, character: 28},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 5, character: 1}),
		{
			contents: {
				kind: 'markdown',
				value: 'The p element represents a paragraph.',
			},
			range: {
				start: {line: 5, character: 0},
				end: {line: 5, character: 2},
			},
		},
	);
	assert.deepStrictEqual(
		await lsp.provideHover(wikitext, {line: 5, character: 3}),
		{
			contents: {
				kind: 'markdown',
				value: `Contains [CSS](https://developer.mozilla.org/docs/Web/CSS) styling declarations to be applied to the element. Note that it is recommended for styles to be defined in a separate file or files. This attribute and the [\`<style>\`](https://developer.mozilla.org/docs/Web/HTML/Element/style "The HTML <style> element contains style information for a document, or part of a document.") element have mainly the purpose of allowing for quick styling, for example for testing purposes.`,
			},
			range: {
				start: {line: 5, character: 3},
				end: {line: 5, character: 8},
			},
		},
	);
})();

provideSignatureHelp

🌐 Expand

param: string The wikitext content.
param: Position
returns: Promise<SignatureHelp | undefined>
Request signature information of a magic word at a given cursor position.

// provideSignatureHelp (Node.js)
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
{{ #invoke: a | b | c | d }}
{{ PAGENAME: }}
{{ PAGESIZE: a | R }}
`;
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 1, character: 12}),
		{
			signatures: [
				{
					label: '{{#invoke:module name|function name|args}}',
					parameters: [
						{label: 'module name'},
						{label: 'function name'},
						{label: 'args'},
					],
					activeParameter: 0,
				},
			],
			activeParameter: 0,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 1, character: 16}),
		{
			signatures: [
				{
					label: '{{#invoke:module name|function name|args}}',
					parameters: [
						{label: 'module name'},
						{label: 'function name'},
						{label: 'args'},
					],
					activeParameter: 1,
				},
			],
			activeParameter: 1,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 1, character: 25}),
		{
			signatures: [
				{
					label: '{{#invoke:module name|function name|args}}',
					parameters: [
						{label: 'module name'},
						{label: 'function name'},
						{label: 'args'},
					],
					activeParameter: 2,
				},
			],
			activeParameter: 3,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 2, character: 2}),
		{
			signatures: [
				{
					label: '{{PAGENAME:page name}}',
					parameters: [{label: 'page name'}],
				},
			],
			activeParameter: -1,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 3, character: 13}),
		{
			signatures: [
				{
					label: '{{PAGESIZE:page name|R}}',
					parameters: [
						{label: 'page name'},
						{label: 'R', documentation: 'Predefined parameter'},
					],
				},
			],
			activeParameter: 0,
		},
	);
	assert.deepStrictEqual(
		await lsp.provideSignatureHelp(wikitext, {line: 3, character: 17}),
		{
			signatures: [
				{
					label: '{{PAGESIZE:page name|R}}',
					parameters: [
						{label: 'page name'},
						{label: 'R', documentation: 'Predefined parameter'},
					],
				},
			],
			activeParameter: 1,
		},
	);
})();

provideInlayHints

🌐 Expand

version added: 1.16.3

param: string The wikitext content.
returns: Promise<InlayHint[]>
Compute inlay hints for a given document tuple that may be rendered in the editor in place with other text.

// provideInlayHints
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
{{a|b=|c}}
{{#invoke:a|b|c}}
`;
	assert.deepStrictEqual(
		await lsp.provideInlayHints(wikitext),
		[
			{
				position: {line: 1, character: 7},
				kind: 2,
				label: '1=',
			},
			{
				position: {line: 2, character: 14},
				kind: 2,
				label: '1=',
			},
		].reverse(),
	);
})();

provideCodeAction

Expand

param: Diagnostic[]
returns: CodeAction[]
Compute commands for a given document and syntax diagnostic.

// provideCodeAction (Node.js)
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
http://a]
</p>
`,
		diagnostics = await lsp.provideDiagnostics(wikitext);
	assert.deepStrictEqual(
		lsp.provideCodeAction(diagnostics),
		[
			{
				title: 'Fix: left bracket',
				kind: 'quickfix',
				diagnostics: [diagnostics[0]],
				isPreferred: true,
				edit: {
					changes: {'': diagnostics[0].data},
				},
			},
			{
				title: 'Suggestion: remove',
				kind: 'quickfix',
				diagnostics: [diagnostics[1]],
				isPreferred: false,
				edit: {
					changes: {'': diagnostics[1].data},
				},
			},
		],
	);
})();

provideDocumentSymbols

Expand

param: string The wikitext content.
returns: Promise<DocumentSymbol[]>
Return a hierarchy of sections found in a given document.

// provideDocumentSymbols (Node.js)
(async () => {
	const lsp = Parser.createLanguageService({}),
		wikitext = `
<!--

-->= 1 =

<!-- -->

<!-- -->== 2 ==



===== 3 ===== <!--

--> 

x {{a|
====== 4_<!--
-->2 ====== 
y }} z
 
== 4 ==


= 4 =

 : {|
|
=== 4 ===
 |} x

`;
	assert.deepStrictEqual(
		await lsp.provideDocumentSymbols(wikitext),
		[
			{
				name: '1',
				kind: 15,
				range: {
					start: {line: 3, character: 3},
					end: {line: 22, character: 0},
				},
				selectionRange: {
					start: {line: 3, character: 3},
					end: {line: 3, character: 8},
				},
				children: [
					{
						name: '2',
						kind: 15,
						range: {
							start: {line: 7, character: 8},
							end: {line: 19, character: 1},
						},
						selectionRange: {
							start: {line: 7, character: 8},
							end: {line: 7, character: 15},
						},
						children: [
							{
								name: '3',
								kind: 15,
								range: {
									start: {line: 11, character: 0},
									end: {line: 19, character: 1},
								},
								selectionRange: {
									start: {line: 11, character: 0},
									end: {line: 11, character: 13},
								},
								children: [
									{
										name: '4_2',
										kind: 15,
										range: {
											start: {line: 16, character: 0},
											end: {line: 19, character: 1},
										},
										selectionRange: {
											start: {line: 16, character: 0},
											end: {line: 17, character: 11},
										},
									},
								],
							},
						],
					},
					{
						name: '4',
						kind: 15,
						range: {
							start: {line: 20, character: 0},
							end: {line: 22, character: 0},
						},
						selectionRange: {
							start: {line: 20, character: 0},
							end: {line: 20, character: 7},
						},
					},
				],
			},
			{
				name: '4_3',
				kind: 15,
				range: {
					start: {line: 23, character: 0},
					end: {line: 30, character: 0},
				},
				selectionRange: {
					start: {line: 23, character: 0},
					end: {line: 23, character: 5},
				},
				children: [
					{
						name: '4_4',
						kind: 15,
						range: {
							start: {line: 27, character: 0},
							end: {line: 30, character: 0},
						},
						selectionRange: {
							start: {line: 27, character: 0},
							end: {line: 27, character: 9},
						},
					},
				],
			},
		],
	);
})();

setTargetWikipedia

Expand

version added: 1.18.1

param: string The URL of the target Wikipedia.
Update the parser configuration to target a specific Wikipedia. Not applicable to other MediaWiki sites.

// setTargetWikipedia (Node.js)
(async () => {
	const lsp = Parser.createLanguageService({});
	await lsp.setTargetWikipedia('https://en.wikipedia.org');
	assert.strictEqual(
		lsp.config.articlePath,
		'https://en.wikipedia.org/wiki/',
	);
})();

LanguageService (EN) - bhsd-harry/wikiparser-node GitHub Wiki

Other Languages

Introduction

Properties

include

lilypond

Methods

destroy

provideDocumentColors

provideColorPresentations

provideCompletionItems

provideFoldingRanges

provideLinks

provideReferences

provideDefinition

resolveRenameLocation

provideRenameEdits

provideDiagnostics

provideHover

provideSignatureHelp

provideInlayHints

provideCodeAction

provideDocumentSymbols

setTargetWikipedia

相关软件包

Related Packages

⚠️ GitHub.com Fallback ⚠️

LanguageService (EN) - bhsd-harry/wikiparser-node GitHub Wiki

Other Languages

Introduction

Properties

include

lilypond

Methods

destroy

provideDocumentColors

provideColorPresentations

provideCompletionItems

provideFoldingRanges

provideLinks

provideReferences

provideDefinition

resolveRenameLocation

provideRenameEdits

provideDiagnostics

provideHover

provideSignatureHelp

provideInlayHints

provideCodeAction

provideDocumentSymbols

setTargetWikipedia

相关软件包

Related Packages

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️