monaco-yql-languages 1.0.2

package/src/clickhouse/clickhouse.ts

@@ -0,0 +1,228 @@
+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 = {
+    comments: {
+        lineComment: '--',
+        blockComment: ['```', '```'],
+    },
+    brackets: [
+        ['{', '}'],
+        ['[', ']'],
+        ['(', ')'],
+    ],
+    autoClosingPairs: [
+        {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: '`'},
+    ],
+};
+
+const keywordsCaseInsensitive = getCaseInsensitiveRegExp(keywords);
+const typeKeywordsCaseInsensitive = getCaseInsensitiveRegExp(
+    oneWordPatterns(dataTypeFamiliesCaseInsensitive),
+);
+const builtinFunctionsCaseInsensitive = getCaseInsensitiveRegExp(functionsCaseInsensitive);
+
+export const language: languages.IMonarchLanguage & Record<string, unknown> = {
+    defaultToken: 'text',
+
+    brackets: [
+        {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')}`,
+        `${caseInsensitiveRegExp('ORDER')}\\W+${caseInsensitiveRegExp('BY')}`,
+        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+\\W*,\\W*\\d+`,
+        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+\\W+${caseInsensitiveRegExp('BY')}\\W+`,
+        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+`,
+        `${caseInsensitiveRegExp('RENAME')}\\W+${caseInsensitiveRegExp('TABLE')}`,
+        `${caseInsensitiveRegExp('IF')}\\W+${caseInsensitiveRegExp('NOT')}\\W+${caseInsensitiveRegExp('EXISTS')}`,
+        `${caseInsensitiveRegExp('IF')}\\W+${caseInsensitiveRegExp('EXISTS')}`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+Vertical`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+JSONCompact`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+JSONEachRow`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TSKV`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedWithNames`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedWithNamesAndTypes`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedRaw`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+BlockTabSeparated`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+CSVWithNames`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+CSV`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+JSON`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparated`,
+    ].join('|'),
+
+    typeKeywords: dataTypeFamiliesCaseSensitive,
+    typeKeywordsDouble: getCaseInsensitiveRegExp(
+        manyWordsPatterns(dataTypeFamiliesCaseInsensitive),
+    ),
+    constants,
+
+    builtinFunctions: functionsCaseSensitive,
+
+    tableFunctions,
+    tableEngines,
+
+    operators: [
+        '+',
+        '-',
+        '/',
+        '//',
+        '%',
+        '<@>',
+        '@>',
+        '<@',
+        '&',
+        '^',
+        '~',
+        '<',
+        '>',
+        '<=',
+        '=>',
+        '==',
+        '!=',
+        '<>',
+        '=',
+    ],
+
+    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'},
+            // variables
+            [/[$@:](@variables)/, 'variable'],
+            [/{(@variables)}/, 'variable'],
+            [/[?;,.]/, 'delimiter'],
+            [/[(){}[\]]/, '@brackets'],
+            // identifiers and keywords
+            [/@keywordsDouble/, 'keyword'],
+            [/@typeKeywordsDouble/, 'keyword.type'],
+            [
+                /[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'},
+                        '@default': 'identifier',
+                    },
+                },
+            ],
+            [
+                /@symbols/,
+                {
+                    cases: {
+                        '@operators': 'operator.sql',
+                        '@default': '',
+                    },
+                },
+            ],
+        ],
+        whitespace: [[/\s+/, 'white']],
+        comments: [
+            [/--+.*/, 'comment'],
+            [/```/, {token: 'comment.quote', next: '@comment'}],
+            [/\/\*/, {token: 'comment.quote', next: '@cppComment'}],
+        ],
+        comment: [
+            [/[^`]+/, 'comment'],
+            [/```/, {token: 'comment.quote', next: '@pop'}],
+            [/./, 'comment'],
+        ],
+        cppComment: [
+            [/[^*/]+/, 'comment'],
+            [/\*\//, {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'}],
+        ],
+        stringSingle: [
+            [/[^\\']/, 'string'],
+            [/@escapes/, 'string.escape'],
+            [/\\./, 'string.escape.invalid'],
+            [/'/, {token: 'string', next: '@pop'}],
+        ],
+        stringDouble: [
+            [/[^\\"]/, 'string.tablepath'],
+            [/@escapes/, 'string.tablepath'],
+            [/\\./, 'string.tablepath'],
+            [/"/, {token: 'string.tablepath', next: '@pop'}],
+        ],
+        stringBacktick: [
+            [/[^\\`]/, 'string.tablepath'],
+            [/@escapes/, 'string.tablepath'],
+            [/\\./, 'string.tablepath'],
+            [/`/, {token: 'string.tablepath', next: '@pop'}],
+        ],
+    },
+};
+
+function caseInsensitiveRegExp(pattern: string) {
+    return pattern
+        .split('')
+        .map((char) => {
+            if (/[a-zA-Z]/.test(char)) {
+                return `[${char.toLowerCase()}${char.toUpperCase()}]`;
+            }
+            return char;
+        })
+        .join('');
+}
+
+function getCaseInsensitiveRegExp(patterns: string[]) {
+    return `(${patterns.map((pattern) => caseInsensitiveRegExp(pattern).replace(/\s+/g, '\\s')).join('|')})`;
+}
+
+function oneWordPatterns(patterns: string[]) {
+    return patterns.filter((pattern) => /^\S*$/.test(pattern));
+}
+
+function manyWordsPatterns(patterns: string[]) {
+    return patterns.filter((pattern) => /\s/.test(pattern)).sort((a, b) => b.localeCompare(a));
+}

package/src/completion.ts

@@ -0,0 +1,124 @@
+import type {
+    CancellationToken,
+    IRange,
+    Position,
+    editor,
+    languages,
+} from './fillers/monaco-editor-core';
+
+export type CompletionListProvider = {
+    (content: string, offset: number, signal?: AbortSignal | null): Promise<string[]>;
+};
+
+const allUpperCaseRe = new RegExp('^[$A-Z_\\s]+$');
+
+export function provideCompletionItems(getCompletionList: CompletionListProvider) {
+    return (
+        model: editor.ITextModel,
+        position: Position,
+        context: languages.CompletionContext,
+        token: CancellationToken,
+    ): languages.ProviderResult<languages.CompletionList> => {
+        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: string[]) => {
+                const suggestions: languages.CompletionItem[] = [];
+                for (const label of data) {
+                    const suggest =
+                        label.length > 1
+                            ? label.slice(0, -1).replace(/[/[]/g, '\\\\$&') + label.slice(-1)
+                            : label;
+                    let range: IRange | undefined;
+                    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 type CompletionLists = Partial<
+    Record<`${Uncapitalize<keyof typeof languages.CompletionItemKind>}List`, Readonly<string[]>>
+>;
+
+export function getCompletionItemsProvider(
+    completions: CompletionLists,
+    completionItemKind: typeof languages.CompletionItemKind,
+) {
+    const suggestions: languages.CompletionItem[] = [];
+
+    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 as keyof CompletionLists] as string[]) {
+                    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: editor.ITextModel,
+            position: Position,
+            _context: languages.CompletionContext,
+            _token: CancellationToken,
+        ): languages.CompletionList | undefined {
+            const word = model.getWordUntilPosition(position);
+            const range = {
+                startLineNumber: position.lineNumber,
+                startColumn: word.startColumn,
+                endLineNumber: position.lineNumber,
+                endColumn: word.endColumn,
+            };
+
+            return {suggestions: suggestions.map((s) => ({...s, range}))};
+        },
+    };
+}

package/src/fillers/monaco-editor-core.ts

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

package/src/monaco.contribution.ts

@@ -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/src/s-expressions/s-expressions.contribution.ts

@@ -0,0 +1,9 @@
+import {registerLanguage} from '../_.contribution';
+
+export const LANGUAGE_ID = 's-expression';
+
+registerLanguage({
+    id: LANGUAGE_ID,
+    extensions: [],
+    loader: () => import('./s-expressions'),
+});

package/src/s-expressions/s-expressions.keywords.ts

@@ -0,0 +1,14 @@
+export const keywordControl =
+    'bind|block|declare|export|import|lambda|let|override_library|package|quote|return|set_package_version'.split(
+        '|',
+    );
+
+export const keywordOperator =
+    'Abs|Add|AddMember|AddMemberType|AddTimezone|AggrAdd|AggrConcat|AggrCountInit|AggrCountUpdate|AggrEquals|AggrGreater|AggrGreaterOrEqual|AggrLess|AggrLessOrEqual|AggrMax|AggrMin|AggrNotEquals|Aggregate|AggregationTraits|AlterTo|And|Append|Apply|AsDict|AsDictStrict|AsEnum|AsList|AsListStrict|AsSet|AsSetStrict|AsStruct|AsTagged|AsVariant|Ascending|AssumeSorted|AssumeStrict|AssumeUnique|AtomCode|AuthTokens|BitAnd|BitCast|BitNot|BitOr|BitXor|Bool|ByteAt|CalcOverWindow|Callable|CallableArgument|CallableArgumentType|CallableResultType|CallableType|CallableTypeComponents|CallableTypeHandle|Cast|CastStruct|Chain1Map|Chopper|Coalesce|Collect|CombineByKey|CombineCore|CommonJoinCore|Concat|Condense|Condense1|ConstraintsOf|Contains|Convert|CountBits|CurrentAuthenticatedUser|CurrentOperationId|CurrentOperationSharedId|CurrentTzDate|CurrentTzDatetime|CurrentTzTimestamp|CurrentUtcDate|CurrentUtcDatetime|CurrentUtcTimestamp|Data|DataSink|DataSource|DataType|DataTypeComponents|DataTypeHandle|Date|Datetime|Dec|Decimal|Default|DependsOn|Descending|Dict|DictFromKeys|DictItems|DictKeyType|DictKeys|DictPayloadType|DictPayloads|DictType|DictTypeComponents|DictTypeHandle|Discard|Div|DivePrefixMembers|Double|EmptyDictType|EmptyDictTypeHandle|EmptyIterator|EmptyListType|EmptyListTypeHandle|EndsWith|Ensure|EnsureConvertibleTo|EnsureType|Enum|Enumerate|Equals|EquiJoin|Error|ErrorType|EvaluateCode|EvaluateType|Exists|ExpandMap|Extend|Extract|ExtractMembers|FileContent|FilePath|Files|Filter|FilterNullElements|FilterNullMembers|Find|FlatListIf|FlatMap|FlatOptionalIf|FlattenByColumns|FlattenMembers|FlattenMembersType|Float|Fold|Fold1|Fold1Map|FoldMap|ForceRemoveMember|ForceRemoveMemberType|FormatCode|FormatCodeWithPositions|FormatType|ForwardList|FromBytes|FromString|FromYsonSimpleType|FuncCode|GenericType|Greater|GreaterOrEqual|GroupByKey|GroupingCore|Guess|HasItems|Head|HoppingCore|If|IfPresent|IfStrict|IfType|Inc|Insert|InstanceOf|Int16|Int32|Int64|Int8|Interval|IsKeySwitch|Iterator|Join|Json|Just|KeepTop|Key|LMap|Lag|LambdaArgumentsCount|LambdaCode|LambdaOptionalArgumentsCount|Last|Lead|Length|Less|LessOrEqual|Likely|Limit|List|ListCode|ListFromRange|ListIf|ListItemType|ListType|ListTypeHandle|Lookup|Map|MapJoinCore|MatchType|Max|Member|Merge|Min|Minus|Mod|Mul|MultiAggregate|MultiHoppingCore|MultiMap|NamedApply|NarrowFlatMap|NarrowMap|NarrowMultiMap|NewMTRand|NextMTRand|Not|NotEquals|Nothing|Now|Nth|Null|NullType|NullTypeHandle|Nvl|Optional|OptionalIf|OptionalItemType|OptionalReduce|OptionalType|OptionalTypeHandle|Or|OrderedExtend|OrderedExtract|OrderedFilter|OrderedFlatMap|OrderedMap|OrderedMultiMap|Parameter|ParseType|ParseTypeHandle|PartitionByKey|PartitionsByKeys|Pickle|Plus|Prepend|PreserveStream|QueueCreate|QueuePeek|QueuePop|QueuePush|QuoteCode|RFind|Random|RandomNumber|RandomUuid|RemoveMember|RemoveMemberType|RemoveTimezone|ReplaceMember|Replicate|ReprCode|ResourceType|ResourceTypeHandle|ResourceTypeTag|Reverse|RotLeft|RotRight|RowNumber|SafeCast|ScriptUdf|SelectMembers|SerializeCode|ShiftLeft|ShiftRight|Size|Skip|SkipNullElements|SkipNullMembers|SkipWhile|SkipWhileInclusive|Sort|SortTraits|SourceOf|SqlAccess|SqlColumn|StablePickle|StartsWith|StaticFold|StaticFold1|StaticMap|StaticZip|StreamItemType|StreamType|StreamTypeHandle|StrictCast|StrictFromString|String|Struct|StructMemberType|StructType|StructTypeComponents|StructTypeHandle|Sub|Substring|Switch|TableName|TablePath|TableRecord|TaggedType|TaggedTypeComponents|TaggedTypeHandle|Take|TakeWhile|TakeWhileInclusive|Timestamp|ToBytes|ToDict|ToIndexDict|ToIntegral|ToList|ToOptional|ToSequence|ToStream|ToString|Top|TopSort|TryMember|TryWeakMemberFromDict|Tuple|TupleElementType|TupleType|TupleTypeComponents|TupleTypeHandle|TypeHandle|TypeKind|TypeOf|TzDate|TzDatetime|TzTimestamp|Udf|Uint16|Uint32|Uint64|Uint8|UnionAll|UnionMerge|UnitType|Unordered|Unpickle|Untag|Unwrap|Utf8|Uuid|Variant|VariantItem|VariantType|VariantTypeHandle|VariantUnderlyingType|Visit|Void|VoidType|VoidTypeHandle|Way|WideChain1Map|WideChopper|WideCombiner|WideCondense1|WideFilter|WideMap|WideSkipWhile|WideSkipWhileInclusive|WideTakeWhile|WideTakeWhileInclusive|WinOnGroups|WinOnRange|WinOnRows|WindowTraits|WithOptionalArgs|WorldCode|Xor|Yson|Zip|ZipAll'.split(
+        '|',
+    );
+
+export const variables =
+    'Commit!|CommitAll!|ConfRead!|Configure!|Epoch|If!|Left!|MrConfigure!|MrCopy!|MrDrop!|MrEquiJoin!|MrFill!|MrIsKeySwitch|MrLMap!|MrLReduce!|MrLength|MrMap!|MrMapReduce!|MrMove!|MrOrderedReduce!|MrPublish!|MrReadTable!|MrReadTableScheme!|MrReduce!|MrSort!|MrTableContent|MrTableIndex|MrTablePath|MrTableRange!|MrTableRecord|MrTempTable|MrWrite!|Read!|ResFill!|ResIf!|ResPull!|ResWrite!|Right!|RtCreateTable!|RtDropTable!|RtInSection|RtMap!|RtMeta|RtOutSection|RtOutTable|RtOutput!|RtReadTable!|RtReadTableScheme!|RtReduce!|RtRowSpec|RtTable|RtWriteTable!|RtYdbOut!|StatFields|StatMeta|StatPublish!|StatTable|StatWriteTable!|Sync!|Write!|YqlRowSpec|YtConfigure!|YtCopy!|YtDropTable!|YtEquiJoin!|YtFill!|YtIsKeySwitch|YtKeyExact|YtKeyRange|YtLength|YtMap!|YtMapReduce!|YtMerge!|YtMeta|YtOutTable|YtOutput!|YtPath|YtPublish!|YtReadTable!|YtReadTableScheme!|YtReduce!|YtRow|YtRowRange|YtSection|YtSort!|YtStat|YtStatOut!|YtStatOutTable|YtTable|YtTableContent|YtTableIndex|YtTablePath|YtTableRecord|YtTouch!|YtWriteTable!'.split(
+        '|',
+    );

package/src/s-expressions/s-expressions.ts

@@ -0,0 +1,91 @@
+import {languages} from '../fillers/monaco-editor-core';
+
+import {keywordControl, keywordOperator, variables} from './s-expressions.keywords';
+
+export const LANGUAGE_ID = 's-expressions';
+
+export const conf: languages.LanguageConfiguration = {
+    comments: {
+        lineComment: '#',
+    },
+    brackets: [
+        ['{', '}'],
+        ['[', ']'],
+        ['(', ')'],
+    ],
+    autoClosingPairs: [
+        {open: '{', close: '}'},
+        {open: '[', close: ']'},
+        {open: '(', close: ')'},
+    ],
+    surroundingPairs: [
+        {open: '{', close: '}'},
+        {open: '[', close: ']'},
+        {open: '(', close: ')'},
+    ],
+};
+
+export const language: languages.IMonarchLanguage & Record<string, unknown> = {
+    defaultToken: 'text',
+    ignoreCase: true,
+    tokenPostfix: '.yql',
+
+    brackets: [
+        {open: '[', close: ']', token: 'delimiter.square'},
+        {open: '(', close: ')', token: 'delimiter.parenthesis'},
+        {open: '{', close: '}', token: 'delimiter.curly'},
+    ],
+
+    keywordControl,
+
+    keywordOperator,
+
+    variables,
+
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+
+    tokenizer: {
+        root: [
+            {include: '@whitespace'},
+            {include: '@comment'},
+            [/(#)((?:\w|[\\+-=<>'"&#])+)/, ['delimiter', 'constant']],
+            [
+                /(?:\b(?:(defun|defmethod|defmacro))\b)(\s+)((?:\w|-|\?)*)/,
+                ['type.function', 'text', 'entity.name'],
+            ],
+            [/(\*)(\S*)(\*)/, ['delimiter', 'variable', 'delimiter']],
+            {include: '@strings'},
+            [/'[^#\s)(]+/, 'variable.parameter'],
+            [/[(){}[\]]/, '@brackets'],
+            // identifiers and keywords
+            [
+                /(?:(?:<=?|>=?|==|!=|[-+*/%])|[a-zA-Z][a-zA-Z0-9!]*)/,
+                {
+                    cases: {
+                        '@keywordControl': {token: 'keyword.operator'},
+                        '@keywordOperator': {token: 'keyword.control'},
+                        '@variables': {token: 'variable'},
+                        '@default': 'identifier',
+                    },
+                },
+            ],
+        ],
+        whitespace: [[/\s+/, 'white']],
+        comment: [[/#.*/, 'comment']],
+        strings: [
+            [/'?"(?=.)/, {token: 'string', next: '@qqstring'}],
+            [/'?[@]{2}/, {token: 'string', next: '@multiline'}],
+            [/'?x"(?:[0-9A-Fa-f]{2})*"/, 'string'],
+        ],
+        qqstring: [
+            [/\\(?:[0-3][0-7][0-7]|x[0-9A-Fa-f]{2}|["tnrbfav\\])/, 'string.escape'],
+            [/[^"\\]+/, 'string'],
+            [/"|$/, {token: 'string', next: '@pop'}],
+        ],
+        multiline: [
+            [/[^@]+/, 'string'],
+            [/[@]{2}/, {token: 'string', next: '@pop'}],
+            [/./, {token: 'string'}],
+        ],
+    },
+};

package/src/themes/themes.contribution.ts

@@ -0,0 +1,49 @@
+import * as monaco from '../fillers/monaco-editor-core';
+
+monaco.editor.defineTheme('vs', {
+    base: 'vs',
+    inherit: true,
+    rules: [
+        // Path to table
+        {token: 'string.tablepath', foreground: '338186'},
+        // Constants true
+        {token: 'constant.yql', foreground: '608b4e'},
+        // Data types JSON, Int32 etc
+        {token: 'keyword.type', foreground: '4d932d'},
+        // Strings
+        {token: 'string.sql', foreground: 'a31515'},
+        // UDF
+        {token: 'support.function', foreground: '7a3e9d'},
+        // Builtin functions COUNT(
+        {token: 'constant.other.color', foreground: '7a3e9d'},
+        // Comments
+        {token: 'comment', foreground: '969896'},
+    ],
+    colors: {
+        'editor.lineHighlightBackground': '#EFEFEF',
+    },
+});
+
+monaco.editor.defineTheme('vs-dark', {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [
+        // Path to table
+        {token: 'string.tablepath', foreground: '338186'},
+        // Constants true
+        {token: 'constant.yql', foreground: '608b4e'},
+        // Data types JSON, Int32 etc
+        {token: 'storage.type', foreground: '6A8759'},
+        // Strings
+        {token: 'string.sql', foreground: 'ce9178'},
+        // UDF
+        {token: 'support.function', foreground: '9e7bb0'},
+        // Builtin functions COUNT(
+        {token: 'constant.other.color', foreground: '9e7bb0'},
+        // Comments
+        {token: 'comment', foreground: '969896'},
+    ],
+    colors: {
+        'editor.lineHighlightBackground': '#282A2E',
+    },
+});

package/src/yql/yql.contribution.ts

@@ -0,0 +1,15 @@
+import {registerLanguage} from '../_.contribution';
+
+export const LANGUAGE_ID = 'yql';
+
+registerLanguage({
+    id: LANGUAGE_ID,
+    extensions: [],
+    loader: () =>
+        import('./yql').then((module) => {
+            return {
+                conf: module.conf,
+                language: module.getLanguage(),
+            };
+        }),
+});

package/src/yql/yql.keywords.ts

@@ -0,0 +1,13 @@
+export const keywords =
+    '$row|$rows|action|add|all|alter|and|any|as|asc|assume|async|bigserial|serial|smallserial|serial8|serial4|serial2|begin|bernoulli|between|by|case|changefeed|column|columns|commit|compact|create|cross|cube|declare|define|delete|desc|dict|discard|distinct|do|drop|else|empty_action|end|erase|evaluate|exclusion|exists|export|family|flatten|for|from|full|global|group|grouping|having|if|ignore|ilike|import|in|index|inner|insert|into|is|join|key|left|like|limit|list|match|not|null|nulls|offset|on|only|optional|or|order|over|partition|pragma|presort|primary|process|reduce|regexp|repeatable|replace|respect|result|return|right|rlike|rollup|sample|schema|select|semi|set|sets|stream|subquery|sync|table|tablesample|then|truncate|union|intersect|except|update|upsert|use|using|values|view|when|where|window|with|without|xor|callable|resource|tagged|generic|unit|void|emptylist|emptydict|flow|callable|resource|tagged|generic|unit|void|emptylist|emptydict|flow'.split(
+        '|',
+    );
+export const typeKeywords =
+    'bool|date|datetime|decimal|double|float|int16|int32|int64|int8|interval|json|jsondocument|string|timestamp|tzdate|tzdatetime|tztimestamp|uint16|uint32|uint64|uint8|utf8|uuid|yson|text|bytes'.split(
+        '|',
+    );
+
+export const builtinFunctions =
+    'abs|aggregate_by|aggregate_list|aggregate_list_distinct|agg_list|agg_list_distinct|as_table|avg|avg_if|adaptivedistancehistogram|adaptivewardhistogram|adaptiveweighthistogram|addmember|addtimezone|aggregateflatten|aggregatetransforminput|aggregatetransformoutput|aggregationfactory|asatom|asdict|asdictstrict|asenum|aslist|asliststrict|asset|assetstrict|asstruct|astagged|astuple|asvariant|atomcode|bitcast|bit_and|bit_or|bit_xor|bool_and|bool_or|bool_xor|bottom|bottom_by|blockwardhistogram|blockweighthistogram|cast|coalesce|concat|concat_strict|correlation|count|count_if|covariance|covariance_population|covariance_sample|callableargument|callableargumenttype|callableresulttype|callabletype|callabletypecomponents|callabletypehandle|choosemembers|combinemembers|countdistinctestimate|currentauthenticateduser|currentoperationid|currentoperationsharedid|currenttzdate|currenttzdatetime|currenttztimestamp|currentutcdate|currentutcdatetime|currentutctimestamp|dense_rank|datatype|datatypecomponents|datatypehandle|dictaggregate|dictcontains|dictcreate|dicthasitems|dictitems|dictkeytype|dictkeys|dictlength|dictlookup|dictpayloadtype|dictpayloads|dicttype|dicttypecomponents|dicttypehandle|each|each_strict|emptydicttype|emptydicttypehandle|emptylisttype|emptylisttypehandle|endswith|ensure|ensureconvertibleto|ensuretype|enum|evaluateatom|evaluatecode|evaluateexpr|evaluatetype|expandstruct|filter|filter_strict|find|first_value|folder|filecontent|filepath|flattenmembers|forceremovemember|forceremovemembers|forcerenamemembers|forcespreadmembers|formatcode|formattype|frombytes|frompg|funccode|greatest|grouping|gathermembers|generictype|histogram|hll|hoppingwindowpgcast|hyperloglog|if|if_strict|instanceof|json_exists|json_query|json_value|jointablerow|just|lag|last_value|lead|least|len|length|like|likely|like_strict|lambdaargumentscount|lambdacode|lambdaoptionalargumentscount|linearhistogram|listaggregate|listall|listany|listavg|listcode|listcollect|listconcat|listcreate|listdistinct|listenumerate|listextend|listextendstrict|listextract|listfilter|listflatmap|listflatten|listfold|listfold1|listfold1map|listfoldmap|listfromrange|listfromtuple|listhas|listhasitems|listhead|listindexof|listitemtype|listlast|listlength|listmap|listmax|listmin|listnotnull|listreplicate|listreverse|listskip|listskipwhile|listskipwhileinclusive|listsort|listsortasc|listsortdesc|listsum|listtake|listtakewhile|listtakewhileinclusive|listtotuple|listtype|listtypehandle|listunionall|listuniq|listzip|listzipall|loghistogram|logarithmichistogram|max|max_by|max_of|median|min|min_by|min_of|mode|multi_aggregate_by|nanvl|nvl|nothing|nulltype|nulltypehandle|optionalitemtype|optionaltype|optionaltypehandle|percentile|parsefile|parsetype|parsetypehandle|pgand|pgarray|pgcall|pgconst|pgnot|pgop|pgor|pickle|quotecode|range|range_strict|rank|regexp|regexp_strict|rfind|row_number|random|randomnumber|randomuuid|removemember|removemembers|removetimezone|renamemembers|replacemember|reprcode|resourcetype|resourcetypehandle|resourcetypetag|some|stddev|stddev_population|stddev_sample|substring|sum|sum_if|sessionstart|sessionwindow|setcreate|setdifference|setincludes|setintersection|setisdisjoint|setsymmetricdifference|setunion|spreadmembers|stablepickle|startswith|staticmap|staticzip|streamitemtype|streamtype|streamtypehandle|structmembertype|structmembers|structtypecomponents|structtypehandle|subqueryextend|subqueryextendfor|subquerymerge|subquerymergefor|subqueryunionall|subqueryunionallfor|subqueryunionmerge|subqueryunionmergefor|top|topfreq|top_by|tablename|tablepath|tablerecordindex|tablerow|tablerows|taggedtype|taggedtypecomponents|taggedtypehandle|tobytes|todict|tomultidict|topg|toset|tosorteddict|tosortedmultidict|trymember|tupleelementtype|tupletype|tupletypecomponents|tupletypehandle|typehandle|typekind|typeof|udaf|udf|unittype|unpickle|untag|unwrap|variance|variance_population|variance_sample|variant|varianttype|varianttypehandle|variantunderlyingtype|voidtype|voidtypehandle|way|worldcode|weakfield'.split(
+        '|',
+    );