@arcgis/coding-components 4.31.0-next.0 → 4.31.0-next.2

package/dist/esm/{arcade-defaults-ef553659.js → arcade-defaults-9eb28407.js}

@@ -1,9 +1,9 @@
 /*!
  * All material copyright Esri, All Rights Reserved, unless otherwise specified.
  * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.0
+ * v4.31.0-next.2
  */
-import { g as getAssetPath } from './index-7be467d0.js';
+import { g as getAssetPath } from './index-a970952c.js';
 
 /**
  * Returns the last element of an array.
@@ -6101,6 +6101,7 @@ const uiMap = new KeyCodeStrMap();
 const userSettingsUSMap = new KeyCodeStrMap();
 const userSettingsGeneralMap = new KeyCodeStrMap();
 const EVENT_KEY_CODE_MAP = new Array(230);
+const NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE = {};
 const scanCodeIntToStr = [];
 const scanCodeStrToInt = Object.create(null);
 const scanCodeLowerCaseStrToInt = Object.create(null);
@@ -6389,6 +6390,9 @@ for (let i = 0; i <= 132 /* KeyCode.MAX_VALUE */; i++) {
         if (eventKeyCode) {
             EVENT_KEY_CODE_MAP[eventKeyCode] = keyCode;
         }
+        if (vkey) {
+            NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[vkey] = keyCode;
+        }
     }
     // Manually added due to the exclusion above (due to duplication with NumpadEnter)
     IMMUTABLE_KEY_CODE_TO_CODE[3 /* KeyCode.Enter */] = 46 /* ScanCode.Enter */;
@@ -21850,6 +21854,7 @@ CharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS = '\'"`;
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 const hasBuffer = (typeof Buffer !== 'undefined');
+new Lazy(() => new Uint8Array(256));
 let textDecoder;
 class VSBuffer {
     /**
@@ -22760,6 +22765,12 @@ Registry.add(Extensions$7.JSONContribution, jsonContributionRegistry);
 const Extensions$6 = {
     Configuration: 'base.contributions.configuration'
 };
+const allSettings = { properties: {}, patternProperties: {} };
+const applicationSettings = { properties: {}, patternProperties: {} };
+const machineSettings = { properties: {}, patternProperties: {} };
+const machineOverridableSettings = { properties: {}, patternProperties: {} };
+const windowSettings = { properties: {}, patternProperties: {} };
+const resourceSettings = { properties: {}, patternProperties: {} };
 const resourceLanguageSettingsSchemaId = 'vscode://schemas/settings/resourceLanguage';
 const contributionRegistry = Registry.as(Extensions$7.JSONContribution);
 class ConfigurationRegistry {
@@ -22932,18 +22943,25 @@ class ConfigurationRegistry {
         register(configuration);
     }
     updateSchema(key, property) {
+        allSettings.properties[key] = property;
         switch (property.scope) {
             case 1 /* ConfigurationScope.APPLICATION */:
+                applicationSettings.properties[key] = property;
                 break;
             case 2 /* ConfigurationScope.MACHINE */:
+                machineSettings.properties[key] = property;
                 break;
             case 6 /* ConfigurationScope.MACHINE_OVERRIDABLE */:
+                machineOverridableSettings.properties[key] = property;
                 break;
             case 3 /* ConfigurationScope.WINDOW */:
+                windowSettings.properties[key] = property;
                 break;
             case 4 /* ConfigurationScope.RESOURCE */:
+                resourceSettings.properties[key] = property;
                 break;
             case 5 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */:
+                resourceSettings.properties[key] = property;
                 this.resourceLanguageSettingsSchema.properties[key] = property;
                 break;
         }
@@ -22958,15 +22976,27 @@ class ConfigurationRegistry {
                 $ref: resourceLanguageSettingsSchemaId,
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
+            allSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+            applicationSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+            machineSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+            machineOverridableSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+            windowSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
+            resourceSettings.properties[overrideIdentifierProperty] = resourceLanguagePropertiesSchema;
         }
     }
     registerOverridePropertyPatternKey() {
-        ({
+        const resourceLanguagePropertiesSchema = {
             type: 'object',
             description: localize('overrideSettings.defaultDescription', "Configure editor settings to be overridden for a language."),
             errorMessage: localize('overrideSettings.errorMessage', "This setting does not support per-language configuration."),
             $ref: resourceLanguageSettingsSchemaId,
-        });
+        };
+        allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
+        applicationSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
+        machineSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
+        machineOverridableSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
+        windowSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
+        resourceSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
         this._onDidSchemaChange.fire();
     }
     updatePropertyDefaultValue(key, property) {
@@ -60172,6 +60202,34 @@ class ExtUri {
  * ```
  */
 const extUri = new ExtUri(() => false);
+/**
+ * BIASED utility that _mostly_ ignored the case of urs paths. ONLY use this util if you
+ * understand what you are doing.
+ *
+ * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.
+ *
+ * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient
+ * because those uris come from a "trustworthy source". When creating unknown uris it's always
+ * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path
+ * casing matters.
+ */
+new ExtUri(uri => {
+    // A file scheme resource is in the same platform as code, so ignore case for non linux platforms
+    // Resource can be from another platform. Lowering the case as an hack. Should come from File system provider
+    return uri.scheme === Schemas.file ? !isLinux : true;
+});
+/**
+ * BIASED utility that always ignores the casing of uris paths. ONLY use this util if you
+ * understand what you are doing.
+ *
+ * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.
+ *
+ * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient
+ * because those uris come from a "trustworthy source". When creating unknown uris it's always
+ * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path
+ * casing matters.
+ */
+new ExtUri(_ => true);
 const isEqual = extUri.isEqual.bind(extUri);
 extUri.isEqualOrParent.bind(extUri);
 extUri.getComparisonKey.bind(extUri);
@@ -105014,6 +105072,20 @@ const intlFileNameCollatorBaseNumeric = new Lazy(() => {
         collatorIsNumeric: collator.resolvedOptions().numeric
     };
 });
+// A collator with numeric sorting enabled.
+new Lazy(() => {
+    const collator = new Intl.Collator(undefined, { numeric: true });
+    return {
+        collator
+    };
+});
+// A collator with numeric sorting enabled, and sensitivity to accents and diacritics but not case.
+new Lazy(() => {
+    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'accent' });
+    return {
+        collator
+    };
+});
 /** Compares filenames without distinguishing the name from the extension. Disambiguates by unicode comparison. */
 function compareFileNames(one, other, caseSensitive = false) {
     const a = one || '';
@@ -120522,7 +120594,7 @@ registerLanguage({
   mimetypes: ["text/css"],
   loader: () => {
     {
-      return import('./css-34fa13c1.js');
+      return import('./css-e257dc49.js');
     }
   }
 });
@@ -120540,7 +120612,7 @@ registerLanguage({
   mimetypes: ["text/html", "text/x-jshtm", "text/template", "text/ng-template"],
   loader: () => {
     {
-      return import('./html-c2757f30.js');
+      return import('./html-a6c37a99.js');
     }
   }
 });
@@ -120560,7 +120632,7 @@ registerLanguage({
   mimetypes: ["text/javascript"],
   loader: () => {
     {
-      return import('./javascript-7cb6a2cd.js');
+      return import('./javascript-ee179624.js');
     }
   }
 });
@@ -120578,7 +120650,7 @@ registerLanguage({
   mimetypes: ["text/typescript"],
   loader: () => {
     {
-      return import('./typescript-a359e263.js');
+      return import('./typescript-a3cf9881.js');
     }
   }
 });
@@ -120697,19 +120769,19 @@ var cssDefaults = new LanguageServiceDefaultsImpl$3("css", optionsDefault$1, mod
 var scssDefaults = new LanguageServiceDefaultsImpl$3("scss", optionsDefault$1, modeConfigurationDefault$2);
 var lessDefaults = new LanguageServiceDefaultsImpl$3("less", optionsDefault$1, modeConfigurationDefault$2);
 monaco_editor_core_exports$3.languages.css = { cssDefaults, lessDefaults, scssDefaults };
-function getMode$3() {
+function getMode$4() {
   {
-    return import('./cssMode-8758c994.js');
+    return import('./cssMode-c11f7f40.js');
   }
 }
 monaco_editor_core_exports$3.languages.onLanguage("less", () => {
-  getMode$3().then((mode) => mode.setupMode(lessDefaults));
+  getMode$4().then((mode) => mode.setupMode(lessDefaults));
 });
 monaco_editor_core_exports$3.languages.onLanguage("scss", () => {
-  getMode$3().then((mode) => mode.setupMode(scssDefaults));
+  getMode$4().then((mode) => mode.setupMode(scssDefaults));
 });
 monaco_editor_core_exports$3.languages.onLanguage("css", () => {
-  getMode$3().then((mode) => mode.setupMode(cssDefaults));
+  getMode$4().then((mode) => mode.setupMode(cssDefaults));
 });
 
 /*!-----------------------------------------------------------------------------
@@ -120822,16 +120894,16 @@ monaco_editor_core_exports$2.languages.html = {
   razorLanguageService,
   registerHTMLLanguageService
 };
-function getMode$2() {
+function getMode$3() {
   {
-    return import('./htmlMode-64bfdd08.js');
+    return import('./htmlMode-1270bc7d.js');
   }
 }
 function registerHTMLLanguageService(languageId, options = optionsDefault, modeConfiguration = getConfigurationDefault(languageId)) {
   const defaults = new LanguageServiceDefaultsImpl$2(languageId, options, modeConfiguration);
   let mode;
   const onLanguageListener = monaco_editor_core_exports$2.languages.onLanguage(languageId, async () => {
-    mode = (await getMode$2()).setupMode(defaults);
+    mode = (await getMode$3()).setupMode(defaults);
   });
   return {
     defaults,
@@ -120924,9 +120996,9 @@ var modeConfigurationDefault$1 = {
 };
 var jsonDefaults = new LanguageServiceDefaultsImpl$1("json", diagnosticDefault, modeConfigurationDefault$1);
 monaco_editor_core_exports$1.languages.json = { jsonDefaults };
-function getMode$1() {
+function getMode$2() {
   {
-    return import('./jsonMode-728cfcab.js');
+    return import('./jsonMode-07502ccb.js');
   }
 }
 monaco_editor_core_exports$1.languages.register({
@@ -120936,7 +121008,7 @@ monaco_editor_core_exports$1.languages.register({
   mimetypes: ["application/json"]
 });
 monaco_editor_core_exports$1.languages.onLanguage("json", () => {
-  getMode$1().then((mode) => mode.setupMode(jsonDefaults));
+  getMode$2().then((mode) => mode.setupMode(jsonDefaults));
 });
 
 /*!-----------------------------------------------------------------------------
@@ -121176,10 +121248,10 @@ var modeConfigurationDefault = {
 var typescriptDefaults = new LanguageServiceDefaultsImpl({ allowNonTsExtensions: true, target: 99 /* Latest */ }, { noSemanticValidation: false, noSyntaxValidation: false, onlyVisible: false }, {}, {}, modeConfigurationDefault);
 var javascriptDefaults = new LanguageServiceDefaultsImpl({ allowNonTsExtensions: true, allowJs: true, target: 99 /* Latest */ }, { noSemanticValidation: true, noSyntaxValidation: false, onlyVisible: false }, {}, {}, modeConfigurationDefault);
 var getTypeScriptWorker = () => {
-  return getMode().then((mode) => mode.getTypeScriptWorker());
+  return getMode$1().then((mode) => mode.getTypeScriptWorker());
 };
 var getJavaScriptWorker = () => {
-  return getMode().then((mode) => mode.getJavaScriptWorker());
+  return getMode$1().then((mode) => mode.getJavaScriptWorker());
 };
 monaco_editor_core_exports.languages.typescript = {
   ModuleKind,
@@ -121193,16 +121265,16 @@ monaco_editor_core_exports.languages.typescript = {
   getTypeScriptWorker,
   getJavaScriptWorker
 };
-function getMode() {
+function getMode$1() {
   {
-    return import('./tsMode-f3c09a15.js');
+    return import('./tsMode-96749a12.js');
   }
 }
 monaco_editor_core_exports.languages.onLanguage("typescript", () => {
-  return getMode().then((mode) => mode.setupTypeScript(typescriptDefaults));
+  return getMode$1().then((mode) => mode.setupTypeScript(typescriptDefaults));
 });
 monaco_editor_core_exports.languages.onLanguage("javascript", () => {
-  return getMode().then((mode) => mode.setupJavaScript(javascriptDefaults));
+  return getMode$1().then((mode) => mode.setupJavaScript(javascriptDefaults));
 });
 
 /*---------------------------------------------------------------------------------------------
@@ -166644,21 +166716,13 @@ registerEditorAction(ToggleHighContrast);
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire();
-		}
-	}, fn(module, module.exports), module.exports;
+function commonjsRequire (path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
 
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
+var main = {exports: {}};
 
-var main = createCommonjsModule(function (module, exports) {
+(function (module, exports) {
 (function (factory) {
     {
         var v = factory(commonjsRequire, exports);
@@ -168923,7 +168987,7 @@ var main = createCommonjsModule(function (module, exports) {
         Is.typedArray = typedArray;
     })(Is || (Is = {}));
 });
-});
+}(main, main.exports));
 
 // src/index.ts
 var isAMD = typeof window !== "undefined" && "$arcgis" in window && typeof window.$arcgis === "object" && "import" in window.$arcgis;
@@ -169208,16 +169272,18 @@ function observeAncestorsMutation(element, attributeFilter, callback) {
   const { subscribe } = observe(attributeFilter);
   return subscribe((mutations) => {
     const matched = mutations.some((mutation) => inTargetElement(element, mutation.target));
-    if (matched)
+    if (matched) {
       callback();
+    }
   });
 }
 var observers = {};
 function observe(attributeFilter) {
   const attributes = attributeFilter.join(",");
   const previousObserver = observers[attributes];
-  if (previousObserver !== void 0)
+  if (previousObserver !== void 0) {
     return previousObserver;
+  }
   const subscribers = /* @__PURE__ */ new Set();
   const mutationObserver = new MutationObserver((mutations) => subscribers.forEach((callback) => callback(mutations)));
   mutationObserver.observe(document.documentElement, {
@@ -169404,14 +169470,16 @@ async function fetchBundle(locale, path) {
   const filePath = `${path}${locale}.json`;
   try {
     const response = await fetch(filePath);
-    if (response.ok)
+    if (response.ok) {
       return await response.json();
+    }
   } catch (error) {
     console.error(error);
     return fallbackBundle;
   }
-  if (locale === defaultLocale)
+  if (locale === defaultLocale) {
     return fallbackBundle;
+  }
   return await fetchBundle(defaultLocale, path);
 }
 var fallbackBundle = new Proxy(
@@ -169431,8 +169499,9 @@ function getElementLocales(element) {
 function startLocaleObserver(element, assetsPath, onUpdated, assetName) {
   let result = void 0;
   const callback = () => void updateComponentLocateState(element, assetsPath, assetName).then((newResult) => {
-    if (result?.lang !== newResult.lang || result.t9nLocale !== newResult.t9nLocale || result.t9nStrings !== newResult.t9nStrings)
+    if (result?.lang !== newResult.lang || result.t9nLocale !== newResult.t9nLocale || result.t9nStrings !== newResult.t9nStrings) {
       onUpdated(newResult);
+    }
     result = newResult;
   }).catch(console.error);
   callback();
@@ -169733,7 +169802,7 @@ function getMapPortalItem(map) {
 }
 //#endregion
 //#region Editor Profile to Language Service Profile functions
-async function variablesToLSVariable(editorVariables, kind = main.CompletionItemKind.Variable) {
+async function variablesToLSVariable(editorVariables, kind = main.exports.CompletionItemKind.Variable) {
     return await Promise.all(editorVariables.map(async (editorVariable) => {
         switch (editorVariable.type) {
             case "dictionary":
@@ -169756,8 +169825,8 @@ function variableToLSVariable(editorVariable, kind) {
             label: name,
             detail: name,
             insertText: name,
-            insertTextMode: main.InsertTextMode.asIs,
-            insertTextFormat: main.InsertTextFormat.PlainText,
+            insertTextMode: main.exports.InsertTextMode.asIs,
+            insertTextFormat: main.exports.InsertTextFormat.PlainText,
             kind,
             documentation: { kind: "markdown", value: description },
         },
@@ -169772,8 +169841,8 @@ async function featureToLSFeature(editorFeature, kind) {
         label: name,
         detail: name,
         insertText: name,
-        insertTextMode: main.InsertTextMode.asIs,
-        insertTextFormat: main.InsertTextFormat.PlainText,
+        insertTextMode: main.exports.InsertTextMode.asIs,
+        insertTextFormat: main.exports.InsertTextFormat.PlainText,
         kind,
     };
     const result = {
@@ -169816,9 +169885,9 @@ async function featureToLSFeature(editorFeature, kind) {
                 label: field.name,
                 detail: description,
                 insertText,
-                insertTextMode: main.InsertTextMode.asIs,
-                insertTextFormat: main.InsertTextFormat.PlainText,
-                kind: main.CompletionItemKind.Field,
+                insertTextMode: main.exports.InsertTextMode.asIs,
+                insertTextFormat: main.exports.InsertTextFormat.PlainText,
+                kind: main.exports.CompletionItemKind.Field,
                 documentation: { kind: "markdown", value: fieldCompletionDescription },
             },
         });
@@ -169838,9 +169907,9 @@ async function featureToLSFeature(editorFeature, kind) {
                 label: field.alias,
                 detail: field.name,
                 insertText,
-                insertTextMode: main.InsertTextMode.asIs,
-                insertTextFormat: main.InsertTextFormat.PlainText,
-                kind: main.CompletionItemKind.Field,
+                insertTextMode: main.exports.InsertTextMode.asIs,
+                insertTextFormat: main.exports.InsertTextFormat.PlainText,
+                kind: main.exports.CompletionItemKind.Field,
                 documentation: { kind: "markdown", value: aliasCompletionDescription },
             },
         });
@@ -169867,13 +169936,13 @@ async function dictionaryToLSDictionary(editorDictionary, kind) {
         name,
         description,
         type: "dictionary",
-        properties: await variablesToLSVariable(variables, main.CompletionItemKind.Field),
+        properties: await variablesToLSVariable(variables, main.exports.CompletionItemKind.Field),
         completion: {
             label: name,
             detail: name,
             insertText: name,
-            insertTextMode: main.InsertTextMode.asIs,
-            insertTextFormat: main.InsertTextFormat.PlainText,
+            insertTextMode: main.exports.InsertTextMode.asIs,
+            insertTextFormat: main.exports.InsertTextFormat.PlainText,
             kind,
             documentation: { kind: "markdown", value: completionDescription },
         },
@@ -170947,32 +171016,58 @@ async function convertToEditorProfileDefinition(predefinedProfile, locale = "en"
     return editorProfile;
 }
 
-const arcadeLanguageId = "arcade";
+/**
+ * Returns the arcade diagnostic service.
+ * Example:
+ * ```ts
+ * const diagnosticService = await getArcadeDiagnosticService();
+ * diagnosticService.onDidChangeDiagnostics(({uri, diaganostics }) => {
+ *  // Filter the diagnostics for the uri of interest
+ *  // Do something with the diagnostics
+ * });
+ * ```
+ */
+async function getArcadeDiagnosticService() {
+    const mode = await getMode();
+    return mode.getArcadeDiagnosticService();
+}
+/**
+ * Returns the arcade worker for the model.
+ * Example:
+ * ```ts
+ * const arcadeWorker = await getArcadeWorker(model.uri);
+ * ```
+ * @returns arcade worker
+ */
+async function getArcadeWorker(uri) {
+    const mode = await getMode();
+    return await mode.getArcadeWorker(uri);
+}
+/**
+ * Request the arcade mode
+ * @returns arcade mode module
+ */
+async function getMode() {
+    return await import('./arcade-mode-5d46035e.js');
+}
+
+// this file contains the building blocks for a language default provider
 const defaultContext = {
     locale: "en",
 };
-class ArcadeLanguageServiceDefaults {
+class LanguageDefaultsBase {
     constructor() {
-        this._languageId = arcadeLanguageId;
-        this._languageOptions = {};
+        // #endregion
+        // #region Protected properties
         this._onDidChange = new Emitter();
         this._profileMap = new Map();
         this._apiContextMap = new Map();
         this._onModelContextDidChange = new Emitter();
         this._onDidModelContextChangeTimeout = -1;
+        // #endregion
     }
-    get onDidChange() {
-        return this._onDidChange.event;
-    }
-    get onModelContextDidChange() {
-        return this._onModelContextDidChange.event;
-    }
-    get languageId() {
-        return this._languageId;
-    }
-    get languageOptions() {
-        return this._languageOptions;
-    }
+    // #endregion
+    // #region Protected methods
     _fireModelContextDidChange(key) {
         if (this._onDidModelContextChangeTimeout !== -1) {
             return;
@@ -170988,35 +171083,13 @@ class ArcadeLanguageServiceDefaults {
         }
         return modelId.toString();
     }
-    /**
-     * Create an EditorProfile for the given model id using the given definition and locale.
-     * The EditorProfile is used by the the Arcade Language service as well by the cosing components.
-     * The definition can be a pre-defined profile or an editor profile definition.
-     * If the locale is not provided then the 'en' locale is used.
-     * @param modelId The model id for which to create the context.
-     * @param definition The definition to use for the model context.
-     * @param locale The locale to use for the model context.
-     * @returns The EditorProfile for the model.
-     */
-    async setProfileForModel(modelId, definition, apiContext = { locale: "en" }) {
-        // Convert pre-defined profile to a runtime profile
-        if (isPredefinedProfile(definition)) {
-            definition = await convertToEditorProfileDefinition(definition, apiContext.locale);
-        }
-        const intlStrings = await fetchT9NStringsBundle(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
-        if (!intlStrings) {
-            throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
-        }
-        this.disposeEditorProfileForModel(modelId);
-        const key = this._getApiKey(modelId);
-        const editorProfile = new EditorProfile(definition, intlStrings);
-        this._profileMap.set(key, editorProfile);
-        const apiProfile = await editorProfile.toLSProfile();
-        this.updateApiContextForModel(modelId, {
-            locale: apiContext.locale,
-            profile: apiProfile,
-            snippets: apiContext.snippets,
-        });
+    // #endregion
+    // #region Public methods
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    get languageOptions() {
+        return this._languageOptions;
     }
     /**
      * Dispose the editor profile for the given model id.
@@ -171065,6 +171138,51 @@ class ArcadeLanguageServiceDefaults {
         this._apiContextMap.set(key, { ...currentApiContext, ...apiContext });
         this._fireModelContextDidChange(key);
     }
+    get onModelContextDidChange() {
+        return this._onModelContextDidChange.event;
+    }
+    get languageId() {
+        return this._languageId;
+    }
+}
+
+const arcadeLanguageId = "arcade";
+class ArcadeLanguageServiceDefaults extends LanguageDefaultsBase {
+    constructor() {
+        super(...arguments);
+        this._languageId = arcadeLanguageId;
+        this._languageOptions = {};
+    }
+    /**
+     * Create an EditorProfile for the given model id using the given definition and locale.
+     * The EditorProfile is used by the the Arcade Language service as well by the cosing components.
+     * The definition can be a pre-defined profile or an editor profile definition.
+     * If the locale is not provided then the 'en' locale is used.
+     * @param modelId The model id for which to create the context.
+     * @param definition The definition to use for the model context.
+     * @param locale The locale to use for the model context.
+     * @returns The EditorProfile for the model.
+     */
+    async setProfileForModel(modelId, definition, apiContext = { locale: "en" }) {
+        // Convert pre-defined profile to a runtime profile
+        if (isPredefinedProfile(definition)) {
+            definition = await convertToEditorProfileDefinition(definition, apiContext.locale);
+        }
+        const intlStrings = await fetchT9NStringsBundle(apiContext.locale, getAssetPath("./assets/arcade-language/t9n"), "profile.t9n.");
+        if (!intlStrings) {
+            throw new Error(`Failed to load the language bundle for ${apiContext.locale}`);
+        }
+        this.disposeEditorProfileForModel(modelId);
+        const key = this._getApiKey(modelId);
+        const editorProfile = new EditorProfile(definition, intlStrings);
+        this._profileMap.set(key, editorProfile);
+        const apiProfile = await editorProfile.toLSProfile();
+        this.updateApiContextForModel(modelId, {
+            locale: apiContext.locale,
+            profile: apiProfile,
+            snippets: apiContext.snippets,
+        });
+    }
     /**
      * Set or update the Arcade language service options.
      * @param languageOptions The language options to set.
@@ -171079,10 +171197,20 @@ class ArcadeLanguageServiceDefaults {
         this._languageOptions = { ...this._languageOptions, ...languageOptions };
         this._onDidChange.fire(this);
     }
+    /**
+     * Gets the API library for the given model id.
+     * @param modelId The model id for which to get the API library.
+     * @returns The API library for the model.
+     */
+    async getApiLibrary(modelId) {
+        const uri = Uri.parse(modelId);
+        const worker = await getArcadeWorker(uri);
+        return await worker.getApiLibrary(this.getApiContextForModel(uri));
+    }
 }
 const arcadeDefaults = new ArcadeLanguageServiceDefaults();
 const arcade = {
     setProfileForModel: arcadeDefaults.setProfileForModel.bind(arcadeDefaults),
 };
 
-export { observeAncestorsMutation as A, KeyMod as B, monaco_editor_core_star as C, Deferred as D, typescriptDefaults as E, main as F, debounce as G, Emitter as H, IStandaloneThemeService as I, KeyCode as K, MarkerSeverity as M, Range as R, StandaloneServices as S, Uri as U, arcade as a, commonjsGlobal as b, createCommonjsModule as c, camelToKebab as d, editor as e, safeAsyncCall as f, generateTokensCSSForColorMap as g, devToolsAwareTimeout as h, startLocaleObserver as i, getElementLocales as j, isURL as k, hasSameOrigin as l, importRequest as m, languages as n, arcadeDefaults as o, setFocusOnElement as p, filterCollection as q, addLTRMark as r, safeCall as s, importArcade as t, generateGuid as u, getElementTheme as v, setValuesInString as w, quoteString as x, supportedFields as y, createFilterExpression as z };
+export { observeAncestorsMutation as A, KeyMod as B, addLTRMark as C, Deferred as D, monaco_editor_core_star as E, typescriptDefaults as F, main as G, debounce as H, IStandaloneThemeService as I, Emitter as J, KeyCode as K, MarkerSeverity as M, Range as R, StandaloneServices as S, Uri as U, arcade as a, safeAsyncCall as b, camelToKebab as c, devToolsAwareTimeout as d, editor as e, startLocaleObserver as f, getElementLocales as g, isURL as h, importArcade as i, hasSameOrigin as j, importRequest as k, generateGuid as l, arcadeDefaults as m, getElementTheme as n, getArcadeDiagnosticService as o, setValuesInString as p, quoteString as q, supportedFields as r, safeCall as s, generateTokensCSSForColorMap as t, commonjsGlobal as u, setFocusOnElement as v, filterCollection as w, createFilterExpression as x, languages as y, getMode as z };