@bhsd/codemirror-mediawiki 3.0.2 → 3.1.0

package/dist/escape.d.ts

@@ -1,4 +1,5 @@
-import type { KeyBinding } from '@codemirror/view';
+import { CodeMirror6 } from './codemirror';
+import type { Extension } from '@codemirror/state';
 export declare const escapeHTML: (str: string) => string, escapeURI: (str: string) => string;
-declare const _default: KeyBinding[];
+declare const _default: (cm: CodeMirror6) => Extension;
 export default _default;

package/dist/escape.js

@@ -1,4 +1,7 @@
+import { keymap } from '@codemirror/view';
+import { EditorSelection } from '@codemirror/state';
 import { indentMore, indentLess } from '@codemirror/commands';
+import { getLSP } from '@bhsd/browser';
 import { CodeMirror6 } from './codemirror';
 const entity = { '"': 'quot', "'": 'apos', '<': 'lt', '>': 'gt', '&': 'amp', ' ': 'nbsp' };
 /**
@@ -7,7 +10,7 @@ const entity = { '"': 'quot', "'": 'apos', '<': 'lt', '>': 'gt', '&': 'amp', ' '
  * @param cmd 原命令
  */
 const convert = (func, cmd) => (view) => {
-    if (view.state.selection.ranges.some(range => !range.empty)) {
+    if (view.state.selection.ranges.some(({ empty }) => !empty)) {
         CodeMirror6.replaceSelections(view, func);
         return true;
     }
@@ -29,7 +32,35 @@ export const escapeHTML = (str) => [...str].map(c => {
     }
     return encodeURIComponent(str);
 };
-export default /* @__PURE__ */ (() => [
+export default (cm) => keymap.of([
     { key: 'Mod-[', run: convert(escapeHTML, indentLess) },
     { key: 'Mod-]', run: convert(escapeURI, indentMore) },
-])();
+    {
+        key: 'Mod-\\',
+        run(view) {
+            const { state } = view, { ranges } = state.selection, lsp = getLSP(view, false, cm.getWikiConfig);
+            if (lsp && 'provideRefactoringAction' in lsp && ranges.some(({ empty }) => !empty)) {
+                (async () => {
+                    const replacements = new WeakMap();
+                    for (const range of ranges) {
+                        // eslint-disable-next-line no-await-in-loop
+                        const [action] = await lsp.provideRefactoringAction(state.sliceDoc(range.from, range.to));
+                        replacements.set(range, action?.edit.changes[''][0].newText);
+                    }
+                    view.dispatch(state.changeByRange(range => {
+                        const insert = replacements.get(range);
+                        if (insert === undefined) {
+                            return { range };
+                        }
+                        return {
+                            range: EditorSelection.range(range.from, range.from + insert.length),
+                            changes: { from: range.from, to: range.to, insert },
+                        };
+                    }));
+                })();
+                return true;
+            }
+            return false;
+        },
+    },
+]);

package/dist/fold.d.ts

@@ -1,14 +1,10 @@
-import { GutterMarker, ViewPlugin } from '@codemirror/view';
-import { RangeSet } from '@codemirror/state';
-import type { EditorView, Tooltip, ViewUpdate, BlockInfo, Command } from '@codemirror/view';
-import type { EditorState, StateEffect, Extension } from '@codemirror/state';
+import type { EditorView, Command } from '@codemirror/view';
+import type { EditorState, Extension } from '@codemirror/state';
 import type { SyntaxNode, Tree } from '@lezer/common';
 export interface DocRange {
     from: number;
     to: number;
 }
-declare type AnchorUpdate = (pos: number, range: DocRange) => number;
-export declare const updateSelection: AnchorUpdate;
 /**
  * Update the stack of opening (+) or closing (-) brackets
  * @param state
@@ -23,54 +19,9 @@ export declare const braceStackUpdate: (state: EditorState, node: SyntaxNode) =>
  * @param refOnly 是否仅检查`<ref>`标签
  */
 export declare const foldable: (state: EditorState, posOrNode: number | SyntaxNode, tree?: Tree | null, refOnly?: boolean) => DocRange | false;
-/**
- * 创建折叠提示
- * @param state
- */
-export declare const create: (state: EditorState) => Tooltip | null;
-/**
- * 执行折叠
- * @param view
- * @param effects 折叠
- * @param anchor 光标位置
- */
-export declare const execute: (view: EditorView, effects: StateEffect<DocRange>[], anchor: number) => boolean;
-/**
- * The rightmost position of all selections, to be updated with folding
- * @param state
- */
-export declare const getAnchor: (state: EditorState) => number;
-/**
- * 折叠所有模板
- * @param state
- * @param tree 语法树
- * @param effects 折叠
- * @param node 语法树节点
- * @param end 终止位置
- * @param anchor 光标位置
- * @param update 更新光标位置
- * @param refOnly 是否仅检查`<ref>`标签
- */
-export declare const traverse: (state: EditorState, tree: Tree, effects: StateEffect<DocRange>[], node: SyntaxNode | null, end: number, anchor: number, update: AnchorUpdate, refOnly?: boolean) => number;
-export declare class FoldMarker extends GutterMarker {
-    readonly open: boolean;
-    constructor(open: boolean);
-    eq(other: this): boolean;
-    toDOM({ state }: EditorView): HTMLSpanElement;
-}
-export declare const findFold: ({ state }: EditorView, line: BlockInfo) => DocRange | undefined;
 export declare const foldableLine: ({ state, viewport: { to: end }, viewportLineBlocks }: EditorView, { from: f, to: t }: DocRange) => DocRange | false;
-export declare const markers: ViewPlugin<{
-    markers: RangeSet<FoldMarker>;
-    update({ docChanged, viewportChanged, startState, state, view }: ViewUpdate): void;
-}, undefined>;
-/**
- * 生成折叠命令
- * @param refOnly 是否仅检查`<ref>`标签
- */
-export declare const foldCommand: (refOnly?: boolean) => Command;
 export declare const foldRef: Command;
-declare const _default: [(e?: Extension | undefined) => Extension];
+declare const _default: (e?: Extension | undefined) => Extension;
 export default _default;
 export declare const mediaWikiFold: Extension;
 /**

package/dist/fold.js

@@ -5,8 +5,7 @@ import { getRegex } from '@bhsd/common';
 import { tokens } from './config';
 import { matchTag, getTag } from './matchTag';
 const getExtRegex = /* @__PURE__ */ getRegex(tag => new RegExp(`mw-tag-${tag}(?![a-z])`, 'u'));
-export const updateSelection = (pos, { to }) => Math.max(pos, to);
-const updateAll = (pos, { from, to }) => from <= pos && to > pos ? to : pos;
+const updateSelection = (pos, { to }) => Math.max(pos, to), updateAll = (pos, { from, to }) => from <= pos && to > pos ? to : pos;
 /**
  * Check if a SyntaxNode is among the specified components
  * @param keys The keys of the tokens to check
@@ -145,7 +144,7 @@ export const foldable = (state, posOrNode, tree, refOnly = false) => {
  * 创建折叠提示
  * @param state
  */
-export const create = (state) => {
+const create = (state) => {
     const { selection: { main: { head } } } = state, range = foldable(state, head);
     if (range) {
         const { from, to } = range;
@@ -179,7 +178,7 @@ export const create = (state) => {
  * @param effects 折叠
  * @param anchor 光标位置
  */
-export const execute = (view, effects, anchor) => {
+const execute = (view, effects, anchor) => {
     if (effects.length > 0) {
         view.dom.querySelector('.cm-tooltip-fold')?.remove();
         // Fold the template(s) and update the cursor position
@@ -192,7 +191,7 @@ export const execute = (view, effects, anchor) => {
  * The rightmost position of all selections, to be updated with folding
  * @param state
  */
-export const getAnchor = (state) => Math.max(...state.selection.ranges.map(({ to }) => to));
+const getAnchor = (state) => Math.max(...state.selection.ranges.map(({ to }) => to));
 /**
  * 折叠所有模板
  * @param state
@@ -204,7 +203,7 @@ export const getAnchor = (state) => Math.max(...state.selection.ranges.map(({ to
  * @param update 更新光标位置
  * @param refOnly 是否仅检查`<ref>`标签
  */
-export const traverse = (state, tree, effects, node, end, anchor, update, refOnly) => {
+const traverse = (state, tree, effects, node, end, anchor, update, refOnly) => {
     while (node && node.from <= end) {
         /* eslint-disable no-param-reassign */
         const range = foldable(state, node, tree, refOnly);
@@ -220,7 +219,7 @@ export const traverse = (state, tree, effects, node, end, anchor, update, refOnl
     }
     return anchor;
 };
-export class FoldMarker extends GutterMarker {
+class FoldMarker extends GutterMarker {
     constructor(open) {
         super();
         this.open = open;
@@ -236,7 +235,7 @@ export class FoldMarker extends GutterMarker {
     }
 }
 const canFold = /* @__PURE__ */ new FoldMarker(true), canUnfold = /* @__PURE__ */ new FoldMarker(false);
-export const findFold = ({ state }, line) => {
+const findFold = ({ state }, line) => {
     let found;
     state.field(foldState, false)?.between(line.from, line.to, (from, to) => {
         if (!found && to === line.to) {
@@ -310,7 +309,7 @@ const buildMarkers = (view) => {
     }
     return builder.finish();
 };
-export const markers = /* @__PURE__ */ ViewPlugin.fromClass(class {
+const markers = /* @__PURE__ */ ViewPlugin.fromClass(class {
     constructor(view) {
         this.markers = buildMarkers(view);
     }
@@ -329,12 +328,12 @@ const defaultFoldExtension = [foldGutter(), keymap.of(foldKeymap)];
  * 生成折叠命令
  * @param refOnly 是否仅检查`<ref>`标签
  */
-export const foldCommand = (refOnly) => view => {
+const foldCommand = (refOnly) => view => {
     const { state } = view, tree = syntaxTree(state), effects = [], anchor = traverse(state, tree, effects, tree.topNode.firstChild, Infinity, getAnchor(state), updateAll, refOnly);
     return execute(view, effects, anchor);
 };
 export const foldRef = /* @__PURE__ */ foldCommand(true);
-export default [(e = defaultFoldExtension) => e];
+export default ((e = defaultFoldExtension) => e);
 export const mediaWikiFold = /* @__PURE__ */ (() => [
     codeFolding({
         placeholderDOM(view) {

package/dist/index.d.ts

@@ -0,0 +1,98 @@
+import { CodeMirror6 } from './codemirror';
+import type { LanguageSupport } from '@codemirror/language';
+import type { MwConfig } from './token';
+import type { LintSourceGetter } from './lintsource';
+export type { MwConfig };
+export { CodeMirror6 };
+/** Register the `highlightSpecialChars` extension */
+export declare const registerHighlightSpecialChars: () => void;
+/** Register the `highlightActiveLine` extension */
+export declare const registerHighlightActiveLine: () => void;
+/** Register the `highlightWhitespace` extension */
+export declare const registerHighlightWhitespace: () => void;
+/** Register the `highlightTrailingWhitespace` extension */
+export declare const registerHighlightTrailingWhitespace: () => void;
+/** Register the `highlightSelectionMatches` extension */
+export declare const registerHighlightSelectionMatches: () => void;
+/** Register the `bracketMatching` extension */
+export declare const registerBracketMatching: () => void;
+/** Register the `closeBrackets` extension */
+export declare const registerCloseBrackets: () => void;
+/** Register the `scrollPastEnd` extension */
+export declare const registerScrollPastEnd: () => void;
+/** Register the `allowMultipleSelections` extension */
+export declare const registerAllowMultipleSelections: () => void;
+/** Register the `autocompletion` extension */
+export declare const registerAutocompletion: () => void;
+/** Register the `codeFolding` extension */
+export declare const registerCodeFolding: () => void;
+/** Register the `colorPicker` extension */
+export declare const registerColorPicker: () => void;
+/** Register all common extensions */
+export declare const registerCommonExtensions: () => void;
+/** Register MediaWiki language support */
+export declare const registerMediaWiki: () => void;
+/** Register the `openLinks` extension */
+export declare const registerOpenLinks: () => void;
+/** Register the `escape` extension */
+export declare const registerEscape: () => void;
+/** Register the `refHover` extension */
+export declare const registerRefHover: () => void;
+/** Register the `hover` extension */
+export declare const registerHover: () => void;
+/** Register the `signatureHelp` extension */
+export declare const registerSignatureHelp: () => void;
+/** Register the `inlayHints` extension */
+export declare const registerInlayHints: () => void;
+/** Register the `colorPicker` extension for MediaWiki */
+export declare const registerColorPickerForMediaWiki: () => void;
+/** Register the `bracketMatching` extension for MediaWiki */
+export declare const registerBracketMatchingForMediaWiki: () => void;
+/** Register the `codeFolding` extension for MediaWiki */
+export declare const registerCodeFoldingForMediaWiki: () => void;
+/** Register MediaWiki core language support */
+export declare const registerMediaWikiCore: () => void;
+/** Register mixed MediaWiki-HTML language support */
+export declare const registerHTML: () => void;
+/** Register HTML core language support */
+export declare const registerHTMLCore: () => void;
+/** Register JavaScript language support */
+export declare const registerJavaScript: () => void;
+/** Register JavaScript core language support */
+export declare const registerJavaScriptCore: () => void;
+/** Register CSS language support */
+export declare const registerCSS: () => void;
+/** Register the `colorPicker` extension for CSS */
+export declare const registerColorPickerForCSS: () => void;
+/** Register CSS core language support */
+export declare const registerCSSCore: () => void;
+/** Register JSON language support */
+export declare const registerJSON: () => void;
+/** Register JSON core language support */
+export declare const registerJSONCore: () => void;
+/** Register Lua language support */
+export declare const registerLua: () => void;
+/** Register Lua core language support */
+export declare const registerLuaCore: () => void;
+/** Register Vue language support */
+export declare const registerVue: () => void;
+/** Register the `closeBrackets` extension for Vue */
+export declare const registerCloseBracketsForVue: () => void;
+/** Register the `colorPicker` extension for Vue */
+export declare const registerColorPickerForVue: () => void;
+/** Register Vue core language support */
+export declare const registerVueCore: () => void;
+/**
+ * Register a custom language support
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export declare const registerLanguage: (name: string, lang: (config?: unknown) => LanguageSupport, lintSource?: LintSourceGetter) => void;
+/**
+ * Register a custom language support without common extensions
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export declare const registerLanguageCore: (name: string, lang: (config?: unknown) => LanguageSupport, lintSource?: LintSourceGetter) => void;

package/dist/index.js

@@ -0,0 +1,316 @@
+import { keymap, highlightSpecialChars, highlightActiveLine, highlightWhitespace, highlightTrailingWhitespace, scrollPastEnd, drawSelection, rectangularSelection, crosshairCursor, } from '@codemirror/view';
+import { EditorState } from '@codemirror/state';
+import { highlightSelectionMatches } from '@codemirror/search';
+import { closeBrackets, autocompletion, acceptCompletion, completionKeymap, startCompletion, } from '@codemirror/autocomplete';
+import { json } from '@codemirror/lang-json';
+import { autoCloseTags } from '@codemirror/lang-html';
+import { css as cssParser } from '@codemirror/legacy-modes/mode/css';
+import { getLSP } from '@bhsd/browser';
+import { colorPicker as cssColorPicker, colorPickerTheme, makeColorPicker } from '@bhsd/codemirror-css-color-picker';
+import colorPicker, { discoverColors } from './color';
+import { mediawiki, html, FullMediaWiki } from './mediawiki';
+import escape from './escape';
+import codeFolding, { mediaWikiFold } from './fold';
+import tagMatchingState from './matchTag';
+import refHover from './ref';
+import magicWordHover from './hover';
+import signatureHelp from './signature';
+import inlayHints from './inlay';
+import { getWikiLintSource, getJsLintSource, getCssLintSource, getJsonLintSource, getLuaLintSource, getVueLintSource, } from './lintsource';
+import openLinks from './openLinks';
+import { tagModes, getStaticMwConfig } from './static';
+import bidiIsolation from './bidi';
+import toolKeymap from './keymap';
+import bracketMatching from './matchBrackets';
+import javascript from './javascript';
+import css from './css';
+import lua from './lua';
+import vue from './vue';
+import { CodeMirror6, avail, languages, linterRegistry, destroyListeners, plain } from './codemirror';
+export { CodeMirror6 };
+/**
+ * 注册通用扩展
+ * @param name 扩展名
+ * @param ext 扩展
+ */
+const registerExtension = (name, ext) => {
+    avail[name] ??= [];
+    const addon = avail[name];
+    addon[0] = ext;
+};
+/** Register the `highlightSpecialChars` extension */
+export const registerHighlightSpecialChars = () => {
+    registerExtension('highlightSpecialChars', highlightSpecialChars);
+};
+/** Register the `highlightActiveLine` extension */
+export const registerHighlightActiveLine = () => {
+    registerExtension('highlightActiveLine', highlightActiveLine);
+};
+/** Register the `highlightWhitespace` extension */
+export const registerHighlightWhitespace = () => {
+    registerExtension('highlightWhitespace', highlightWhitespace);
+};
+/** Register the `highlightTrailingWhitespace` extension */
+export const registerHighlightTrailingWhitespace = () => {
+    registerExtension('highlightTrailingWhitespace', highlightTrailingWhitespace);
+};
+/** Register the `highlightSelectionMatches` extension */
+export const registerHighlightSelectionMatches = () => {
+    registerExtension('highlightSelectionMatches', highlightSelectionMatches);
+};
+/** Register the `bracketMatching` extension */
+export const registerBracketMatching = () => {
+    registerExtension('bracketMatching', ([config, e = []] = []) => [
+        bracketMatching(config),
+        e,
+    ]);
+};
+/** Register the `closeBrackets` extension */
+export const registerCloseBrackets = () => {
+    registerExtension('closeBrackets', (e = []) => [closeBrackets(), e]);
+};
+/** Register the `scrollPastEnd` extension */
+export const registerScrollPastEnd = () => {
+    registerExtension('scrollPastEnd', scrollPastEnd);
+};
+/** Register the `allowMultipleSelections` extension */
+export const registerAllowMultipleSelections = () => {
+    registerExtension('allowMultipleSelections', () => [
+        EditorState.allowMultipleSelections.of(true),
+        drawSelection(),
+        rectangularSelection(),
+        crosshairCursor(),
+    ]);
+};
+/** Register the `autocompletion` extension */
+export const registerAutocompletion = () => {
+    registerExtension('autocompletion', () => [
+        autocompletion({ defaultKeymap: false }),
+        keymap.of([
+            ...completionKeymap.filter(({ run }) => run !== startCompletion),
+            { key: 'Shift-Enter', run: startCompletion },
+            { key: 'Tab', run: acceptCompletion },
+        ]),
+    ]);
+};
+/** Register the `codeFolding` extension */
+export const registerCodeFolding = () => {
+    registerExtension('codeFolding', codeFolding);
+};
+/** Register the `colorPicker` extension */
+export const registerColorPicker = () => {
+    registerExtension('colorPicker', colorPicker);
+};
+/** 注册所有通用扩展（除`colorPicker`） */
+const registerExtensions = () => {
+    highlightSpecialChars();
+    registerHighlightActiveLine();
+    registerHighlightWhitespace();
+    registerHighlightTrailingWhitespace();
+    registerHighlightSelectionMatches();
+    registerBracketMatching();
+    registerCloseBrackets();
+    registerScrollPastEnd();
+    registerAllowMultipleSelections();
+    registerAutocompletion();
+    registerCodeFolding();
+};
+/** Register all common extensions */
+export const registerCommonExtensions = () => {
+    registerExtensions();
+    registerColorPicker();
+};
+function mediawikiOnly(ext) {
+    return typeof ext === 'function'
+        ? [(enable, cm) => enable ? ext(cm) : [], { mediawiki: true }]
+        : [(e = []) => e, { mediawiki: ext }];
+}
+/**
+ * 注册特定语言的扩展
+ * @param lang 语言
+ * @param name 扩展名
+ * @param ext 扩展
+ */
+const registerLangExtension = (lang, name, ext) => {
+    avail[name] ??= [() => []];
+    const addon = avail[name];
+    addon[1] ??= {};
+    addon[1][lang] = ext;
+};
+/** Register MediaWiki language support */
+export const registerMediaWiki = () => {
+    registerCommonExtensions();
+    registerMediaWikiCore();
+    registerOpenLinks();
+    registerEscape();
+    registerRefHover();
+    registerHover();
+    registerSignatureHelp();
+    registerInlayHints();
+    registerColorPickerForMediaWiki();
+    registerBracketMatchingForMediaWiki();
+    registerCodeFoldingForMediaWiki();
+};
+/**
+ * 注册MediaWiki专用扩展
+ * @param name 扩展名
+ * @param ext 扩展
+ */
+const registerExtensionForMediaWiki = (name, ext) => {
+    avail[name] ??= mediawikiOnly(ext);
+};
+/** Register the `openLinks` extension */
+export const registerOpenLinks = () => {
+    registerExtensionForMediaWiki('openLinks', openLinks);
+};
+/** Register the `escape` extension */
+export const registerEscape = () => {
+    registerExtensionForMediaWiki('escape', escape);
+};
+/** Register the `refHover` extension */
+export const registerRefHover = () => {
+    registerExtensionForMediaWiki('refHover', refHover);
+};
+/** Register the `hover` extension */
+export const registerHover = () => {
+    registerExtensionForMediaWiki('hover', magicWordHover);
+};
+/** Register the `signatureHelp` extension */
+export const registerSignatureHelp = () => {
+    registerExtensionForMediaWiki('signatureHelp', signatureHelp);
+};
+/** Register the `inlayHints` extension */
+export const registerInlayHints = () => {
+    registerExtensionForMediaWiki('inlayHints', inlayHints);
+};
+/** Register the `colorPicker` extension for MediaWiki */
+export const registerColorPickerForMediaWiki = () => {
+    registerLangExtension('mediawiki', 'colorPicker', [
+        [makeColorPicker({ discoverColors }), colorPickerTheme],
+        { marginLeft: '0.6ch' },
+    ]);
+};
+/** Register the `bracketMatching` extension for MediaWiki */
+export const registerBracketMatchingForMediaWiki = () => {
+    registerLangExtension('mediawiki', 'bracketMatching', [
+        { brackets: '()[]{}（）【】［］｛｝' },
+        tagMatchingState,
+    ]);
+};
+/** Register the `codeFolding` extension for MediaWiki */
+export const registerCodeFoldingForMediaWiki = () => {
+    registerLangExtension('mediawiki', 'codeFolding', mediaWikiFold);
+};
+/** Register MediaWiki core language support */
+export const registerMediaWikiCore = () => {
+    CodeMirror6.getMwConfig = (config) => getStaticMwConfig(config, tagModes);
+    languages['mediawiki'] = (config) => [
+        mediawiki(config),
+        plain(),
+        bidiIsolation,
+        toolKeymap,
+    ];
+    linterRegistry['mediawiki'] = getWikiLintSource;
+    destroyListeners.push(view => getLSP(view)?.destroy());
+};
+/** Register mixed MediaWiki-HTML language support */
+export const registerHTML = () => {
+    registerCommonExtensions();
+    registerHTMLCore();
+};
+/** Register HTML core language support */
+export const registerHTMLCore = () => {
+    Object.assign(FullMediaWiki.prototype, {
+        css() {
+            return cssParser;
+        },
+    });
+    languages['html'] = html;
+};
+/** Register JavaScript language support */
+export const registerJavaScript = () => {
+    registerExtensions();
+    registerJavaScriptCore();
+};
+/** Register JavaScript core language support */
+export const registerJavaScriptCore = () => {
+    languages['javascript'] = javascript;
+    linterRegistry['javascript'] = getJsLintSource;
+};
+/** Register CSS language support */
+export const registerCSS = () => {
+    registerCommonExtensions();
+    registerCSSCore();
+    registerColorPickerForCSS();
+};
+/** Register the `colorPicker` extension for CSS */
+export const registerColorPickerForCSS = () => {
+    registerLangExtension('css', 'colorPicker', [cssColorPicker]);
+};
+/** Register CSS core language support */
+export const registerCSSCore = () => {
+    languages['css'] = css;
+    linterRegistry['css'] = getCssLintSource;
+};
+/** Register JSON language support */
+export const registerJSON = () => {
+    registerExtensions();
+    registerJSONCore();
+};
+/** Register JSON core language support */
+export const registerJSONCore = () => {
+    languages['json'] = json;
+    linterRegistry['json'] = getJsonLintSource;
+};
+/** Register Lua language support */
+export const registerLua = () => {
+    registerExtensions();
+    registerLuaCore();
+};
+/** Register Lua core language support */
+export const registerLuaCore = () => {
+    languages['lua'] = lua;
+    linterRegistry['lua'] = getLuaLintSource;
+};
+/** Register Vue language support */
+export const registerVue = () => {
+    registerCommonExtensions();
+    registerVueCore();
+    registerCloseBracketsForVue();
+    registerColorPickerForVue();
+};
+/** Register the `closeBrackets` extension for Vue */
+export const registerCloseBracketsForVue = () => {
+    registerLangExtension('vue', 'closeBrackets', autoCloseTags);
+};
+/** Register the `colorPicker` extension for Vue */
+export const registerColorPickerForVue = () => {
+    registerLangExtension('vue', 'colorPicker', [cssColorPicker]);
+};
+/** Register Vue core language support */
+export const registerVueCore = () => {
+    languages['vue'] = vue;
+    linterRegistry['vue'] = getVueLintSource;
+};
+/**
+ * Register a custom language support
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export const registerLanguage = (name, lang, lintSource) => {
+    registerCommonExtensions();
+    registerLanguageCore(name, lang, lintSource);
+};
+/**
+ * Register a custom language support without common extensions
+ * @param name language name
+ * @param lang language support
+ * @param lintSource optional linter
+ */
+export const registerLanguageCore = (name, lang, lintSource) => {
+    languages[name] = lang;
+    if (lintSource) {
+        linterRegistry[name] = lintSource;
+    }
+};