monaco-yql-languages 1.0.5 → 1.0.6

package/build/_.contribution.d.ts

@@ -0,0 +1,88 @@
+import { CompletionLists } from './completion';
+import { IEvent, languages } from './fillers/monaco-editor-core';
+interface ILang extends languages.ILanguageExtensionPoint {
+    loader: () => Promise<ILangImpl>;
+}
+interface ILangImpl {
+    conf: languages.LanguageConfiguration;
+    language: languages.IMonarchLanguage;
+    completions?: CompletionLists;
+}
+export declare function loadLanguage(languageId: string): Promise<ILangImpl>;
+export declare function registerLanguage(def: ILang): void;
+export interface ICreateData {
+    languageId: string;
+}
+export interface ModeConfiguration {
+    /**
+     * Defines whether the built-in completionItemProvider is enabled.
+     */
+    readonly completionItems?: boolean;
+    /**
+     * Defines whether the built-in hoverProvider is enabled.
+     */
+    readonly hovers?: boolean;
+    /**
+     * Defines whether the built-in documentSymbolProvider is enabled.
+     */
+    readonly documentSymbols?: boolean;
+    /**
+     * Defines whether the built-in definitions provider is enabled.
+     */
+    readonly definitions?: boolean;
+    /**
+     * Defines whether the built-in references provider is enabled.
+     */
+    readonly references?: boolean;
+    /**
+     * Defines whether the built-in references provider is enabled.
+     */
+    readonly documentHighlights?: boolean;
+    /**
+     * Defines whether the built-in rename provider is enabled.
+     */
+    readonly rename?: boolean;
+    /**
+     * Defines whether the built-in color provider is enabled.
+     */
+    readonly colors?: boolean;
+    /**
+     * Defines whether the built-in foldingRange provider is enabled.
+     */
+    readonly foldingRanges?: boolean;
+    /**
+     * Defines whether the built-in diagnostic provider is enabled.
+     */
+    readonly diagnostics?: boolean;
+    /**
+     * Defines whether the built-in selection range provider is enabled.
+     */
+    readonly selectionRanges?: boolean;
+}
+export interface DiagnosticsOptions {
+    readonly validate?: boolean;
+}
+export interface LanguageServiceDefaults {
+    readonly languageId: string;
+    readonly onDidChange: IEvent<LanguageServiceDefaults>;
+    readonly diagnosticsOptions: DiagnosticsOptions;
+    readonly modeConfiguration: ModeConfiguration;
+    setDiagnosticsOptions(options: DiagnosticsOptions): void;
+    setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+export declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
+    private _onDidChange;
+    private _diagnosticsOptions;
+    private _modeConfiguration;
+    private _languageId;
+    constructor(languageId: string, diagnosticsOptions: DiagnosticsOptions, modeConfiguration: ModeConfiguration);
+    get onDidChange(): IEvent<LanguageServiceDefaults>;
+    get languageId(): string;
+    get modeConfiguration(): ModeConfiguration;
+    get diagnosticsOptions(): DiagnosticsOptions;
+    setDiagnosticsOptions(options: DiagnosticsOptions): void;
+    setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+export declare const modeConfigurationDefault: Required<ModeConfiguration>;
+export declare const diagnosticDefault: Required<DiagnosticsOptions>;
+export {};

package/build/_.contribution.js

@@ -0,0 +1,113 @@
+import { getCompletionItemsProvider } from './completion';
+import { Emitter, languages } from './fillers/monaco-editor-core';
+const languageDefinitions = {};
+const lazyLanguageLoaders = {};
+class LazyLanguageLoader {
+    static getOrCreate(languageId) {
+        if (!lazyLanguageLoaders[languageId]) {
+            lazyLanguageLoaders[languageId] = new LazyLanguageLoader(languageId);
+        }
+        return lazyLanguageLoaders[languageId];
+    }
+    constructor(languageId) {
+        this._languageId = languageId;
+        this._loadingTriggered = false;
+        this._lazyLoadPromise = new Promise((resolve, reject) => {
+            this._lazyLoadPromiseResolve = resolve;
+            this._lazyLoadPromiseReject = reject;
+        });
+    }
+    whenLoaded() {
+        return this._lazyLoadPromise;
+    }
+    load() {
+        if (!this._loadingTriggered) {
+            this._loadingTriggered = true;
+            languageDefinitions[this._languageId].loader().then((mod) => this._lazyLoadPromiseResolve(mod), (err) => this._lazyLoadPromiseReject(err));
+        }
+        return this._lazyLoadPromise;
+    }
+}
+export function loadLanguage(languageId) {
+    return LazyLanguageLoader.getOrCreate(languageId).load();
+}
+export function registerLanguage(def) {
+    const languageId = def.id;
+    languageDefinitions[languageId] = def;
+    languages.register(def);
+    const lazyLanguageLoader = LazyLanguageLoader.getOrCreate(languageId);
+    languages.setMonarchTokensProvider(languageId, lazyLanguageLoader.whenLoaded().then((mod) => mod.language));
+    languages.onLanguage(languageId, () => {
+        lazyLanguageLoader.load().then((mod) => {
+            languages.setLanguageConfiguration(languageId, mod.conf);
+        });
+    });
+    lazyLanguageLoader.whenLoaded().then((mod) => {
+        if (mod.completions) {
+            registerCompletionItemProvider(languageId, mod.completions);
+        }
+    });
+}
+function registerCompletionItemProvider(languageId, completions) {
+    const disposables = [];
+    function unregister() {
+        var _a;
+        while (disposables.length > 0) {
+            (_a = disposables.pop()) === null || _a === void 0 ? void 0 : _a.dispose();
+        }
+    }
+    const defaults = languages[languageId];
+    if (!defaults || defaults.modeConfiguration.completionItems) {
+        disposables.push(languages.registerCompletionItemProvider(languageId, getCompletionItemsProvider(completions, languages.CompletionItemKind)));
+    }
+    if (defaults) {
+        disposables.push(defaults.onDidChange(() => {
+            unregister();
+            registerCompletionItemProvider(languageId, completions);
+        }));
+    }
+}
+export class LanguageServiceDefaultsImpl {
+    constructor(languageId, diagnosticsOptions, modeConfiguration) {
+        this._onDidChange = new Emitter();
+        this._languageId = languageId;
+        this.setDiagnosticsOptions(diagnosticsOptions);
+        this.setModeConfiguration(modeConfiguration);
+    }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    get languageId() {
+        return this._languageId;
+    }
+    get modeConfiguration() {
+        return this._modeConfiguration;
+    }
+    get diagnosticsOptions() {
+        return this._diagnosticsOptions;
+    }
+    setDiagnosticsOptions(options) {
+        this._diagnosticsOptions = options || Object.create(null);
+        this._onDidChange.fire(this);
+    }
+    setModeConfiguration(modeConfiguration) {
+        this._modeConfiguration = modeConfiguration || Object.create(null);
+        this._onDidChange.fire(this);
+    }
+}
+export const modeConfigurationDefault = {
+    completionItems: true,
+    hovers: true,
+    documentSymbols: true,
+    definitions: true,
+    references: true,
+    documentHighlights: true,
+    rename: true,
+    colors: true,
+    foldingRanges: true,
+    diagnostics: true,
+    selectionRanges: true,
+};
+export const diagnosticDefault = {
+    validate: true,
+};

package/build/clickhouse/clickhouse.contribution.d.ts

@@ -0,0 +1,3 @@
+import { LanguageServiceDefaults } from '../_.contribution';
+export declare const LANGUAGE_ID = "clickhouse";
+export declare const clickhouseDefaults: LanguageServiceDefaults;

package/build/clickhouse/clickhouse.contribution.js

@@ -0,0 +1,16 @@
+import { LanguageServiceDefaultsImpl, diagnosticDefault, modeConfigurationDefault, registerLanguage, } from '../_.contribution';
+import { languages } from '../fillers/monaco-editor-core';
+export const LANGUAGE_ID = 'clickhouse';
+registerLanguage({
+    id: LANGUAGE_ID,
+    extensions: [],
+    loader: () => import('./clickhouse').then((module) => {
+        return {
+            conf: module.conf,
+            language: module.language,
+            completions: module.completionLists,
+        };
+    }),
+});
+export const clickhouseDefaults = new LanguageServiceDefaultsImpl(LANGUAGE_ID, diagnosticDefault, modeConfigurationDefault);
+languages[LANGUAGE_ID] = clickhouseDefaults;

package/build/clickhouse/clickhouse.d.ts

@@ -0,0 +1,4 @@
+import type { languages } from '../fillers/monaco-editor-core';
+export { completionLists } from './clickhouse.keywords';
+export declare const conf: languages.LanguageConfiguration;
+export declare const language: languages.IMonarchLanguage & Record<string, unknown>;

package/{src/clickhouse/clickhouse.ts → build/clickhouse/clickhouse.js}

@@ -1,19 +1,6 @@
-import type {languages} from '../fillers/monaco-editor-core';
-
-import {
-    constants,
-    dataTypeFamiliesCaseInsensitive,
-    dataTypeFamiliesCaseSensitive,
-    functionsCaseInsensitive,
-    functionsCaseSensitive,
-    keywords,
-    tableEngines,
-    tableFunctions,
-} from './clickhouse.keywords';
-
-export {completionLists} from './clickhouse.keywords';
-
-export const conf: languages.LanguageConfiguration = {
+import { constants, dataTypeFamiliesCaseInsensitive, dataTypeFamiliesCaseSensitive, functionsCaseInsensitive, functionsCaseSensitive, keywords, tableEngines, tableFunctions, } from './clickhouse.keywords';
+export { completionLists } from './clickhouse.keywords';
+export const conf = {
     comments: {
         lineComment: '--',
         blockComment: ['```', '```'],
@@ -24,40 +11,33 @@ export const conf: languages.LanguageConfiguration = {
         ['(', ')'],
     ],
     autoClosingPairs: [
-        {open: '{', close: '}'},
-        {open: '[', close: ']'},
-        {open: '(', close: ')'},
-        {open: '"', close: '"'},
-        {open: "'", close: "'"},
-        {open: '`', close: '`'},
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
     ],
     surroundingPairs: [
-        {open: '{', close: '}'},
-        {open: '[', close: ']'},
-        {open: '(', close: ')'},
-        {open: '"', close: '"'},
-        {open: "'", close: "'"},
-        {open: '`', close: '`'},
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
     ],
 };
-
 const keywordsCaseInsensitive = getCaseInsensitiveRegExp(keywords);
-const typeKeywordsCaseInsensitive = getCaseInsensitiveRegExp(
-    oneWordPatterns(dataTypeFamiliesCaseInsensitive),
-);
+const typeKeywordsCaseInsensitive = getCaseInsensitiveRegExp(oneWordPatterns(dataTypeFamiliesCaseInsensitive));
 const builtinFunctionsCaseInsensitive = getCaseInsensitiveRegExp(functionsCaseInsensitive);
-
-export const language: languages.IMonarchLanguage & Record<string, unknown> = {
+export const language = {
     defaultToken: 'text',
-
     brackets: [
-        {open: '[', close: ']', token: 'delimiter.square'},
-        {open: '(', close: ')', token: 'delimiter.parenthesis'},
-        {open: '{', close: '}', token: 'delimiter.curly'},
+        { open: '[', close: ']', token: 'delimiter.square' },
+        { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        { open: '{', close: '}', token: 'delimiter.curly' },
     ],
-
     keywords,
-
     keywordsDouble: [
         `${caseInsensitiveRegExp('GROUP')}\\W+${caseInsensitiveRegExp('BY')}`,
         `${caseInsensitiveRegExp('ON')}\\W+${caseInsensitiveRegExp('CLUSTER')}`,
@@ -81,18 +61,12 @@ export const language: languages.IMonarchLanguage & Record<string, unknown> = {
         `${caseInsensitiveRegExp('FORMAT')}\\W+JSON`,
         `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparated`,
     ].join('|'),
-
     typeKeywords: dataTypeFamiliesCaseSensitive,
-    typeKeywordsDouble: getCaseInsensitiveRegExp(
-        manyWordsPatterns(dataTypeFamiliesCaseInsensitive),
-    ),
+    typeKeywordsDouble: getCaseInsensitiveRegExp(manyWordsPatterns(dataTypeFamiliesCaseInsensitive)),
     constants,
-
     builtinFunctions: functionsCaseSensitive,
-
     tableFunctions,
     tableEngines,
-
     operators: [
         '+',
         '-',
@@ -114,18 +88,16 @@ export const language: languages.IMonarchLanguage & Record<string, unknown> = {
         '<>',
         '=',
     ],
-
     symbols: /[=><!~?:&|+\-*/^%]+/,
     escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
     // TODO: FIX ME
     variables: /[\w]+(?:\[[\w\]+]|[=-]>\w+)?/,
-
     tokenizer: {
         root: [
-            {include: '@whitespace'},
-            {include: '@comments'},
-            {include: '@numbers'},
-            {include: '@strings'},
+            { include: '@whitespace' },
+            { include: '@comments' },
+            { include: '@numbers' },
+            { include: '@strings' },
             // variables
             [/[$@:](@variables)/, 'variable'],
             [/{(@variables)}/, 'variable'],
@@ -138,14 +110,14 @@ export const language: languages.IMonarchLanguage & Record<string, unknown> = {
                 /[a-zA-Z_$][\w$]*/,
                 {
                     cases: {
-                        [keywordsCaseInsensitive]: {token: 'keyword'},
-                        '@constants': {token: 'constant'},
-                        '@builtinFunctions': {token: 'constant.other.color'},
-                        [builtinFunctionsCaseInsensitive]: {token: 'constant.other.color'},
-                        '@tableFunctions': {token: 'constant.other.color'},
-                        '@tableEngines': {token: 'constant.other.color'},
-                        '@typeKeywords': {token: 'keyword.type'},
-                        [typeKeywordsCaseInsensitive]: {token: 'keyword.type'},
+                        [keywordsCaseInsensitive]: { token: 'keyword' },
+                        '@constants': { token: 'constant' },
+                        '@builtinFunctions': { token: 'constant.other.color' },
+                        [builtinFunctionsCaseInsensitive]: { token: 'constant.other.color' },
+                        '@tableFunctions': { token: 'constant.other.color' },
+                        '@tableEngines': { token: 'constant.other.color' },
+                        '@typeKeywords': { token: 'keyword.type' },
+                        [typeKeywordsCaseInsensitive]: { token: 'keyword.type' },
                         '@default': 'identifier',
                     },
                 },
@@ -163,66 +135,62 @@ export const language: languages.IMonarchLanguage & Record<string, unknown> = {
         whitespace: [[/\s+/, 'white']],
         comments: [
             [/--+.*/, 'comment'],
-            [/```/, {token: 'comment.quote', next: '@comment'}],
-            [/\/\*/, {token: 'comment.quote', next: '@cppComment'}],
+            [/```/, { token: 'comment.quote', next: '@comment' }],
+            [/\/\*/, { token: 'comment.quote', next: '@cppComment' }],
         ],
         comment: [
             [/[^`]+/, 'comment'],
-            [/```/, {token: 'comment.quote', next: '@pop'}],
+            [/```/, { token: 'comment.quote', next: '@pop' }],
             [/./, 'comment'],
         ],
         cppComment: [
             [/[^*/]+/, 'comment'],
-            [/\*\//, {token: 'comment.quote', next: '@pop'}],
+            [/\*\//, { token: 'comment.quote', next: '@pop' }],
             [/./, 'comment'],
         ],
         numbers: [[/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/, 'number']],
         strings: [
-            [/'/, {token: 'string', next: '@stringSingle'}],
-            [/"/, {token: 'string.tablepath', next: '@stringDouble'}],
-            [/`/, {token: 'string.tablepath', next: '@stringBacktick'}],
+            [/'/, { token: 'string', next: '@stringSingle' }],
+            [/"/, { token: 'string.tablepath', next: '@stringDouble' }],
+            [/`/, { token: 'string.tablepath', next: '@stringBacktick' }],
         ],
         stringSingle: [
             [/[^\\']/, 'string'],
             [/@escapes/, 'string.escape'],
             [/\\./, 'string.escape.invalid'],
-            [/'/, {token: 'string', next: '@pop'}],
+            [/'/, { token: 'string', next: '@pop' }],
         ],
         stringDouble: [
             [/[^\\"]/, 'string.tablepath'],
             [/@escapes/, 'string.tablepath'],
             [/\\./, 'string.tablepath'],
-            [/"/, {token: 'string.tablepath', next: '@pop'}],
+            [/"/, { token: 'string.tablepath', next: '@pop' }],
         ],
         stringBacktick: [
             [/[^\\`]/, 'string.tablepath'],
             [/@escapes/, 'string.tablepath'],
             [/\\./, 'string.tablepath'],
-            [/`/, {token: 'string.tablepath', next: '@pop'}],
+            [/`/, { token: 'string.tablepath', next: '@pop' }],
         ],
     },
 };
-
-function caseInsensitiveRegExp(pattern: string) {
+function caseInsensitiveRegExp(pattern) {
     return pattern
         .split('')
         .map((char) => {
-            if (/[a-zA-Z]/.test(char)) {
-                return `[${char.toLowerCase()}${char.toUpperCase()}]`;
-            }
-            return char;
-        })
+        if (/[a-zA-Z]/.test(char)) {
+            return `[${char.toLowerCase()}${char.toUpperCase()}]`;
+        }
+        return char;
+    })
         .join('');
 }
-
-function getCaseInsensitiveRegExp(patterns: string[]) {
+function getCaseInsensitiveRegExp(patterns) {
     return `(${patterns.map((pattern) => caseInsensitiveRegExp(pattern).replace(/\s+/g, '\\s')).join('|')})`;
 }
-
-function oneWordPatterns(patterns: string[]) {
+function oneWordPatterns(patterns) {
     return patterns.filter((pattern) => /^\S*$/.test(pattern));
 }
-
-function manyWordsPatterns(patterns: string[]) {
+function manyWordsPatterns(patterns) {
     return patterns.filter((pattern) => /\s/.test(pattern)).sort((a, b) => b.localeCompare(a));
 }

package/build/clickhouse/clickhouse.keywords.d.ts

@@ -0,0 +1,11 @@
+import type { CompletionLists } from '../completion';
+export declare const keywords: string[];
+export declare const keywordsDouble: string[];
+export declare const constants: string[];
+export declare const functionsCaseSensitive: string[];
+export declare const functionsCaseInsensitive: string[];
+export declare const tableFunctions: string[];
+export declare const tableEngines: string[];
+export declare const dataTypeFamiliesCaseSensitive: string[];
+export declare const dataTypeFamiliesCaseInsensitive: string[];
+export declare const completionLists: CompletionLists;

package/{src/clickhouse/clickhouse.keywords.ts → build/clickhouse/clickhouse.keywords.js}

@@ -1,5 +1,3 @@
-import type {CompletionLists} from '../completion';
-
 export const keywords = [
     'AND',
     'ANY',
@@ -58,7 +56,6 @@ export const keywords = [
     'WHERE',
     'WITH',
 ];
-
 export const keywordsDouble = [
     'GROUP BY',
     'ON CLUSTER',
@@ -80,9 +77,7 @@ export const keywordsDouble = [
     'FORMAT JSON',
     'FORMAT TabSeparated',
 ];
-
 export const constants = ['true', 'false', 'NULL'];
-
 export const functionsCaseSensitive = [
     '__bitBoolMaskAnd',
     '__bitBoolMaskOr',
@@ -1016,7 +1011,6 @@ export const functionsCaseSensitive = [
     'YSONLength',
     'YSONType',
 ];
-
 export const functionsCaseInsensitive = [
     '_CAST',
     'abs',
@@ -1138,7 +1132,6 @@ export const functionsCaseInsensitive = [
     'YEAR',
     'yearweek',
 ];
-
 export const tableFunctions = [
     'cluster',
     'clusterAllReplicas',
@@ -1166,9 +1159,7 @@ export const tableFunctions = [
     'zeros',
     'zeros_mt',
 ];
-
 export const tableEngines = ['Buffer', 'Memory', 'YtTable'];
-
 export const dataTypeFamiliesCaseSensitive = [
     'AggregateFunction',
     'Array',
@@ -1214,7 +1205,6 @@ export const dataTypeFamiliesCaseSensitive = [
     'UUID',
     'YtBoolean',
 ];
-
 export const dataTypeFamiliesCaseInsensitive = [
     'BIGINT',
     'BIGINT SIGNED',
@@ -1294,13 +1284,9 @@ export const dataTypeFamiliesCaseInsensitive = [
     'VARCHAR',
     'VARCHAR2',
 ];
-
-export const completionLists: CompletionLists = {
+export const completionLists = {
     keywordList: keywords.concat(keywordsDouble),
     constantList: constants,
-    typeParameterList: dataTypeFamiliesCaseSensitive.concat(
-        dataTypeFamiliesCaseInsensitive,
-        tableEngines,
-    ),
+    typeParameterList: dataTypeFamiliesCaseSensitive.concat(dataTypeFamiliesCaseInsensitive, tableEngines),
     functionList: functionsCaseSensitive.concat(functionsCaseInsensitive, tableFunctions),
 };

package/build/completion.d.ts

@@ -0,0 +1,9 @@
+import type { CancellationToken, Position, editor, languages } from './fillers/monaco-editor-core';
+export type CompletionListProvider = {
+    (content: string, offset: number, signal?: AbortSignal | null): Promise<string[]>;
+};
+export declare function provideCompletionItems(getCompletionList: CompletionListProvider): (model: editor.ITextModel, position: Position, context: languages.CompletionContext, token: CancellationToken) => languages.ProviderResult<languages.CompletionList>;
+export type CompletionLists = Partial<Record<`${Uncapitalize<keyof typeof languages.CompletionItemKind>}List`, Readonly<string[]>>>;
+export declare function getCompletionItemsProvider(completions: CompletionLists, completionItemKind: typeof languages.CompletionItemKind): {
+    provideCompletionItems(model: editor.ITextModel, position: Position, _context: languages.CompletionContext, _token: CancellationToken): languages.CompletionList | undefined;
+};

package/build/completion.js

@@ -0,0 +1,87 @@
+const allUpperCaseRe = new RegExp('^[$A-Z_\\s]+$');
+export function provideCompletionItems(getCompletionList) {
+    return (model, position, context, token) => {
+        const controller = new AbortController();
+        const signal = controller.signal;
+        token.onCancellationRequested(() => {
+            controller.abort();
+        });
+        const prevText = model
+            .getLineContent(position.lineNumber)
+            .slice(0, position.column - 1)
+            .toLowerCase();
+        if (context.triggerCharacter === ':' && prevText.slice(-2) !== '::') {
+            return { suggestions: [] };
+        }
+        else if (context.triggerCharacter === '`' && /[^\s.]`$/.test(prevText)) {
+            return { suggestions: [] };
+        }
+        return getCompletionList(model.getValue(), model.getOffsetAt(position), signal).then(async (data) => {
+            const suggestions = [];
+            for (const label of data) {
+                const suggest = label.length > 1
+                    ? label.slice(0, -1).replace(/[/[]/g, '\\\\$&') + label.slice(-1)
+                    : label;
+                let range;
+                if (/[`~!@#%^&*()-=+[{\]}|;:'",.<>/?]/.test(suggest)) {
+                    for (let i = 0; i < label.length; i++) {
+                        const prefix = (i === 0 ? suggest : suggest.slice(0, -i)).toLowerCase();
+                        if (prevText.endsWith(prefix)) {
+                            range = {
+                                startLineNumber: position.lineNumber,
+                                startColumn: position.column - prefix.length,
+                                endLineNumber: position.lineNumber,
+                                endColumn: position.column,
+                            };
+                            break;
+                        }
+                    }
+                }
+                suggestions.push({
+                    label,
+                    filterText: allUpperCaseRe.test(label) ? label.toLowerCase() : label,
+                    kind: 18, // languages.CompletionItemKind.Text,
+                    insertText: suggest,
+                    command: label.endsWith('/') || label.endsWith('.`') || label.endsWith('::')
+                        ? { id: 'editor.action.triggerSuggest', title: '' }
+                        : undefined,
+                    //@ts-ignore
+                    range,
+                });
+            }
+            return { suggestions, incomplete: suggestions.length > 0 };
+        });
+    };
+}
+export function getCompletionItemsProvider(completions, completionItemKind) {
+    const suggestions = [];
+    for (const value in completionItemKind) {
+        if (!isNaN(Number(value))) {
+            const name = `${completionItemKind[value].toLowerCase()}List`;
+            if (name in completions) {
+                for (const label of completions[name]) {
+                    suggestions.push({
+                        label,
+                        filterText: allUpperCaseRe.test(label) ? label.toLowerCase() : label,
+                        insertText: label,
+                        kind: Number(value),
+                        range: { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 },
+                    });
+                }
+            }
+        }
+    }
+    suggestions.sort((a, b) => a.filterText.localeCompare(b.filterText));
+    return {
+        provideCompletionItems(model, position, _context, _token) {
+            const word = model.getWordUntilPosition(position);
+            const range = {
+                startLineNumber: position.lineNumber,
+                startColumn: word.startColumn,
+                endLineNumber: position.lineNumber,
+                endColumn: word.endColumn,
+            };
+            return { suggestions: suggestions.map((s) => (Object.assign(Object.assign({}, s), { range }))) };
+        },
+    };
+}

package/build/fillers/monaco-editor-core.js

@@ -0,0 +1 @@
+export * from 'monaco-editor/esm/vs/editor/editor.api';

package/build/monaco.contribution.js

@@ -0,0 +1,5 @@
+import './clickhouse/clickhouse.contribution';
+import './s-expressions/s-expressions.contribution';
+import './themes/themes.contribution';
+import './yql/yql.contribution';
+import './yql/yql_ansi.contribution';

package/build/s-expressions/s-expressions.contribution.d.ts

@@ -0,0 +1 @@
+export declare const LANGUAGE_ID = "s-expression";

package/{src/s-expressions/s-expressions.contribution.ts → build/s-expressions/s-expressions.contribution.js}

@@ -1,7 +1,5 @@
-import {registerLanguage} from '../_.contribution';
-
+import { registerLanguage } from '../_.contribution';
 export const LANGUAGE_ID = 's-expression';
-
 registerLanguage({
     id: LANGUAGE_ID,
     extensions: [],