@kusto/monaco-kusto 12.0.1 → 12.0.3

package/release/esm/kustoMode.js

@@ -48,104 +48,101 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { WorkerManager } from './workerManager';
 import * as languageFeatures from './languageFeatures';
+import { kustoLanguageDefinition } from './syntaxHighlighting/kustoMonarchLanguageDefinition';
 import { LANGUAGE_ID } from './globals';
 import { semanticTokensProviderRegistrarCreator } from './syntaxHighlighting/semanticTokensProviderRegistrar';
-import { kustoLanguageDefinition } from './syntaxHighlighting/kustoMonarchLanguageDefinition';
-var workerAccessor;
+var kustoWorker;
+var resolveWorker;
+var rejectWorker;
+var workerPromise = new Promise(function (resolve, reject) {
+    resolveWorker = resolve;
+    rejectWorker = reject;
+});
+/**
+ * Called when Kusto language is first needed (a model has the language set)
+ * @param defaults
+ */
 export function setupMode(defaults, monacoInstance) {
-    return __awaiter(this, void 0, void 0, function () {
-        var onSchemaChange, client, semanticTokensProviderRegistrar, completionAdapter, documentRangeFormattingAdapter, foldingRangeAdapter, definitionProvider, referenceProvider, hoverAdapter, documentFormattingAdapter, languageConfiguration;
-        var _this = this;
-        return __generator(this, function (_a) {
-            onSchemaChange = new monaco.Emitter();
-            client = new WorkerManager(monacoInstance, defaults);
-            semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator();
-            workerAccessor = function (uri) { return __awaiter(_this, void 0, void 0, function () {
-                var worker, augmentedSetSchema, setSchemaFromShowSchema;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, client.getLanguageServiceWorker(uri)];
-                        case 1:
-                            worker = _a.sent();
-                            augmentedSetSchema = function (schema) { return __awaiter(_this, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, worker.setSchema(schema)];
-                                        case 1:
-                                            _a.sent();
-                                            onSchemaChange.fire(schema);
-                                            semanticTokensProviderRegistrar(monacoInstance, worker);
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); };
-                            setSchemaFromShowSchema = function (schema, clusterConnectionString, databaseInContextName, globalScalarParameters, globalTabularParameters) { return __awaiter(_this, void 0, void 0, function () {
-                                var normalizedSchema;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, worker.normalizeSchema(schema, clusterConnectionString, databaseInContextName)];
-                                        case 1:
-                                            normalizedSchema = _a.sent();
-                                            normalizedSchema.globalScalarParameters = globalScalarParameters;
-                                            normalizedSchema.globalTabularParameters = globalTabularParameters;
-                                            return [4 /*yield*/, augmentedSetSchema(normalizedSchema)];
-                                        case 2:
-                                            _a.sent();
-                                            return [2 /*return*/];
+    var _this = this;
+    var onSchemaChange = new monaco.Emitter();
+    // TODO: when should we dispose of these? seems like monaco-css and monaco-typescript don't dispose of these.
+    var disposables = [];
+    var semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator();
+    var client = new WorkerManager(monacoInstance, defaults);
+    disposables.push(client);
+    var workerAccessor = function (first) {
+        var more = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            more[_i - 1] = arguments[_i];
+        }
+        var augmentedSetSchema = function (schema, worker) { return __awaiter(_this, void 0, void 0, function () {
+            var workerPromise;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        workerPromise = worker.setSchema(schema);
+                        return [4 /*yield*/, workerPromise.then(function () {
+                                onSchemaChange.fire(schema);
+                            })];
+                    case 1:
+                        _a.sent();
+                        semanticTokensProviderRegistrar(monacoInstance, workerAccessor);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        var worker = client.getLanguageServiceWorker.apply(client, [first].concat(more));
+        return worker.then(function (worker) { return (__assign(__assign({}, worker), { setSchema: function (schema) { return augmentedSetSchema(schema, worker); }, setSchemaFromShowSchema: function (schema, connection, database, globalScalarParameters, globalTabularParameters) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, worker.normalizeSchema(schema, connection, database).then(function (schema) {
+                                    if (globalScalarParameters || globalTabularParameters) {
+                                        schema = __assign(__assign({}, schema), { globalScalarParameters: globalScalarParameters, globalTabularParameters: globalTabularParameters });
                                     }
-                                });
-                            }); };
-                            return [2 /*return*/, __assign(__assign({}, worker), { setSchema: augmentedSetSchema, setSchemaFromShowSchema: setSchemaFromShowSchema })];
-                    }
+                                    augmentedSetSchema(schema, worker);
+                                })];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
                 });
-            }); };
-            monacoInstance.languages.setMonarchTokensProvider(LANGUAGE_ID, kustoLanguageDefinition);
-            completionAdapter = new languageFeatures.CompletionAdapter(workerAccessor, defaults.languageSettings);
-            monacoInstance.languages.registerCompletionItemProvider(LANGUAGE_ID, completionAdapter);
-            // this constructor has side effects and therefore doesn't need to be passed anywhere
-            new languageFeatures.DiagnosticsAdapter(monacoInstance, LANGUAGE_ID, workerAccessor, defaults, onSchemaChange.event);
-            documentRangeFormattingAdapter = new languageFeatures.FormatAdapter(workerAccessor);
-            monacoInstance.languages.registerDocumentRangeFormattingEditProvider(LANGUAGE_ID, documentRangeFormattingAdapter);
-            foldingRangeAdapter = new languageFeatures.FoldingAdapter(workerAccessor);
-            monacoInstance.languages.registerFoldingRangeProvider(LANGUAGE_ID, foldingRangeAdapter);
-            definitionProvider = new languageFeatures.DefinitionAdapter(workerAccessor);
-            monacoInstance.languages.registerDefinitionProvider(LANGUAGE_ID, definitionProvider);
-            monacoInstance.languages.registerRenameProvider(LANGUAGE_ID, new languageFeatures.RenameAdapter(workerAccessor));
-            referenceProvider = new languageFeatures.ReferenceAdapter(workerAccessor);
-            monacoInstance.languages.registerReferenceProvider(LANGUAGE_ID, referenceProvider);
-            if (defaults.languageSettings.enableHover) {
-                hoverAdapter = new languageFeatures.HoverAdapter(workerAccessor);
-                monacoInstance.languages.registerHoverProvider(LANGUAGE_ID, hoverAdapter);
-            }
-            documentFormattingAdapter = new languageFeatures.DocumentFormatAdapter(workerAccessor);
-            monacoInstance.languages.registerDocumentFormattingEditProvider(LANGUAGE_ID, documentFormattingAdapter);
-            languageConfiguration = {
-                folding: {
-                    offSide: false,
-                    markers: { start: /^\s*[\r\n]/gm, end: /^\s*[\r\n]/gm },
-                },
-                comments: {
-                    lineComment: '//',
-                    blockComment: null,
-                },
-                autoClosingPairs: [
-                    { open: '{', close: '}' },
-                    { open: '[', close: ']' },
-                    { open: '(', close: ')' },
-                    { open: "'", close: "'", notIn: ['string', 'comment'] },
-                    { open: '"', close: '"', notIn: ['string', 'comment'] },
-                ],
-            };
-            monacoInstance.languages.setLanguageConfiguration(LANGUAGE_ID, languageConfiguration);
-            return [2 /*return*/, workerAccessor];
-        });
+            } })); });
+    };
+    disposables.push(monacoInstance.languages.registerCompletionItemProvider(LANGUAGE_ID, new languageFeatures.CompletionAdapter(workerAccessor, defaults.languageSettings)));
+    var monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(LANGUAGE_ID, kustoLanguageDefinition);
+    disposables.push(new languageFeatures.DiagnosticsAdapter(monacoInstance, LANGUAGE_ID, workerAccessor, defaults, onSchemaChange.event));
+    disposables.push(monacoInstance.languages.registerDocumentRangeFormattingEditProvider(LANGUAGE_ID, new languageFeatures.FormatAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerFoldingRangeProvider(LANGUAGE_ID, new languageFeatures.FoldingAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerDefinitionProvider(LANGUAGE_ID, new languageFeatures.DefinitionAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerRenameProvider(LANGUAGE_ID, new languageFeatures.RenameAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerReferenceProvider(LANGUAGE_ID, new languageFeatures.ReferenceAdapter(workerAccessor)));
+    if (defaults.languageSettings.enableHover) {
+        disposables.push(monacoInstance.languages.registerHoverProvider(LANGUAGE_ID, new languageFeatures.HoverAdapter(workerAccessor)));
+    }
+    monacoInstance.languages.registerDocumentFormattingEditProvider(LANGUAGE_ID, new languageFeatures.DocumentFormatAdapter(workerAccessor));
+    kustoWorker = workerAccessor;
+    resolveWorker(workerAccessor);
+    monacoInstance.languages.setLanguageConfiguration(LANGUAGE_ID, {
+        folding: {
+            offSide: false,
+            markers: { start: /^\s*[\r\n]/gm, end: /^\s*[\r\n]/gm },
+        },
+        comments: {
+            lineComment: '//',
+            blockComment: null,
+        },
+        autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'", notIn: ['string', 'comment'] },
+            { open: '"', close: '"', notIn: ['string', 'comment'] },
+        ],
     });
+    return kustoWorker;
 }
 export function getKustoWorker() {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, workerAccessor];
-        });
-    });
+    return workerPromise.then(function () { return kustoWorker; });
 }

package/release/esm/languageFeatures.d.ts

@@ -13,7 +13,7 @@ export declare class DiagnosticsAdapter {
     private _schemaListener;
     private _cursorListener;
     private _debouncedValidations;
-    constructor(_monacoInstance: typeof monaco, _languageId: string, _worker: AugmentedWorkerAccessor, defaults: LanguageServiceDefaults, onSchemaChange: monaco.IEvent<Schema>);
+    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: AugmentedWorkerAccessor, defaults: LanguageServiceDefaults, onSchemaChange: monaco.IEvent<Schema>);
     private getMonacoCodeActions;
     private getOrCreateDebouncedValidation;
     dispose(): void;

package/release/esm/languageServiceManager/schema.d.ts

@@ -62,8 +62,8 @@ export interface EngineSchema {
         readonly databases: readonly Database[];
     };
     readonly database: Database | undefined;
-    globalScalarParameters?: readonly ScalarParameter[];
-    globalTabularParameters?: readonly TabularParameter[];
+    readonly globalScalarParameters?: readonly ScalarParameter[];
+    readonly globalTabularParameters?: readonly TabularParameter[];
 }
 export type TableEntityType = 'Table' | 'ExternalTable' | 'MaterializedViewTable';
 export interface ClusterMangerSchema {

package/release/esm/monaco.contribution.js

@@ -1,64 +1,17 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-import * as mode from './kustoMode';
 import KustoCommandHighlighter from './commandHighlighter';
 import KustoCommandFormatter from './commandFormatter';
 import { extend } from './extendedEditor';
 import { themes } from './syntaxHighlighting/themes';
 import { LANGUAGE_ID } from './globals';
-import * as schema from './languageServiceManager/schema';
+import { getCslTypeNameFromClrType, getCallName, getExpression, getInputParametersAsCslString, getEntityDataTypeFromCslType, } from './languageServiceManager/schema';
 import { getRangeHtml } from './extendedGlobalApi';
 export * from './languageServiceManager/schema';
 export * from './languageServiceManager/renderInfo';
 export * from './languageServiceManager/settings';
 export * from './types';
 export * from './extendedGlobalApi';
+// --- Kusto configuration and defaults ---------
 var LanguageServiceDefaultsImpl = /** @class */ (function () {
     function LanguageServiceDefaultsImpl(languageSettings) {
         this._onDidChange = new monaco.Emitter();
@@ -119,15 +72,18 @@ var defaultLanguageSettings = {
     completionOptions: { includeExtendedSyntax: false },
 };
 export function getKustoWorker() {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, mode.getKustoWorker()];
+    return new Promise(function (resolve, reject) {
+        withMode(function (mode) {
+            mode.getKustoWorker().then(resolve, reject);
         });
     });
 }
+function withMode(callback) {
+    import('./kustoMode').then(callback);
+}
 export var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-monaco.languages.onLanguage(LANGUAGE_ID, function () {
-    mode.setupMode(kustoDefaults, monaco);
+monaco.languages.onLanguage('kusto', function () {
+    withMode(function (mode) { return mode.setupMode(kustoDefaults, monaco); });
 });
 monaco.languages.register({
     id: LANGUAGE_ID,
@@ -179,5 +135,14 @@ function triggerSuggestDialogWhenCompletionItemSelected(editor) {
 function isStandaloneCodeEditor(editor) {
     return editor.addAction !== undefined;
 }
-var globalApi = __assign(__assign({}, schema), { kustoDefaults: kustoDefaults, getKustoWorker: getKustoWorker, getRangeHtml: getRangeHtml });
+var globalApi = {
+    getCslTypeNameFromClrType: getCslTypeNameFromClrType,
+    getCallName: getCallName,
+    getExpression: getExpression,
+    getInputParametersAsCslString: getInputParametersAsCslString,
+    getEntityDataTypeFromCslType: getEntityDataTypeFromCslType,
+    kustoDefaults: kustoDefaults,
+    getKustoWorker: getKustoWorker,
+    getRangeHtml: getRangeHtml,
+};
 monaco.languages.kusto = globalApi;

package/release/esm/{schema-b8f0ba9b.js → schema-d4e431c7.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 12.0.1(56b90ce0fd31e7d6792f5098d1e8204274966b6e)
+ * monaco-kusto version: 12.0.3(418f3d71791a9e0959cc8869c01ea6d9b94b3179)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -81,14 +81,4 @@ const getInputParameterAsCslString = inputParameter => {
  */
 let showSchema;
 
-const schema = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-    __proto__: null,
-    getCallName,
-    getCslTypeNameFromClrType,
-    getEntityDataTypeFromCslType,
-    getExpression,
-    getInputParametersAsCslString,
-    showSchema
-}, Symbol.toStringTag, { value: 'Module' }));
-
-export { getEntityDataTypeFromCslType as a, getCallName as b, getExpression as c, getInputParametersAsCslString as d, showSchema as e, getCslTypeNameFromClrType as g, schema as s };
+export { getCallName as a, getExpression as b, getInputParametersAsCslString as c, getEntityDataTypeFromCslType as d, getCslTypeNameFromClrType as g, showSchema as s };

package/release/esm/syntaxHighlighting/SemanticTokensProvider.d.ts

@@ -1,7 +1,7 @@
 import type * as monaco from 'monaco-editor';
 import { editor } from 'monaco-editor';
 import { ClassificationRange } from './types';
-type ClassificationsGetter = (uri: string) => Promise<ClassificationRange[]>;
+type ClassificationsGetter = (resource: monaco.Uri) => Promise<ClassificationRange[]>;
 export declare class SemanticTokensProvider implements monaco.languages.DocumentSemanticTokensProvider {
     private readonly classificationsGetter;
     constructor(classificationsGetter: ClassificationsGetter);

package/release/esm/syntaxHighlighting/SemanticTokensProvider.js

@@ -44,12 +44,12 @@ var SemanticTokensProvider = /** @class */ (function () {
     };
     SemanticTokensProvider.prototype.provideDocumentSemanticTokens = function (model) {
         return __awaiter(this, void 0, void 0, function () {
-            var uri, classifications, semanticTokens;
+            var resource, classifications, semanticTokens;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        uri = model.uri.toString();
-                        return [4 /*yield*/, this.classificationsGetter(uri)];
+                        resource = model.uri;
+                        return [4 /*yield*/, this.classificationsGetter(resource)];
                     case 1:
                         classifications = _a.sent();
                         semanticTokens = classifications.map(function (classification, index) {

package/release/esm/syntaxHighlighting/semanticTokensProviderRegistrar.d.ts

@@ -1,6 +1,6 @@
 import monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { SemanticTokensProvider } from './SemanticTokensProvider';
-import { IKustoWorkerImpl } from '../kustoWorker';
+import { AugmentedWorkerAccessor } from '../kustoMode';
 export type SemanticTokensProviderRegistrar = (monacoInstance: typeof monaco, semanticTokensProvider: SemanticTokensProvider) => void;
-export declare function semanticTokensProviderRegistrarCreator(): (monacoInstance: typeof monaco, worker: IKustoWorkerImpl) => void;
+export declare function semanticTokensProviderRegistrarCreator(): (monacoInstance: typeof monaco, workerAccessor: AugmentedWorkerAccessor) => void;
 export declare function semanticTokensProviderRegistrarCreatorForTest(): (monacoInstance: typeof monaco, semanticTokensProvider: SemanticTokensProvider) => void;

package/release/esm/syntaxHighlighting/semanticTokensProviderRegistrar.js

@@ -1,11 +1,47 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { LANGUAGE_ID } from '../globals';
 import { SemanticTokensProvider } from './SemanticTokensProvider';
 // Registers semantic token provider that utilizes the language service
 // for more context-relevant syntax highlighting.
 export function semanticTokensProviderRegistrarCreator() {
     var semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreatorForTest();
-    return function (monacoInstance, worker) {
-        var semanticTokensProvider = semanticTokensProviderMaker(worker);
+    return function (monacoInstance, workerAccessor) {
+        var semanticTokensProvider = semanticTokensProviderMaker(workerAccessor);
         semanticTokensProviderRegistrar(monacoInstance, semanticTokensProvider);
     };
 }
@@ -18,6 +54,18 @@ export function semanticTokensProviderRegistrarCreatorForTest() {
         semanticTokensDisposable = monacoInstance.languages.registerDocumentSemanticTokensProvider(LANGUAGE_ID, semanticTokensProvider);
     };
 }
-function semanticTokensProviderMaker(worker) {
-    return new SemanticTokensProvider(worker.getClassifications);
+function semanticTokensProviderMaker(workerAccessor) {
+    var _this = this;
+    var classificationsGetter = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+        var worker;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, workerAccessor(resource)];
+                case 1:
+                    worker = _a.sent();
+                    return [2 /*return*/, worker.getClassifications(resource.toString())];
+            }
+        });
+    }); };
+    return new SemanticTokensProvider(classificationsGetter);
 }