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

package/dist/cjs/{arcade-defaults-a8d8f8e2.js → language-defaults-base-57b37f9f.js}

@@ -1,12 +1,10 @@
 /*!
  * 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.2
+ * v4.31.0-next.21
  */
 'use strict';
 
-const index = require('./index-b34238a6.js');
-
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
     var n = Object.create(null);
@@ -120616,7 +120614,7 @@ registerLanguage({
   mimetypes: ["text/css"],
   loader: () => {
     {
-      return Promise.resolve().then(function () { return require('./css-7cc05f76.js'); });
+      return Promise.resolve().then(function () { return require('./css-bb6a49ec.js'); });
     }
   }
 });
@@ -120634,7 +120632,7 @@ registerLanguage({
   mimetypes: ["text/html", "text/x-jshtm", "text/template", "text/ng-template"],
   loader: () => {
     {
-      return Promise.resolve().then(function () { return require('./html-f56911e1.js'); });
+      return Promise.resolve().then(function () { return require('./html-7ff4071d.js'); });
     }
   }
 });
@@ -120654,7 +120652,7 @@ registerLanguage({
   mimetypes: ["text/javascript"],
   loader: () => {
     {
-      return Promise.resolve().then(function () { return require('./javascript-5115cb76.js'); });
+      return Promise.resolve().then(function () { return require('./javascript-864c0220.js'); });
     }
   }
 });
@@ -120672,7 +120670,7 @@ registerLanguage({
   mimetypes: ["text/typescript"],
   loader: () => {
     {
-      return Promise.resolve().then(function () { return require('./typescript-b395242f.js'); });
+      return Promise.resolve().then(function () { return require('./typescript-6c87ddb3.js'); });
     }
   }
 });
@@ -120791,19 +120789,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$4() {
+function getMode$3() {
   {
-    return Promise.resolve().then(function () { return require('./cssMode-2b0daeae.js'); });
+    return Promise.resolve().then(function () { return require('./cssMode-e7fac7d7.js'); });
   }
 }
 monaco_editor_core_exports$3.languages.onLanguage("less", () => {
-  getMode$4().then((mode) => mode.setupMode(lessDefaults));
+  getMode$3().then((mode) => mode.setupMode(lessDefaults));
 });
 monaco_editor_core_exports$3.languages.onLanguage("scss", () => {
-  getMode$4().then((mode) => mode.setupMode(scssDefaults));
+  getMode$3().then((mode) => mode.setupMode(scssDefaults));
 });
 monaco_editor_core_exports$3.languages.onLanguage("css", () => {
-  getMode$4().then((mode) => mode.setupMode(cssDefaults));
+  getMode$3().then((mode) => mode.setupMode(cssDefaults));
 });
 
 /*!-----------------------------------------------------------------------------
@@ -120916,16 +120914,16 @@ monaco_editor_core_exports$2.languages.html = {
   razorLanguageService,
   registerHTMLLanguageService
 };
-function getMode$3() {
+function getMode$2() {
   {
-    return Promise.resolve().then(function () { return require('./htmlMode-43eed674.js'); });
+    return Promise.resolve().then(function () { return require('./htmlMode-c89193ec.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$3()).setupMode(defaults);
+    mode = (await getMode$2()).setupMode(defaults);
   });
   return {
     defaults,
@@ -121018,9 +121016,9 @@ var modeConfigurationDefault$1 = {
 };
 var jsonDefaults = new LanguageServiceDefaultsImpl$1("json", diagnosticDefault, modeConfigurationDefault$1);
 monaco_editor_core_exports$1.languages.json = { jsonDefaults };
-function getMode$2() {
+function getMode$1() {
   {
-    return Promise.resolve().then(function () { return require('./jsonMode-550dda36.js'); });
+    return Promise.resolve().then(function () { return require('./jsonMode-ac4a7be7.js'); });
   }
 }
 monaco_editor_core_exports$1.languages.register({
@@ -121030,7 +121028,7 @@ monaco_editor_core_exports$1.languages.register({
   mimetypes: ["application/json"]
 });
 monaco_editor_core_exports$1.languages.onLanguage("json", () => {
-  getMode$2().then((mode) => mode.setupMode(jsonDefaults));
+  getMode$1().then((mode) => mode.setupMode(jsonDefaults));
 });
 
 /*!-----------------------------------------------------------------------------
@@ -121270,10 +121268,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$1().then((mode) => mode.getTypeScriptWorker());
+  return getMode().then((mode) => mode.getTypeScriptWorker());
 };
 var getJavaScriptWorker = () => {
-  return getMode$1().then((mode) => mode.getJavaScriptWorker());
+  return getMode().then((mode) => mode.getJavaScriptWorker());
 };
 monaco_editor_core_exports.languages.typescript = {
   ModuleKind,
@@ -121287,16 +121285,16 @@ monaco_editor_core_exports.languages.typescript = {
   getTypeScriptWorker,
   getJavaScriptWorker
 };
-function getMode$1() {
+function getMode() {
   {
-    return Promise.resolve().then(function () { return require('./tsMode-336306a9.js'); });
+    return Promise.resolve().then(function () { return require('./tsMode-d30d4ab1.js'); });
   }
 }
 monaco_editor_core_exports.languages.onLanguage("typescript", () => {
-  return getMode$1().then((mode) => mode.setupTypeScript(typescriptDefaults));
+  return getMode().then((mode) => mode.setupTypeScript(typescriptDefaults));
 });
 monaco_editor_core_exports.languages.onLanguage("javascript", () => {
-  return getMode$1().then((mode) => mode.setupJavaScript(javascriptDefaults));
+  return getMode().then((mode) => mode.setupJavaScript(javascriptDefaults));
 });
 
 /*---------------------------------------------------------------------------------------------
@@ -166736,6 +166734,760 @@ class ToggleHighContrast extends EditorAction {
 }
 registerEditorAction(ToggleHighContrast);
 
+// src/index.ts
+var isAMD = typeof window !== "undefined" && "$arcgis" in window && typeof window.$arcgis === "object" && "import" in window.$arcgis && !("forceESM" in window.$arcgis);
+function isDefaultModule(module) {
+  return module.default !== void 0;
+}
+async function importLayersFeatureLayer() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/layers/FeatureLayer");
+  }
+  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/layers/FeatureLayer.js')); });
+  return isDefaultModule(module) ? module.default : module;
+}
+async function newLayersFeatureLayer(properties) {
+  const ModConstructor = await importLayersFeatureLayer();
+  return new ModConstructor(properties);
+}
+async function importPortalPortalItem() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/portal/PortalItem");
+  }
+  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/portal/PortalItem.js')); });
+  return isDefaultModule(module) ? module.default : module;
+}
+async function newPortalPortalItem(properties) {
+  const ModConstructor = await importPortalPortalItem();
+  return new ModConstructor(properties);
+}
+async function importWebMap() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/WebMap");
+  }
+  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/WebMap.js')); });
+  return isDefaultModule(module) ? module.default : module;
+}
+async function newWebMap(properties) {
+  const ModConstructor = await importWebMap();
+  return new ModConstructor(properties);
+}
+async function importWebScene() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/WebScene");
+  }
+  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/WebScene.js')); });
+  return isDefaultModule(module) ? module.default : module;
+}
+async function newWebScene(properties) {
+  const ModConstructor = await importWebScene();
+  return new ModConstructor(properties);
+}
+async function importArcade() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/arcade");
+  }
+  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/arcade.js')); });
+  return isDefaultModule(module) ? module.default : module;
+}
+async function importRequest() {
+  if (isAMD) {
+    return await window.$arcgis.import("esri/request");
+  }
+  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/request.js')); });
+  return isDefaultModule(module) ? module.default : module;
+}
+
+//#region Type Guards
+function isFeatureLayerLikeInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        typeof item.declaredClass === "string" &&
+        item.declaredClass.startsWith("esri.layers.") &&
+        isFieldsDefinition(item) &&
+        "queryFeatures" in item &&
+        typeof item.queryFeatures === "function");
+}
+function isGroupLayerCapable(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "allLayers" in item &&
+        "allTables" in item &&
+        typeof item.allLayers === "object" &&
+        typeof item.allTables === "object");
+}
+function isMapInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        typeof item.declaredClass === "string" &&
+        (item.declaredClass === "esri.Map" ||
+            item.declaredClass === "esri.WebMap" ||
+            item.declaredClass === "esri.WebScene"));
+}
+function isLoadAllCapable(item) {
+    return !!item && typeof item === "object" && "loadAll" in item && typeof item.loadAll === "function";
+}
+function isPortalItemDefinition(item) {
+    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
+}
+function isFeatureLayerItemDefinition(item) {
+    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
+}
+function isFieldsDefinition(item) {
+    return !!item && typeof item === "object" && "fields" in item && Array.isArray(item.fields);
+}
+function isUrlDefinition(item) {
+    return !!item && typeof item === "object" && "url" in item && typeof item.url === "string";
+}
+function isSupportedServiceUrlDefinition(item) {
+    return isUrlDefinition(item) && /\/(?:featureserver|mapserver)(?:\/|$)/iu.test(item.url);
+}
+function isFeatureDefinition(item) {
+    return isUrlDefinition(item) || isFieldsDefinition(item) || isFeatureLayerItemDefinition(item);
+}
+function isFeatureSetDefinition(item) {
+    return isUrlDefinition(item) || isFieldsDefinition(item) || isFeatureLayerItemDefinition(item);
+}
+function isFeatureSetCollectionDefinition(item) {
+    return isPortalItemDefinition(item) || isMapInstance(item) || isSupportedServiceUrlDefinition(item);
+}
+function isSubtypeInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        item.declaredClass === "esri.layers.support.Subtype");
+}
+function isCodedValueDomainInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        item.declaredClass === "esri.layers.support.CodedValueDomain");
+}
+function isInheritedDomainInstance(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "declaredClass" in item &&
+        item.declaredClass === "esri.layers.support.InheritedDomain");
+}
+function isPredefinedProfile(item) {
+    return (!!item &&
+        typeof item === "object" &&
+        "id" in item &&
+        typeof item.id === "string" &&
+        "definitions" in item &&
+        typeof item.definitions === "object" &&
+        !Array.isArray(item.definitions));
+}
+function isTitleCapableSource(item) {
+    return !!item && typeof item === "object" && "title" in item && typeof item.title === "string";
+}
+function isUrlCapableSource(item) {
+    return !!item && typeof item === "object" && "url" in item && typeof item.url === "string";
+}
+function isLayerIdCapableSource(item) {
+    return !!item && typeof item === "object" && "layerId" in item && typeof item.layerId === "number";
+}
+function isFeatureTypesCapableLayer(item) {
+    return !!item && typeof item === "object" && "typeIdField" in item && "types" in item;
+}
+function isDomainsCapableLayer(item) {
+    return !!item && typeof item === "object" && "getFieldDomain" in item && typeof item.getFieldDomain === "function";
+}
+function isSubtypeFieldCapableLayer(item) {
+    return !!item && typeof item === "object" && "subtypeField" in item;
+}
+function isSubtypesCapableLayer(item) {
+    return isSubtypeFieldCapableLayer(item) && "subtypes" in item;
+}
+function isPortalItemCapable(item) {
+    return !!item && typeof item === "object" && "portalItem" in item;
+}
+function isRelationshipsCapableLayer(item) {
+    return (isLayerIdCapableSource(item) &&
+        "relationships" in item &&
+        "url" in item &&
+        Array.isArray(item.relationships) &&
+        typeof item.url === "string");
+}
+function isTableCapableLayer(item) {
+    return !!item && typeof item === "object" && "isTable" in item && typeof item.isTable === "boolean";
+}
+function isLoadableSource(item) {
+    return !!item && typeof item === "object" && "load" in item && typeof item.load === "function";
+}
+//#endregion
+//#region Service Metadata
+async function supportedSourceFromDefinition(definition) {
+    if (!definition) {
+        return null;
+    }
+    let source = null;
+    if (isFieldsDefinition(definition)) {
+        source = definition;
+    }
+    else {
+        source = await newLayersFeatureLayer(definition);
+    }
+    if (isLoadableSource(source)) {
+        await source.load();
+    }
+    return source;
+}
+async function serviceMetaData(url) {
+    url += "/layers";
+    const request = await importRequest();
+    const response = await request(url, { responseType: "json", query: { f: "json" } });
+    const queryCapability = url.endsWith("MapServer/layers") ? "data" : "query";
+    const layers = getSupportedLayerInfos(response.data?.layers, queryCapability);
+    const tables = getSupportedLayerInfos(response.data?.tables, queryCapability);
+    return { layers, tables };
+}
+function getSupportedLayerInfos(layers, queryCapability) {
+    if (!layers) {
+        return [];
+    }
+    return layers.filter((layer) => {
+        switch (layer.type) {
+            case "Feature Layer":
+            case "Oriented Imagery Layer":
+            case "Catalog Layer":
+            case "Table": {
+                const capabilities = layer.capabilities
+                    ? layer.capabilities
+                        .toLowerCase()
+                        .split(",")
+                        .map((value) => value.trim())
+                    : [];
+                return capabilities.includes(queryCapability);
+            }
+            default:
+                return false;
+        }
+    });
+}
+//#endregion
+
+// src/array-utils.ts
+
+// src/deferred.ts
+var Deferred = class {
+  /**
+   * Resolves the promise.
+   * @param value The value to resolve the promise with.
+   */
+  resolve(_value) {
+  }
+  /**
+   * Rejects the promise.
+   */
+  reject(_error) {
+  }
+  /**
+   * Creates a new deferred promise.
+   */
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+};
+
+// src/dom.ts
+function inTargetElement(element, targetElement) {
+  let currentElement = element;
+  while (currentElement) {
+    if (currentElement === targetElement) {
+      return true;
+    }
+    if (!currentElement.parentNode) {
+      return false;
+    }
+    if (currentElement.parentNode instanceof ShadowRoot) {
+      currentElement = currentElement.parentNode.host;
+    } else {
+      currentElement = currentElement.parentNode;
+    }
+  }
+  return false;
+}
+function observeAncestorsMutation(element, attributeFilter, callback) {
+  const { subscribe } = observe(attributeFilter);
+  return subscribe((mutations) => {
+    const matched = mutations.some((mutation) => inTargetElement(element, mutation.target));
+    if (matched) {
+      callback();
+    }
+  });
+}
+var observers = {};
+function observe(attributeFilter) {
+  const attributes = attributeFilter.join(",");
+  const previousObserver = observers[attributes];
+  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, {
+    attributes: true,
+    attributeFilter,
+    subtree: true
+  });
+  const observer = {
+    subscribe(callback) {
+      subscribers.add(callback);
+      return {
+        remove: () => {
+          subscribers.delete(callback);
+          if (subscribers.size === 0) {
+            mutationObserver.disconnect();
+            observers[attributes] = void 0;
+          }
+        }
+      };
+    }
+  };
+  observers[attributes] = observer;
+  return observer;
+}
+function closestElement(base, selector) {
+  let currentElement = base;
+  while (currentElement) {
+    const element = currentElement.closest(selector);
+    if (element) {
+      return element;
+    }
+    const rootElement = currentElement.getRootNode();
+    if (rootElement === document) {
+      return null;
+    }
+    currentElement = rootElement.host;
+  }
+  return null;
+}
+function getElementTheme(base) {
+  const themeElt = closestElement(base, ":is(.calcite-mode-light, .calcite-mode-dark)");
+  return themeElt && themeElt.classList.contains("calcite-mode-dark") ? "dark" : "light";
+}
+function getElementAttribute(el, prop, fallbackValue) {
+  const closest = closestElement(el, `[${prop}]`);
+  return closest?.getAttribute(prop) ?? fallbackValue;
+}
+function isElement(ref) {
+  return ref.nodeType === Node.ELEMENT_NODE;
+}
+function isHTMLWithSetFocus(ref) {
+  return "setFocus" in ref && typeof ref.setFocus === "function";
+}
+function setFocus(ref, selector = "") {
+  if (!isElement(ref)) {
+    return false;
+  }
+  if (ref.matches(selector)) {
+    if (isHTMLWithSetFocus(ref)) {
+      setTimeout(() => ref.setFocus(), 0);
+    }
+    return true;
+  }
+  for (const child of ref.children) {
+    if (setFocus(child, selector)) {
+      return true;
+    }
+  }
+  const shadowRoot = ref.shadowRoot;
+  if (shadowRoot) {
+    for (const child of shadowRoot.children) {
+      if (setFocus(child, selector)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function setFocusOnElement(ref, selector) {
+  if (!ref?.shadowRoot) {
+    return;
+  }
+  if (ref.hasAttribute("hydrated") || ref.hasAttribute("calcite-hydrated")) {
+    setFocus(ref, selector);
+    return;
+  }
+  const mutationObserver = new MutationObserver(() => {
+    mutationObserver.disconnect();
+    setFocus(ref, selector);
+  });
+  mutationObserver.observe(ref, {
+    attributes: true,
+    attributeFilter: ["hydrated", "calcite-hydrated"]
+  });
+}
+
+// src/errors.ts
+function safeCall(callback, thisContext, ...rest) {
+  try {
+    return callback?.call(thisContext, ...rest);
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+}
+async function safeAsyncCall(callback, thisContext, ...rest) {
+  try {
+    const result = callback?.call(thisContext, ...rest);
+    return result instanceof Promise ? await result : result;
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+}
+
+// src/guid.ts
+function gen(count) {
+  let out = "";
+  for (let i = 0; i < count; i++) {
+    out += ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
+  }
+  return out;
+}
+function generateGuid() {
+  return [gen(2), gen(1), gen(1), gen(1), gen(3)].join("-");
+}
+
+// src/intl.ts
+var supportedLocalesArray = [
+  "ar",
+  "bg",
+  "bs",
+  "ca",
+  "cs",
+  "da",
+  "de",
+  "el",
+  "en",
+  "es",
+  "et",
+  "fi",
+  "fr",
+  "he",
+  "hr",
+  "hu",
+  "id",
+  "it",
+  "ja",
+  "ko",
+  "lt",
+  "lv",
+  "nl",
+  "nb",
+  "pl",
+  "pt-BR",
+  "pt-PT",
+  "ro",
+  "ru",
+  "sk",
+  "sl",
+  "sr",
+  "sv",
+  "th",
+  "tr",
+  "uk",
+  "vi",
+  "zh-CN",
+  "zh-HK",
+  "zh-TW"
+];
+var supportedLocales = new Set(supportedLocalesArray);
+var defaultLocale = "en";
+var localeEquivalencies = {
+  // We use `pt-BR` as it will have the same translations as `pt`, which has no corresponding bundle
+  pt: "pt-PT",
+  // We support both 'nb' and 'no' (BCP 47) for Norwegian but only `nb` has corresponding bundle
+  no: "nb",
+  // We can `zh-CN` as base translation for chinese locales which has no corresponding bundle.
+  zh: "zh-CN"
+};
+async function fetchT9nStringsBundle(locale, assetsPath, prefix = "") {
+  const path = `${assetsPath}/${prefix}`;
+  const filePath = `${path}${locale}.json`;
+  t9nStringsCache[filePath] ?? (t9nStringsCache[filePath] = fetchBundle(locale, path));
+  return await t9nStringsCache[filePath];
+}
+var t9nStringsCache = {};
+async function fetchBundle(locale, path) {
+  const filePath = `${path}${locale}.json`;
+  try {
+    const response = await fetch(filePath);
+    if (response.ok) {
+      return await response.json();
+    }
+  } catch (error) {
+    console.error(error);
+    return {};
+  }
+  if (locale === defaultLocale) {
+    return {};
+  }
+  return await fetchBundle(defaultLocale, path);
+}
+function getElementLocales(element) {
+  const lang = getElementAttribute(element, "lang", navigator.language || defaultLocale);
+  return { lang, t9nLocale: langToLocale(lang) };
+}
+function langToLocale(lang) {
+  const parts = lang.split("-");
+  const normalized = `${parts[0].toLowerCase()}${parts.slice(1).join("-").toUpperCase()}`;
+  if (supportedLocales.has(normalized)) {
+    return normalized;
+  }
+  const languageCode = normalized.slice(0, 2).toLowerCase();
+  const locale = localeEquivalencies[languageCode] ?? languageCode;
+  if (supportedLocales.has(locale)) {
+    return locale;
+  }
+  return defaultLocale;
+}
+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) {
+      onUpdated(newResult);
+    }
+    result = newResult;
+  }).catch(console.error);
+  callback();
+  return observeAncestorsMutation(element, ["lang"], callback);
+}
+async function updateComponentLocateState(element, assetsPath, assetName = element.tagName.toLowerCase().replace("arcgis-", "")) {
+  const { lang, t9nLocale } = getElementLocales(element);
+  const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
+  const prefix = `${assetName}.t9n.`;
+  const t9nStrings = await fetchT9nStringsBundle(t9nLocale, t9nAssetsPath, prefix);
+  return { lang, t9nLocale, t9nStrings };
+}
+
+// src/strings.ts
+var doubleQuote = '"';
+var singleQuote = "'";
+function repeatString(value, n) {
+  return new Array(n + 1).join(value);
+}
+function quoteString(value) {
+  let quote = doubleQuote;
+  let alternateQuote = singleQuote;
+  const avoidEscape = value.includes(quote) && !value.includes(alternateQuote);
+  if (avoidEscape) {
+    alternateQuote = doubleQuote;
+    quote = singleQuote;
+  }
+  const alternateEscape = new RegExp(`(^|[^\\\\])((?:\\\\{2})*)((?:\\\\${alternateQuote})+)`, "gu");
+  value = value.replace(
+    alternateEscape,
+    (_, boundaryChar, leadingEscapedSlashes, escapedQuoteChars) => (
+      // We divide the escapedQuoteChars by 2 since there are 2 characters in each escaped part ('\\"'.length === 2)
+      boundaryChar + leadingEscapedSlashes + repeatString(alternateQuote, escapedQuoteChars.length / 2)
+    )
+  );
+  const quoteEscape = new RegExp(`(^|[^\\\\])((?:\\\\{2})*)(${quote}+)`, "gu");
+  value = value.replace(
+    quoteEscape,
+    (_, boundaryChar, leadingEscapedSlashes, quoteChars) => boundaryChar + leadingEscapedSlashes + repeatString(`\\${quote}`, quoteChars.length)
+  );
+  return quote + value + quote;
+}
+function createFilterExpression(filterWord) {
+  const sanitizedWord = filterWord ? filterWord.replaceAll(/[-[\]/{}()*+?.\\^$|]/gu, "\\$&") : "^.*$";
+  return new RegExp(sanitizedWord, "i");
+}
+function setValuesInString(message, values = {}) {
+  return (message ?? "").replace(/\{(?<valueName>.*?)\}/gu, (match, valueName) => values[valueName] ?? match);
+}
+function addLTRMark(value) {
+  return `\u200E${value ?? ""}\u200E`;
+}
+
+// src/timeouts.ts
+function devToolsAwareTimeout(callback, timeout) {
+  const interval = timeout > longTimeoutThreshold ? longTimeoutInterval : timeout / shortTimeoutIntervals;
+  let elapsed = 0;
+  const reference = setInterval(() => {
+    elapsed += interval;
+    if (elapsed >= timeout) {
+      clearInterval(reference);
+      callback();
+    }
+  }, interval);
+  return reference;
+}
+var longTimeoutThreshold = 4e3;
+var longTimeoutInterval = 2e3;
+var shortTimeoutIntervals = 4;
+
+// src/type-guards.ts
+function isNotNull(item) {
+  return item !== null;
+}
+function isNotUndefined(item) {
+  return item !== void 0;
+}
+
+// src/ui.ts
+function debounce(func, waitFor = 100) {
+  let timeout;
+  return (...args) => {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, waitFor);
+  };
+}
+
+// src/url.ts
+function hasSameOrigin(url1, url2, ignoreProtocol = false) {
+  if (!url1 || !url2) {
+    return false;
+  }
+  const url1Obj = new URL(url1);
+  const url2Obj = new URL(url2);
+  if (!ignoreProtocol && url1Obj.protocol !== url2Obj.protocol) {
+    return false;
+  }
+  if (url1Obj.host == null || url2Obj.host == null) {
+    return false;
+  }
+  return url1Obj.host.toLowerCase() === url2Obj.host.toLowerCase() && url1Obj.port === url2Obj.port;
+}
+function isURL(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Filters a collection of items by the given keys and filter word.
+ */
+function filterCollection(collection, keys, filterWord, beforeFilteringFn) {
+    if (!keys) {
+        return [];
+    }
+    const _keys = !Array.isArray(keys) ? [keys] : keys;
+    if (!_keys.length) {
+        return [];
+    }
+    const filterExpression = createFilterExpression(filterWord);
+    return collection.filter((item) => {
+        if (beforeFilteringFn) {
+            const res = beforeFilteringFn(item);
+            if (res !== null || res !== undefined) {
+                return res;
+            }
+        }
+        return _keys.some((key) => filterExpression.test(String(item[key] ?? "")));
+    });
+}
+/**
+ * Returns the url to the portal item.
+ */
+function portalItemPageUrl(portalItem) {
+    if (!portalItem) {
+        return "";
+    }
+    return `${portalItem.portal.url}/home/item.html?id=${portalItem.id}`;
+}
+//#endregion
+
+/**
+ * Returns an icon name for the field type
+ */
+function fieldTypeToIconName(field) {
+    switch (field.type) {
+        case "oid":
+            return "key";
+        case "small-integer":
+        case "big-integer":
+        case "integer":
+        case "single":
+        case "double":
+        case "long":
+            return "number";
+        case "global-id":
+        case "guid":
+            return "key";
+        case "string":
+            return "string";
+        case "date":
+            return "date-time";
+        case "date-only":
+            return "calendar";
+        case "time-only":
+            return "clock";
+        case "timestamp-offset":
+            return "time-zone";
+        default:
+            return "cube";
+    }
+}
+/**
+ * Returns the ApiValueVariable type for the given field.
+ */
+function fieldTypeToApiValueVarType(field) {
+    switch (field.type) {
+        case "small-integer":
+        case "integer":
+        case "big-integer":
+        case "single":
+        case "double":
+        case "long":
+        case "oid":
+            return "number";
+        case "global-id":
+        case "guid":
+        case "string":
+            return "text";
+        case "date":
+            return "date";
+        case "date-only":
+            return "dateOnly";
+        case "time-only":
+            return "time";
+        default:
+            return "text";
+    }
+}
+function supportedFields(fields) {
+    return (fields ?? []).filter((field) => {
+        switch (field.type) {
+            case "string":
+            case "small-integer":
+            case "integer":
+            case "big-integer":
+            case "single":
+            case "double":
+            case "long":
+            case "date":
+            case "date-only":
+            case "time-only":
+            case "timestamp-offset":
+            case "oid":
+            case "guid":
+            case "global-id":
+                return true;
+            default:
+                return false;
+        }
+    });
+}
+function fieldAlias(field) {
+    return field.alias || field.name;
+}
+
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function commonjsRequire (path) {
@@ -169011,752 +169763,6 @@ var main = {exports: {}};
 });
 }(main, main.exports));
 
-// src/index.ts
-var isAMD = typeof window !== "undefined" && "$arcgis" in window && typeof window.$arcgis === "object" && "import" in window.$arcgis;
-function isDefaultModule(module) {
-  return module.default !== void 0;
-}
-async function importLayersFeatureLayer() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/layers/FeatureLayer");
-  }
-  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/layers/FeatureLayer.js')); });
-  return isDefaultModule(module) ? module.default : module;
-}
-async function newLayersFeatureLayer(properties) {
-  const ModConstructor = await importLayersFeatureLayer();
-  return new ModConstructor(properties);
-}
-async function importPortalPortalItem() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/portal/PortalItem");
-  }
-  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/portal/PortalItem.js')); });
-  return isDefaultModule(module) ? module.default : module;
-}
-async function newPortalPortalItem(properties) {
-  const ModConstructor = await importPortalPortalItem();
-  return new ModConstructor(properties);
-}
-async function importWebMap() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/WebMap");
-  }
-  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/WebMap.js')); });
-  return isDefaultModule(module) ? module.default : module;
-}
-async function newWebMap(properties) {
-  const ModConstructor = await importWebMap();
-  return new ModConstructor(properties);
-}
-async function importWebScene() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/WebScene");
-  }
-  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/WebScene.js')); });
-  return isDefaultModule(module) ? module.default : module;
-}
-async function newWebScene(properties) {
-  const ModConstructor = await importWebScene();
-  return new ModConstructor(properties);
-}
-async function importArcade() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/arcade");
-  }
-  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/arcade.js')); });
-  return isDefaultModule(module) ? module.default : module;
-}
-async function importRequest() {
-  if (isAMD) {
-    return await window.$arcgis.import("esri/request");
-  }
-  const module = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@arcgis/core/request.js')); });
-  return isDefaultModule(module) ? module.default : module;
-}
-
-//#region Type Guards
-function isQueryableLayerInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        item.declaredClass.startsWith("esri.layers.") &&
-        "fields" in item &&
-        "queryFeatures" in item &&
-        typeof item.queryFeatures === "function");
-}
-function isSubtypeSublayerInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        item.declaredClass === "esri.layers.support.SubtypeSublayer");
-}
-function isGroupLayerInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        item.declaredClass === "esri.layers.GroupLayer");
-}
-function isMapInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        typeof item.declaredClass === "string" &&
-        (item.declaredClass === "esri.Map" ||
-            item.declaredClass === "esri.WebMap" ||
-            item.declaredClass === "esri.WebScene"));
-}
-function isWebMapInstance(item) {
-    return item.declaredClass === "esri.WebMap";
-}
-function isWebSceneInstance(item) {
-    return item.declaredClass === "esri.WebScene";
-}
-function isLoadableMapInstance(item) {
-    return item.declaredClass === "esri.WebMap" || item.declaredClass === "esri.WebScene";
-}
-function isPortalItemDefinition(item) {
-    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
-}
-function isFeatureLayerItemDefinition(item) {
-    return !!item && typeof item === "object" && "portalItem" in item && item.portalItem != null;
-}
-function isFieldsDefinition(item) {
-    return !!item && typeof item === "object" && "fields" in item && Array.isArray(item.fields);
-}
-function isUrlDefinition(item) {
-    return !!item && typeof item === "object" && "url" in item && typeof item.url === "string";
-}
-function isSupportedServiceUrlDefinition(item) {
-    return isUrlDefinition(item) && /\/(?:featureserver|mapserver)(?:\/|$)/iu.test(item.url);
-}
-function isSubtypeInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        item.declaredClass === "esri.layers.support.Subtype");
-}
-function isCodedValueDomainInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        item.declaredClass === "esri.layers.support.CodedValueDomain");
-}
-function isInheritedDomainInstance(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "declaredClass" in item &&
-        item.declaredClass === "esri.layers.support.InheritedDomain");
-}
-function isPredefinedProfile(item) {
-    return (!!item &&
-        typeof item === "object" &&
-        "id" in item &&
-        typeof item.id === "string" &&
-        "definitions" in item &&
-        typeof item.definitions === "object" &&
-        !Array.isArray(item.definitions));
-}
-function isTitleCapableSource(item) {
-    return !!item && typeof item === "object" && "title" in item && typeof item.title === "string";
-}
-function isUrlCapableSource(item) {
-    return !!item && typeof item === "object" && "url" in item && typeof item.url === "string";
-}
-function isLayerIdCapableSource(item) {
-    return !!item && typeof item === "object" && "layerId" in item && typeof item.layerId === "number";
-}
-function isFeatureTypesCapableLayer(item) {
-    return !!item && typeof item === "object" && "typeIdField" in item && "types" in item;
-}
-function isDomainsCapableLayer(item) {
-    return !!item && typeof item === "object" && "getFieldDomain" in item && typeof item.getFieldDomain === "function";
-}
-function isSubtypeFieldCapableLayer(item) {
-    return !!item && typeof item === "object" && "subtypeField" in item;
-}
-function isSubtypesCapableLayer(item) {
-    return isSubtypeFieldCapableLayer(item) && "subtypes" in item;
-}
-function isRelationshipsCapableLayer(item) {
-    return (isLayerIdCapableSource(item) &&
-        "relationships" in item &&
-        "url" in item &&
-        Array.isArray(item.relationships) &&
-        typeof item.url === "string");
-}
-function isTableCapableLayer(item) {
-    return !!item && typeof item === "object" && "isTable" in item && typeof item.isTable === "boolean";
-}
-function isLoadableSource(item) {
-    return !!item && typeof item === "object" && "load" in item && typeof item.load === "function";
-}
-//#endregion
-//#region Service Metadata
-async function supportedSourceFromDefinition(definition) {
-    if (!definition) {
-        return null;
-    }
-    let source = null;
-    if (isFieldsDefinition(definition)) {
-        source = definition;
-    }
-    else {
-        source = await newLayersFeatureLayer(definition);
-    }
-    if (isLoadableSource(source)) {
-        await source.load();
-    }
-    return source;
-}
-async function serviceMetaData(url) {
-    url += "/layers";
-    const request = await importRequest();
-    const response = await request(url, { responseType: "json", query: { f: "json" } });
-    const queryCapability = url.endsWith("MapServer/layers") ? "data" : "query";
-    const layers = getSupportedLayerInfos(response.data?.layers, queryCapability);
-    const tables = getSupportedLayerInfos(response.data?.tables, queryCapability);
-    return { layers, tables };
-}
-function getSupportedLayerInfos(layers, queryCapability) {
-    if (!layers) {
-        return [];
-    }
-    return layers.filter((layer) => {
-        switch (layer.type) {
-            case "Feature Layer":
-            case "Oriented Imagery Layer":
-            case "Catalog Layer":
-            case "Table": {
-                const capabilities = layer.capabilities
-                    ? layer.capabilities
-                        .toLowerCase()
-                        .split(",")
-                        .map((value) => value.trim())
-                    : [];
-                return capabilities.includes(queryCapability);
-            }
-            default:
-                return false;
-        }
-    });
-}
-//#endregion
-
-// src/array-utils.ts
-
-// src/deferred.ts
-var Deferred = class {
-  /**
-   * Resolves the promise.
-   * @param value The value to resolve the promise with.
-   */
-  resolve(_value) {
-  }
-  /**
-   * Rejects the promise.
-   */
-  reject(_error) {
-  }
-  /**
-   * Creates a new deferred promise.
-   */
-  constructor() {
-    this.promise = new Promise((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
-  }
-};
-
-// src/dom.ts
-function inTargetElement(element, targetElement) {
-  let currentElement = element;
-  while (currentElement) {
-    if (currentElement === targetElement) {
-      return true;
-    }
-    if (!currentElement.parentNode) {
-      return false;
-    }
-    if (currentElement.parentNode instanceof ShadowRoot) {
-      currentElement = currentElement.parentNode.host;
-    } else {
-      currentElement = currentElement.parentNode;
-    }
-  }
-  return false;
-}
-function observeAncestorsMutation(element, attributeFilter, callback) {
-  const { subscribe } = observe(attributeFilter);
-  return subscribe((mutations) => {
-    const matched = mutations.some((mutation) => inTargetElement(element, mutation.target));
-    if (matched) {
-      callback();
-    }
-  });
-}
-var observers = {};
-function observe(attributeFilter) {
-  const attributes = attributeFilter.join(",");
-  const previousObserver = observers[attributes];
-  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, {
-    attributes: true,
-    attributeFilter,
-    subtree: true
-  });
-  const observer = {
-    subscribe(callback) {
-      subscribers.add(callback);
-      return {
-        remove: () => {
-          subscribers.delete(callback);
-          if (subscribers.size === 0) {
-            mutationObserver.disconnect();
-            observers[attributes] = void 0;
-          }
-        }
-      };
-    }
-  };
-  observers[attributes] = observer;
-  return observer;
-}
-function closestElement(base, selector) {
-  let currentElement = base;
-  while (currentElement) {
-    const element = currentElement.closest(selector);
-    if (element) {
-      return element;
-    }
-    const rootElement = currentElement.getRootNode();
-    if (rootElement === document) {
-      return null;
-    }
-    currentElement = rootElement.host;
-  }
-  return null;
-}
-function getElementTheme(base) {
-  const themeElt = closestElement(base, ":is(.calcite-mode-light, .calcite-mode-dark)");
-  return themeElt && themeElt.classList.contains("calcite-mode-dark") ? "dark" : "light";
-}
-function getElementAttribute(el, prop, fallbackValue) {
-  const closest = closestElement(el, `[${prop}]`);
-  return closest?.getAttribute(prop) ?? fallbackValue;
-}
-function isElement(ref) {
-  return ref.nodeType === Node.ELEMENT_NODE;
-}
-function isHTMLWithSetFocus(ref) {
-  return "setFocus" in ref && typeof ref.setFocus === "function";
-}
-function setFocus(ref, selector = "") {
-  if (!isElement(ref)) {
-    return false;
-  }
-  if (ref.matches(selector)) {
-    if (isHTMLWithSetFocus(ref)) {
-      setTimeout(() => ref.setFocus(), 0);
-    }
-    return true;
-  }
-  for (const child of ref.children) {
-    if (setFocus(child, selector)) {
-      return true;
-    }
-  }
-  const shadowRoot = ref.shadowRoot;
-  if (shadowRoot) {
-    for (const child of shadowRoot.children) {
-      if (setFocus(child, selector)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function setFocusOnElement(ref, selector) {
-  if (!ref?.shadowRoot) {
-    return;
-  }
-  if (ref.hasAttribute("hydrated") || ref.hasAttribute("calcite-hydrated")) {
-    setFocus(ref, selector);
-    return;
-  }
-  const mutationObserver = new MutationObserver(() => {
-    mutationObserver.disconnect();
-    setFocus(ref, selector);
-  });
-  mutationObserver.observe(ref, {
-    attributes: true,
-    attributeFilter: ["hydrated", "calcite-hydrated"]
-  });
-}
-
-// src/errors.ts
-function safeCall(callback, thisContext, ...rest) {
-  try {
-    return callback?.call(thisContext, ...rest);
-  } catch (error) {
-    console.error(error, callback);
-  }
-  return void 0;
-}
-async function safeAsyncCall(callback, thisContext, ...rest) {
-  try {
-    const result = callback?.call(thisContext, ...rest);
-    return result instanceof Promise ? await result : result;
-  } catch (error) {
-    console.error(error, callback);
-  }
-  return void 0;
-}
-
-// src/guid.ts
-function gen(count) {
-  let out = "";
-  for (let i = 0; i < count; i++) {
-    out += ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
-  }
-  return out;
-}
-function generateGuid() {
-  return [gen(2), gen(1), gen(1), gen(1), gen(3)].join("-");
-}
-var camelToKebab = (string) => string.replace(upperBeforeLower, (upper, remainder) => `${remainder === 0 ? "" : "-"}${upper.toLowerCase()}`);
-var upperBeforeLower = /[A-Z]+(?![a-z])|[A-Z]/gu;
-var capitalize = (string) => string.charAt(0).toUpperCase() + string.slice(1);
-var camelToHuman = (string) => capitalize(string.replace(upperBeforeLower, (upper, remainder) => `${remainder === 0 ? "" : " "}${upper}`));
-
-// src/intl.ts
-var supportedLocales = /* @__PURE__ */ new Set([
-  "ar",
-  "bg",
-  "bs",
-  "ca",
-  "cs",
-  "da",
-  "de",
-  "el",
-  "en",
-  "es",
-  "et",
-  "fi",
-  "fr",
-  "he",
-  "hr",
-  "hu",
-  "id",
-  "it",
-  "ja",
-  "ko",
-  "lt",
-  "lv",
-  "nl",
-  "nb",
-  "pl",
-  "pt-BR",
-  "pt-PT",
-  "ro",
-  "ru",
-  "sk",
-  "sl",
-  "sr",
-  "sv",
-  "th",
-  "tr",
-  "uk",
-  "vi",
-  "zh-CN",
-  "zh-HK",
-  "zh-TW"
-]);
-var defaultLocale = "en";
-async function fetchT9NStringsBundle(locale, assetsPath, prefix = "") {
-  const path = `${assetsPath}/${prefix}`;
-  const filePath = `${path}${locale}.json`;
-  t9nStringsCache[filePath] ?? (t9nStringsCache[filePath] = fetchBundle(locale, path));
-  return await t9nStringsCache[filePath];
-}
-var t9nStringsCache = {};
-async function fetchBundle(locale, path) {
-  const filePath = `${path}${locale}.json`;
-  try {
-    const response = await fetch(filePath);
-    if (response.ok) {
-      return await response.json();
-    }
-  } catch (error) {
-    console.error(error);
-    return fallbackBundle;
-  }
-  if (locale === defaultLocale) {
-    return fallbackBundle;
-  }
-  return await fetchBundle(defaultLocale, path);
-}
-var fallbackBundle = new Proxy(
-  {},
-  {
-    get: (_target, property) => camelToHuman(property.toString())
-  }
-);
-function getElementLocales(element) {
-  const lang = getElementAttribute(element, "lang", navigator.language || defaultLocale);
-  if (supportedLocales.has(lang)) {
-    return { lang, t9nLocale: lang };
-  }
-  const rootCode = lang.slice(0, 2);
-  return { lang, t9nLocale: supportedLocales.has(rootCode) ? rootCode : defaultLocale };
-}
-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) {
-      onUpdated(newResult);
-    }
-    result = newResult;
-  }).catch(console.error);
-  callback();
-  return observeAncestorsMutation(element, ["lang"], callback);
-}
-async function updateComponentLocateState(element, assetsPath, assetName = element.tagName.toLowerCase().replace("arcgis-", "")) {
-  const { lang, t9nLocale } = getElementLocales(element);
-  const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
-  const prefix = `${assetName}.t9n.`;
-  const t9nStrings = await fetchT9NStringsBundle(t9nLocale, t9nAssetsPath, prefix);
-  return { lang, t9nLocale, t9nStrings };
-}
-
-// src/strings.ts
-var doubleQuote = '"';
-var singleQuote = "'";
-function repeatString(value, n) {
-  return new Array(n + 1).join(value);
-}
-function quoteString(value) {
-  let quote = doubleQuote;
-  let alternateQuote = singleQuote;
-  const avoidEscape = value.includes(quote) && !value.includes(alternateQuote);
-  if (avoidEscape) {
-    alternateQuote = doubleQuote;
-    quote = singleQuote;
-  }
-  const alternateEscape = new RegExp(`(^|[^\\\\])((?:\\\\{2})*)((?:\\\\${alternateQuote})+)`, "gu");
-  value = value.replace(
-    alternateEscape,
-    (_, boundaryChar, leadingEscapedSlashes, escapedQuoteChars) => (
-      // We divide the escapedQuoteChars by 2 since there are 2 characters in each escaped part ('\\"'.length === 2)
-      boundaryChar + leadingEscapedSlashes + repeatString(alternateQuote, escapedQuoteChars.length / 2)
-    )
-  );
-  const quoteEscape = new RegExp(`(^|[^\\\\])((?:\\\\{2})*)(${quote}+)`, "gu");
-  value = value.replace(
-    quoteEscape,
-    (_, boundaryChar, leadingEscapedSlashes, quoteChars) => boundaryChar + leadingEscapedSlashes + repeatString(`\\${quote}`, quoteChars.length)
-  );
-  return quote + value + quote;
-}
-function createFilterExpression(filterWord) {
-  const sanitizedWord = filterWord ? filterWord.replaceAll(/[-[\]/{}()*+?.\\^$|]/gu, "\\$&") : "^.*$";
-  return new RegExp(sanitizedWord, "i");
-}
-function setValuesInString(message, values = {}) {
-  return (message ?? "").replace(/\{(?<valueName>.*?)\}/gu, (match, valueName) => values[valueName] ?? match);
-}
-function addLTRMark(value) {
-  return `\u200E${value ?? ""}\u200E`;
-}
-
-// src/timeouts.ts
-function devToolsAwareTimeout(callback, timeout) {
-  const interval = timeout > longTimeoutThreshold ? longTimeoutInterval : timeout / shortTimeoutIntervals;
-  let elapsed = 0;
-  const reference = setInterval(() => {
-    elapsed += interval;
-    if (elapsed >= timeout) {
-      clearInterval(reference);
-      callback();
-    }
-  }, interval);
-  return reference;
-}
-var longTimeoutThreshold = 4e3;
-var longTimeoutInterval = 2e3;
-var shortTimeoutIntervals = 4;
-
-// src/type-guards.ts
-function isNotNull(item) {
-  return item !== null;
-}
-function isNotUndefined(item) {
-  return item !== void 0;
-}
-
-// src/ui.ts
-function debounce(func, waitFor = 100) {
-  let timeout;
-  return (...args) => {
-    const later = () => {
-      clearTimeout(timeout);
-      func(...args);
-    };
-    clearTimeout(timeout);
-    timeout = setTimeout(later, waitFor);
-  };
-}
-
-// src/url.ts
-function hasSameOrigin(url1, url2, ignoreProtocol = false) {
-  if (!url1 || !url2) {
-    return false;
-  }
-  const url1Obj = new URL(url1);
-  const url2Obj = new URL(url2);
-  if (!ignoreProtocol && url1Obj.protocol !== url2Obj.protocol) {
-    return false;
-  }
-  if (url1Obj.host == null || url2Obj.host == null) {
-    return false;
-  }
-  return url1Obj.host.toLowerCase() === url2Obj.host.toLowerCase() && url1Obj.port === url2Obj.port;
-}
-function isURL(url) {
-  try {
-    new URL(url);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-/**
- * Filters a collection of items by the given keys and filter word.
- */
-function filterCollection(collection, keys, filterWord, beforeFilteringFn) {
-    if (!keys) {
-        return [];
-    }
-    const _keys = !Array.isArray(keys) ? [keys] : keys;
-    if (!_keys.length) {
-        return [];
-    }
-    const filterExpression = createFilterExpression(filterWord);
-    return collection.filter((item) => {
-        if (beforeFilteringFn) {
-            const res = beforeFilteringFn(item);
-            if (res !== null || res !== undefined) {
-                return res;
-            }
-        }
-        return _keys.some((key) => filterExpression.test(String(item[key] ?? "")));
-    });
-}
-/**
- * Returns the url to the portal item.
- */
-function portalItemPageUrl(portalItem) {
-    if (!portalItem) {
-        return "";
-    }
-    return `${portalItem.portal.url}/home/item.html?id=${portalItem.id}`;
-}
-//#endregion
-
-/**
- * Returns an icon name for the field type
- */
-function fieldTypeToIconName(field) {
-    switch (field.type) {
-        case "oid":
-            return "key";
-        case "small-integer":
-        case "big-integer":
-        case "integer":
-        case "single":
-        case "double":
-        case "long":
-            return "number";
-        case "global-id":
-        case "guid":
-            return "key";
-        case "string":
-            return "string";
-        case "date":
-            return "date-time";
-        case "date-only":
-            return "calendar";
-        case "time-only":
-            return "clock";
-        case "timestamp-offset":
-            return "time-zone";
-        default:
-            return "cube";
-    }
-}
-/**
- * Returns the Arcade type for the given field.
- */
-function fieldTypeToArcadeType(field) {
-    switch (field.type) {
-        case "small-integer":
-        case "integer":
-        case "big-integer":
-        case "single":
-        case "double":
-        case "long":
-        case "oid":
-            return "number";
-        case "global-id":
-        case "guid":
-        case "string":
-            return "text";
-        case "date":
-            return "date";
-        case "date-only":
-            return "dateOnly";
-        case "time-only":
-            return "time";
-        default:
-            return "text";
-    }
-}
-function supportedFields(fields) {
-    return (fields ?? []).filter((field) => {
-        switch (field.type) {
-            case "string":
-            case "small-integer":
-            case "integer":
-            case "big-integer":
-            case "single":
-            case "double":
-            case "long":
-            case "date":
-            case "date-only":
-            case "time-only":
-            case "timestamp-offset":
-            case "oid":
-            case "guid":
-            case "global-id":
-                return true;
-            default:
-                return false;
-        }
-    });
-}
-function fieldAlias(field) {
-    return field.alias || field.name;
-}
-
 //#endregion
 //#region Support functions
 async function getRelatedFeatureLayer(layer, relationship) {
@@ -169772,14 +169778,6 @@ function sortFields(layer) {
         if (secondField.type === "oid") {
             return 1;
         }
-        if (isSubtypeSublayerInstance(layer)) {
-            if (firstField.name === layer.parent.subtypeField) {
-                return -1;
-            }
-            if (secondField.name === layer.parent.subtypeField) {
-                return 1;
-            }
-        }
         if (isSubtypeFieldCapableLayer(layer)) {
             if (firstField.name === layer.subtypeField) {
                 return -1;
@@ -169817,86 +169815,28 @@ function assembleMemberExpression(obj, prop) {
     return `${obj}${getMemberExpressionProperty(prop)}`;
 }
 function getMapPortalItem(map) {
-    if (isWebMapInstance(map) || isWebSceneInstance(map)) {
+    if (isPortalItemCapable(map)) {
         return map.portalItem;
     }
     return null;
 }
-//#endregion
-//#region Editor Profile to Language Service Profile functions
-async function variablesToLSVariable(editorVariables, kind = main.exports.CompletionItemKind.Variable) {
-    return await Promise.all(editorVariables.map(async (editorVariable) => {
-        switch (editorVariable.type) {
-            case "dictionary":
-                return await dictionaryToLSDictionary(editorVariable, kind);
-            case "feature":
-                return await featureToLSFeature(editorVariable, kind);
-            default:
-                return variableToLSVariable(editorVariable, kind);
-        }
-    }));
-}
-function variableToLSVariable(editorVariable, kind) {
-    const { name, type } = editorVariable;
-    const description = editorVariable.getDescription();
-    return {
-        name,
-        description,
-        type,
-        completion: {
-            label: name,
-            detail: name,
-            insertText: name,
-            insertTextMode: main.exports.InsertTextMode.asIs,
-            insertTextFormat: main.exports.InsertTextFormat.PlainText,
-            kind,
-            documentation: { kind: "markdown", value: description },
-        },
-    };
-}
-async function featureToLSFeature(editorFeature, kind) {
-    // Get the source for the definition
-    const source = await editorFeature.loadSource();
-    const { name } = editorFeature;
-    const description = editorFeature.getDescription();
-    const resultCompletion = {
-        label: name,
-        detail: name,
-        insertText: name,
-        insertTextMode: main.exports.InsertTextMode.asIs,
-        insertTextFormat: main.exports.InsertTextFormat.PlainText,
-        kind,
-    };
-    const result = {
-        name,
-        description,
-        type: "dictionary",
-        properties: [],
-        completion: resultCompletion,
-    };
-    // No source definition, then it will be a feature without any known fields
-    if (!source) {
-        return result;
-    }
-    // Create properties for the fields and the aliases
-    // Also improve the feature completion documentation
-    let featureCompletionDescription = description;
+/**
+ * converts fields to profile values and calculates the feature completion description all in one iteration
+ */
+function fieldsToProfileValues(fields, initialFeatureCompletionDescription, includeAliases = false) {
+    let featureCompletionDescription = initialFeatureCompletionDescription;
     const fieldProfileValues = [];
     const aliasProfileValues = [];
-    supportedFields(source.fields).forEach((field) => {
-        let fieldCompletionDescription = `**${field.name}**  \n${field.type}`;
-        if (field.description) {
-            fieldCompletionDescription += `  \n'${field.description}`;
-        }
+    supportedFields(fields).forEach((field) => {
         if (featureCompletionDescription) {
             featureCompletionDescription += "  \n  \n";
         }
-        featureCompletionDescription += `**${field.name}** (${fieldAlias(field)})  \n${field.type}`;
+        featureCompletionDescription += `**${field.name}** (${field.alias})  \n${field.type}`;
         if (field.description) {
             featureCompletionDescription += `  \n'${field.description}`;
         }
         // The property for the field
-        const type = fieldTypeToArcadeType(field);
+        const type = fieldTypeToApiValueVarType(field);
         const insertText = getMemberExpressionProperty(field.name, false);
         const description = fieldAlias(field);
         fieldProfileValues.push({
@@ -169910,65 +169850,35 @@ async function featureToLSFeature(editorFeature, kind) {
                 insertTextMode: main.exports.InsertTextMode.asIs,
                 insertTextFormat: main.exports.InsertTextFormat.PlainText,
                 kind: main.exports.CompletionItemKind.Field,
-                documentation: { kind: "markdown", value: fieldCompletionDescription },
             },
         });
-        if (!field.alias || field.alias.toLowerCase() === field.name.toLowerCase()) {
-            return;
-        }
-        // The property for the alias if different than the field name
-        let aliasCompletionDescription = `**${field.alias}**  \n${field.type}`;
-        if (field.description) {
-            aliasCompletionDescription += `  \n'${field.description}`;
+        if (includeAliases) {
+            if (!field.alias || field.alias.toLowerCase() === field.name.toLowerCase()) {
+                return;
+            }
+            // The property for the alias if different than the field name
+            let aliasCompletionDescription = `**${field.alias}**  \n${field.type}`;
+            if (field.description) {
+                aliasCompletionDescription += `  \n'${field.description}`;
+            }
+            aliasProfileValues.push({
+                name: field.alias,
+                description: field.name,
+                type,
+                completion: {
+                    label: field.alias,
+                    detail: field.name,
+                    insertText,
+                    insertTextMode: main.exports.InsertTextMode.asIs,
+                    insertTextFormat: main.exports.InsertTextFormat.PlainText,
+                    kind: main.exports.CompletionItemKind.Field,
+                    documentation: { kind: "markdown", value: aliasCompletionDescription },
+                },
+            });
         }
-        aliasProfileValues.push({
-            name: field.alias,
-            description: field.name,
-            type,
-            completion: {
-                label: field.alias,
-                detail: field.name,
-                insertText,
-                insertTextMode: main.exports.InsertTextMode.asIs,
-                insertTextFormat: main.exports.InsertTextFormat.PlainText,
-                kind: main.exports.CompletionItemKind.Field,
-                documentation: { kind: "markdown", value: aliasCompletionDescription },
-            },
-        });
     });
-    result.properties = [...fieldProfileValues, ...aliasProfileValues];
-    resultCompletion.documentation = { kind: "markdown", value: featureCompletionDescription };
-    return result;
-}
-async function dictionaryToLSDictionary(editorDictionary, kind) {
-    const { name, dictionaryVariables: variables } = editorDictionary;
-    const description = editorDictionary.getDescription();
-    const completionDescription = variables.reduce((previous, p) => {
-        if (previous !== "") {
-            previous += "  \n  \n";
-        }
-        previous += `**${p.name}**  \n${p.type}`;
-        const description = p.getDescription();
-        if (description) {
-            previous += `  \n${description}`;
-        }
-        return previous;
-    }, description);
-    return {
-        name,
-        description,
-        type: "dictionary",
-        properties: await variablesToLSVariable(variables, main.exports.CompletionItemKind.Field),
-        completion: {
-            label: name,
-            detail: name,
-            insertText: name,
-            insertTextMode: main.exports.InsertTextMode.asIs,
-            insertTextFormat: main.exports.InsertTextFormat.PlainText,
-            kind,
-            documentation: { kind: "markdown", value: completionDescription },
-        },
-    };
+    const properties = [...fieldProfileValues, ...aliasProfileValues];
+    return [properties, featureCompletionDescription];
 }
 /**
  * Represents a item in the EditorProfile. The profile is converted into an optimized way for
@@ -170502,7 +170412,7 @@ class SourceBasedVariable extends CollectionBasedVariable {
         const relationshipsGroup = new GroupOfVariables(this._profile, { code: "relationships" });
         const relationshipItems = await Promise.all(source.relationships.map(async (relationship) => {
             const relatedLayer = await getRelatedFeatureLayer(source, relationship);
-            if (!isQueryableLayerInstance(relatedLayer)) {
+            if (!isFeatureLayerLikeInstance(relatedLayer)) {
                 return null;
             }
             if (relationship.relatedTableId === this.relationshipsProperties?.sourceTableId) {
@@ -170673,13 +170583,14 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         if (typeof this._featureSetCollections.source === "string") {
             return this._profile?.intlStrings.featureservice ?? "featureservice";
         }
-        if (isWebSceneInstance(this._featureSetCollections.source)) {
-            return this._profile?.intlStrings.webscene ?? "webscene";
-        }
-        if (isWebMapInstance(this._featureSetCollections.source)) {
-            return this._profile?.intlStrings.webmap ?? "webmap";
+        switch (this._featureSetCollections.source.declaredClass) {
+            case "esri.WebMap":
+                return this._profile?.intlStrings.webmap ?? "webmap";
+            case "esri.WebScene":
+                return this._profile?.intlStrings.webscene ?? "webscene";
+            default:
+                return this._profile?.intlStrings.map ?? "map";
         }
-        return this._profile?.intlStrings.map ?? "map";
     }
     async loadSource() {
         if (isNotNull(this._loadPromise) && isNotUndefined(this._loadPromise)) {
@@ -170746,7 +170657,7 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         return null;
     }
     async _featureSetCollectionFromMap(map) {
-        if (isLoadableMapInstance(map)) {
+        if (isLoadAllCapable(map)) {
             // Make sure the map is loaded
             await map.loadAll();
         }
@@ -170804,11 +170715,11 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
             .toArray()
             .reverse()
             .forEach((layer) => {
-            if (isQueryableLayerInstance(layer)) {
+            if (isFeatureLayerLikeInstance(layer)) {
                 layerVariables.push(this._createFeatureSetVariable(layer, true));
                 return;
             }
-            if (isGroupLayerInstance(layer)) {
+            if (isGroupLayerCapable(layer)) {
                 const groupLayerVariables = filteringTables
                     ? this._convertWebMapLayersToVariables(layer.allTables, true)
                     : this._convertWebMapLayersToVariables(layer.allLayers);
@@ -170817,31 +170728,31 @@ class FeatureSetCollectionVariable extends CollectionBasedVariable {
         });
         return layerVariables;
     }
-    _createFeatureSetVariable(featureLayer, isFromWebMap = false) {
+    _createFeatureSetVariable(featureLayerLike, isFromWebMap = false) {
         return new FeatureSetVariable(this, {
             profile: this._profile,
-            declaration: { name: featureLayer.title, definition: featureLayer },
+            declaration: { name: featureLayerLike.title, definition: featureLayerLike },
             label: isFromWebMap
-                ? featureLayer.title
-                : featureLayer.sourceJSON.name ?? featureLayer.title,
+                ? featureLayerLike.title
+                : featureLayerLike.sourceJSON.name ?? featureLayerLike.title,
             description: "",
             nonInteractive: true,
-        }, this._makeFeatureSetSnippets(featureLayer, isFromWebMap));
+        }, this._makeFeatureSetSnippets(featureLayerLike, isFromWebMap));
     }
-    _makeFeatureSetSnippets(featureLayer, isFromWebMap = false) {
+    _makeFeatureSetSnippets(featureLayerLike, isFromWebMap = false) {
         if (!this._profile?.supportFeatureSetFunctions) {
             return [];
         }
         if (isFromWebMap) {
-            const snippetById = `FeatureSetById(${this.snippet}, "${featureLayer.id}")`;
-            const snippetByName = `FeatureSetByName(${this.snippet}, "${featureLayer.title}")`;
+            const snippetById = `FeatureSetById(${this.snippet}, "${featureLayerLike.id}")`;
+            const snippetByName = `FeatureSetByName(${this.snippet}, "${featureLayerLike.title}")`;
             return [
                 new ValueVariable({ profile: this._profile, label: snippetById, description: "", snippet: snippetById }),
                 new ValueVariable({ profile: this._profile, label: snippetByName, description: "", snippet: snippetByName }),
             ];
         }
         else {
-            const snippetById = `FeatureSetById(${this.snippet}, "${featureLayer.layerId}")`;
+            const snippetById = `FeatureSetById(${this.snippet}, "${featureLayerLike.layerId}")`;
             return [new ValueVariable({ profile: this._profile, label: snippetById, description: "", snippet: snippetById })];
         }
     }
@@ -170879,14 +170790,6 @@ class EditorProfile extends DictionaryVariable {
     get supportFeatureSetFunctions() {
         return this.definition?.bundles?.includes("data-access") ?? false;
     }
-    /**
-     * Returns the language service profile. It is different than the editor profile as it is optimized for Monaco.
-     */
-    async toLSProfile() {
-        const { apiVersion, bundles, hiddenApiItems } = this.definition ?? {};
-        const variables = await variablesToLSVariable(this.dictionaryVariables);
-        return { apiVersion, bundles, variables, hiddenApiItems: hiddenApiItems?.map((s) => s.toLowerCase()) };
-    }
     /**
      * Returns the EditorProfile as a json. The EditorProfile may have been updated. This function allows to
      * get the new json representing mutations.
@@ -170900,179 +170803,6 @@ class EditorProfile extends DictionaryVariable {
 }
 //#endregion
 
-function isFeatureDefinition(item) {
-    return isUrlDefinition(item) || isFieldsDefinition(item) || isFeatureLayerItemDefinition(item);
-}
-function isFeatureSetDefinition(item) {
-    return isUrlDefinition(item) || isFieldsDefinition(item) || isFeatureLayerItemDefinition(item);
-}
-function isFeatureSetCollectionDefinition(item) {
-    return isPortalItemDefinition(item) || isMapInstance(item) || isSupportedServiceUrlDefinition(item);
-}
-/**
- * Get a PredefinedProfile for a locale. If not already loaded then fetch it.
- * If the locale doesn't exist or the locale profile file doesn't exist then returns
- * the english version of the profile.
- */
-async function getSdkPredefinedProfiles(locale = "en") {
-    const profiles = sdkPredefinedProfilesMap.get(locale);
-    if (profiles) {
-        return profiles;
-    }
-    if (!supportedLocales.has(locale)) {
-        return await getSdkPredefinedProfiles("en");
-    }
-    try {
-        const response = await fetch(index.getAssetPath(`./assets/arcade-language/profiles/arcade-profiles.t9n.${locale}.json`));
-        if (response.ok) {
-            return cacheSdkPredefinedProfiles(locale, (await response.json()));
-        }
-        if (locale === "en") {
-            return null;
-        }
-        return await getSdkPredefinedProfiles("en");
-    }
-    catch {
-        return null;
-    }
-}
-const sdkPredefinedProfilesMap = new Map();
-/**
- * Convert a stored profile into a PredefinedProfile and add it to the in-memory
- * Map of profiles per locale.
- */
-function cacheSdkPredefinedProfiles(locale, profiles) {
-    const map = new Map();
-    profiles.forEach((profile) => {
-        map.set(profile.id, profile);
-    });
-    sdkPredefinedProfilesMap.set(locale, map);
-    return map;
-}
-async function getSdkPredefinedProfile(id, locale = "en") {
-    const profiles = await getSdkPredefinedProfiles(locale);
-    return profiles?.get(id) ?? null;
-}
-function isExtendedPredefinedProfileDefinition(item) {
-    return !!item && typeof item === "object" && "additionalVariables" in item && Array.isArray(item.additionalVariables);
-}
-function convertApiVariables(variables) {
-    return variables?.map(convertApiVariable);
-}
-function convertApiVariable(variable) {
-    switch (variable.type) {
-        case "dictionary":
-            return {
-                ...variable,
-                type: variable.type,
-                properties: convertApiVariables(variable.properties),
-            };
-        case "array": {
-            return {
-                ...variable,
-                type: variable.type,
-                elementType: { type: "number", name: "number" },
-            };
-        }
-        default:
-            return { ...variable, type: variable.type };
-    }
-}
-async function convertToEditorProfileDefinition(predefinedProfile, locale = "en") {
-    if (!isPredefinedProfile(predefinedProfile)) {
-        return undefined;
-    }
-    const sdkPredefinedProfile = await getSdkPredefinedProfile(predefinedProfile.id, locale);
-    if (!sdkPredefinedProfile) {
-        return undefined;
-    }
-    const editorProfile = {
-        bundles: [...sdkPredefinedProfile.bundles],
-        variables: [],
-        hiddenApiItems: predefinedProfile.hiddenApiItems?.map((s) => s.toLowerCase()),
-    };
-    // Merge the SDK variables' definitions/properties with the predefined profile definitions.
-    sdkPredefinedProfile.variables.forEach((predefinedVariable) => {
-        // Don't include disabled variables
-        if (predefinedProfile.disabledVariables?.includes(predefinedVariable.name)) {
-            return;
-        }
-        // Try to get a definition from the predefined profile, for the variable that needs one.
-        const definition = predefinedProfile.definitions[predefinedVariable.name];
-        // Note: Something is weird with TS. The sdkVariables are being casted to the wrong type
-        // despite the type checking from the switch statement.
-        switch (predefinedVariable.type) {
-            case "dictionary": {
-                // For dictionary, we support properties overrride
-                return editorProfile.variables.push(convertApiVariable({
-                    ...predefinedVariable,
-                    type: predefinedVariable.type,
-                    properties: Array.isArray(definition) ? [...definition] : predefinedVariable.properties,
-                }));
-            }
-            case "feature":
-                // If the definition is not valid, then we don't include it.
-                if (!isFeatureDefinition(definition)) {
-                    return;
-                }
-                return editorProfile.variables.push({ ...predefinedVariable, type: predefinedVariable.type, definition });
-            case "featureSet":
-                // If the definition is not valid, then we don't include it.
-                if (!isFeatureSetDefinition(definition)) {
-                    return;
-                }
-                return editorProfile.variables.push({ ...predefinedVariable, type: predefinedVariable.type, definition });
-            case "featureSetCollection":
-                // If the definition is not valid, then we don't include it.
-                if (!isFeatureSetCollectionDefinition(definition)) {
-                    return;
-                }
-                return editorProfile.variables.push({ ...predefinedVariable, type: predefinedVariable.type, definition });
-            default:
-                return editorProfile.variables.push(convertApiVariable(predefinedVariable));
-        }
-    });
-    if (isExtendedPredefinedProfileDefinition(predefinedProfile)) {
-        editorProfile.variables.push(...(predefinedProfile.additionalVariables ?? []));
-    }
-    return editorProfile;
-}
-
-/**
- * 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 Promise.resolve().then(function () { return require('./arcade-mode-b85ae7d4.js'); });
-}
-
 // this file contains the building blocks for a language default provider
 const defaultContext = {
     locale: "en",
@@ -171114,20 +170844,11 @@ class LanguageDefaultsBase {
         return this._languageOptions;
     }
     /**
-     * Dispose the editor profile for the given model id.
-     * It is the responsibility of the caller that created the editor profile to dispose it.
-     * @param modelId The model id for which to dispose the editor profile.
+     * Dispose any cached resources for the model
      */
-    disposeEditorProfileForModel(modelId) {
+    disposeForModel(modelId) {
         const key = this._getApiKey(modelId);
         this._profileMap.delete(key);
-    }
-    /**
-     * Dispose the api context for the given model id.
-     * @param modelId The model id for which to dispose the api context.
-     */
-    disposeApiContextForModel(modelId) {
-        const key = this._getApiKey(modelId);
         if (this._apiContextMap.delete(key)) {
             this._fireModelContextDidChange(key);
         }
@@ -171168,100 +170889,37 @@ class LanguageDefaultsBase {
     }
 }
 
-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, index.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.
-     */
-    setLanguageOptions(languageOptions = {}) {
-        // Check if options have actually changed.
-        // Avoid restarting the worker when no updates.
-        // Today we only have the 'assetsPath' as a property
-        if (this._languageOptions.assetsPath === languageOptions.assetsPath) {
-            return;
-        }
-        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),
-};
-
 exports.Deferred = Deferred;
+exports.EditorProfile = EditorProfile;
 exports.Emitter = Emitter;
 exports.IStandaloneThemeService = IStandaloneThemeService;
 exports.KeyCode = KeyCode;
 exports.KeyMod = KeyMod;
+exports.LanguageDefaultsBase = LanguageDefaultsBase;
 exports.MarkerSeverity = MarkerSeverity;
 exports.Range = Range;
 exports.Uri = Uri;
 exports.addLTRMark = addLTRMark;
-exports.arcade = arcade;
-exports.arcadeDefaults = arcadeDefaults;
-exports.camelToKebab = camelToKebab;
 exports.commonjsGlobal = commonjsGlobal;
 exports.createFilterExpression = createFilterExpression;
 exports.debounce = debounce;
 exports.devToolsAwareTimeout = devToolsAwareTimeout;
 exports.editor = editor;
+exports.fetchT9nStringsBundle = fetchT9nStringsBundle;
+exports.fieldsToProfileValues = fieldsToProfileValues;
 exports.filterCollection = filterCollection;
 exports.generateGuid = generateGuid;
 exports.generateTokensCSSForColorMap = generateTokensCSSForColorMap;
-exports.getArcadeDiagnosticService = getArcadeDiagnosticService;
 exports.getElementLocales = getElementLocales;
 exports.getElementTheme = getElementTheme;
-exports.getMode = getMode;
 exports.hasSameOrigin = hasSameOrigin;
 exports.importArcade = importArcade;
 exports.importRequest = importRequest;
+exports.isFeatureDefinition = isFeatureDefinition;
+exports.isFeatureSetCollectionDefinition = isFeatureSetCollectionDefinition;
+exports.isFeatureSetDefinition = isFeatureSetDefinition;
+exports.isNotUndefined = isNotUndefined;
+exports.isPredefinedProfile = isPredefinedProfile;
 exports.isURL = isURL;
 exports.languages = languages;
 exports.main = main;
@@ -171274,4 +170932,5 @@ exports.setFocusOnElement = setFocusOnElement;
 exports.setValuesInString = setValuesInString;
 exports.startLocaleObserver = startLocaleObserver;
 exports.supportedFields = supportedFields;
+exports.supportedLocales = supportedLocales;
 exports.typescriptDefaults = typescriptDefaults;