@arcgis/toolkit 4.34.0-next.61

package/LICENSE.md

@@ -0,0 +1,13 @@
+# Licensing
+
+COPYRIGHT © 2025 Esri
+
+All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
+
+This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement. You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
+
+See use restrictions at http://www.esri.com/legal/pdfs/mla_e204_e300/english
+
+For additional information, contact: Environmental Systems Research Institute, Inc. Attn: Contracts and Legal Services Department 380 New York Street Redlands, California, USA 92373 USA
+
+email: contracts@esri.com

package/README.md

@@ -0,0 +1,21 @@
+# ArcGIS Maps SDK for JavaScript - Internal Toolkit
+
+**No Esri Technical Support included.**
+
+Package that is part of the [ArcGIS Maps SDK for JavaScript](https://developers.arcgis.com/javascript).
+
+It is not intended to be used directly, but rather used as a dependency by other packages in the SDK.
+
+## License
+
+COPYRIGHT © 2025 Esri
+
+All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
+
+This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement. You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
+
+See use restrictions at <http://www.esri.com/legal/pdfs/mla_e204_e300/english>
+
+For additional information, contact: Environmental Systems Research Institute, Inc. Attn: Contracts and Legal Services Department 380 New York Street Redlands, California, USA 92373 USA
+
+email: contracts@esri.com

package/dist/array/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mappedFind = (array, callback) => {
+  for (let i = 0; i < array.length; i++) {
+    const value = callback(array[i], i);
+    if (value != null) {
+      return value ?? void 0;
+    }
+  }
+  return;
+};
+exports.mappedFind = mappedFind;

package/dist/array/index.d.cts

@@ -0,0 +1,12 @@
+import { nil } from '../type';
+/**
+ * A combination of map and find.
+ * Find a value in an array, and return its mapped variant.
+ *
+ * @example
+ * ```ts
+ * // Given array of url strings, return the first valid URL object.
+ * const url = mappedFind(urlsStrings, (url) => URL.parse(url));
+ * ```
+ */
+export declare const mappedFind: <Item, ReturnType>(array: readonly Item[], callback: (item: Item, index: number) => nil | ReturnType) => ReturnType | undefined;

package/dist/array/index.d.ts

@@ -0,0 +1,12 @@
+import { nil } from '../type';
+/**
+ * A combination of map and find.
+ * Find a value in an array, and return its mapped variant.
+ *
+ * @example
+ * ```ts
+ * // Given array of url strings, return the first valid URL object.
+ * const url = mappedFind(urlsStrings, (url) => URL.parse(url));
+ * ```
+ */
+export declare const mappedFind: <Item, ReturnType>(array: readonly Item[], callback: (item: Item, index: number) => nil | ReturnType) => ReturnType | undefined;

package/dist/array/index.js

@@ -0,0 +1,12 @@
+const mappedFind = (array, callback) => {
+  for (let i = 0; i < array.length; i++) {
+    const value = callback(array[i], i);
+    if (value != null) {
+      return value ?? void 0;
+    }
+  }
+  return;
+};
+export {
+  mappedFind
+};

package/dist/dom/index.cjs

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const classes = (...classes2) => {
+  const effectiveClasses = [];
+  for (let i = 0; i < classes2.length; i++) {
+    const arg = classes2[i];
+    if (typeof arg === "string") {
+      effectiveClasses.push(arg);
+    } else if (Array.isArray(arg)) {
+      effectiveClasses.push.apply(effectiveClasses, arg);
+    } else if (typeof arg === "object") {
+      for (const prop in arg) {
+        if (arg[prop]) {
+          effectiveClasses.push(prop);
+        }
+      }
+    }
+  }
+  const className = effectiveClasses.join(" ");
+  effectiveClasses.length = 0;
+  return className;
+};
+const 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;
+};
+const observeAncestorsMutation = (element, attributeFilter, callback) => {
+  const subscribe = observe(attributeFilter).subscribe;
+  return subscribe((mutations) => {
+    const matched = mutations.some((mutation) => inTargetElement(element, mutation.target));
+    if (matched) {
+      callback();
+    }
+  });
+};
+const observers = {};
+const 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)));
+  if (globalThis.document) {
+    mutationObserver.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter,
+      subtree: true
+    });
+  }
+  const observer = {
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+        if (subscribers.size === 0) {
+          mutationObserver.disconnect();
+          observers[attributes] = void 0;
+        }
+      };
+    }
+  };
+  observers[attributes] = observer;
+  return observer;
+};
+const getClosestElement = (base, selector) => {
+  let currentElement = base;
+  while (currentElement) {
+    const element = currentElement.closest?.(selector);
+    if (element) {
+      return element;
+    }
+    const rootElement = currentElement.getRootNode?.();
+    if (rootElement === globalThis.document) {
+      return;
+    }
+    currentElement = rootElement.host;
+  }
+  return;
+};
+function unsafeGetCalciteModeName(el) {
+  const closestElWithMode = getClosestElement(el, `.calcite-mode-dark, .calcite-mode-light, .calcite-mode-auto`);
+  return closestElWithMode?.classList.contains("calcite-mode-dark") || closestElWithMode?.classList.contains("calcite-mode-auto") && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+const unsafeGetElementDirection = (el) => (
+  //#endregion unsafeGetElementDirection
+  getElementAttribute(el, "dir", "ltr")
+);
+const getElementAttribute = (el, attributeName, fallbackValue) => {
+  const closest = getClosestElement(el, `[${attributeName}]`);
+  return closest?.getAttribute(attributeName) ?? fallbackValue;
+};
+const focusElement = async (el) => {
+  if (el == null) {
+    return;
+  }
+  if (hasSetFocus(el)) {
+    await el.setFocus();
+  } else {
+    el.focus();
+  }
+};
+const hasSetFocus = (ref) => typeof ref.setFocus === "function";
+const setFocusOnElement = (ref, selector) => {
+  if (!ref?.shadowRoot) {
+    return;
+  }
+  if (ref.hasAttribute("hydrated") || ref.hasAttribute("calcite-hydrated")) {
+    setFocus(ref, selector);
+    return;
+  }
+  void Promise.resolve(ref.componentOnReady?.()).then(() => setFocus(ref, selector));
+};
+const isElement = (ref) => ref.nodeType === Node.ELEMENT_NODE;
+const setFocus = (ref, selector = "") => {
+  if (!isElement(ref)) {
+    return false;
+  }
+  if (ref.matches(selector)) {
+    if (hasSetFocus(ref)) {
+      setTimeout(() => void 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;
+};
+exports.classes = classes;
+exports.focusElement = focusElement;
+exports.getClosestElement = getClosestElement;
+exports.getElementAttribute = getElementAttribute;
+exports.observeAncestorsMutation = observeAncestorsMutation;
+exports.setFocusOnElement = setFocusOnElement;
+exports.unsafeGetCalciteModeName = unsafeGetCalciteModeName;
+exports.unsafeGetElementDirection = unsafeGetElementDirection;

package/dist/dom/index.d.cts

@@ -0,0 +1,115 @@
+import { nil } from '../type';
+/**
+ * Combine multiple class names into a single string.
+ *
+ * @remarks
+ * This function is less necessary in Lumina packages as the `class` JSX prop
+ * accepts `Record<string, boolean>` objects.
+ */
+export declare const classes: (...classes: (nil | Record<string, boolean> | string[] | string | false)[]) => string;
+/**
+ * Observe the element and its ancestors for attribute mutations.
+ * If the attributes have been changed in the ancestor tree then the callback
+ * will be invoked.
+ *
+ * @param element The element on which to observe the attribute mutations.
+ * @param attributeFilter The list of attributes to observe.
+ * @param callback The callback to invoke when the attributes have been changed.
+ * @returns A callback to unsubscribe from the observer.
+ *
+ * @example
+ * ```ts
+ * observeAncestorsMutation(
+ *   element,
+ *   ["dir", "lang"],
+ *   () => console.log(getElementAttribute(element, "dir", "ltr"))
+ * );
+ * ```
+ */
+export declare const observeAncestorsMutation: (element: Node, attributeFilter: string[], callback: () => void) => (() => void);
+/**
+ * Find the closest element that matches the selector.
+ * It will traverse the element's ancestors to find the target element.
+ * Shadow DOM boundaries are also taken into account.
+ * @param base The element to start the search from.
+ * @param selector The selector to match.
+ * @returns The closest element that matches the selector or null if not found.
+ *
+ * @remarks
+ * This is similar to [Element.closest()](https://developer.mozilla.org/en-US/docs/Web/API/Element/closest),
+ * but the DOM's utility only looks up until the first shadow boundary.
+ *
+ * @example
+ * ```ts
+ * const hostElement = getClosestElement(element, "arcgis-map, arcgis-scene");
+ * ```
+ */
+export declare const getClosestElement: <T = Element>(base: Element, selector: string) => T | undefined;
+/**
+ * Use the closest Calcite mode class name to determine the
+ * theme of the element. It will traverse the element's
+ * ancestors to find the theme. Shadow DOM boundaries are also
+ * taken into account.
+ *
+ * @param base The element to start the search from.
+ * @returns The theme of the element ("light" or "dark"). "light" is the default.
+ *
+ * @remarks
+ * It is advised to consider alternative solutions before using this utility:
+ * - Calcite CSS variables. Benefits: makes styles more consistent,
+ *   and variables are updated automatically to match dark/light theme.
+ * - Detect dark mode using CSS selectors and apply styles in CSS.
+ *   Benefit: styles update automatically when the theme changes.
+ */
+export declare function unsafeGetCalciteModeName(el: HTMLElement): "dark" | "light";
+/**
+ * Get direction property of the closest element.
+ *
+ * @param el The element to start the search from.
+ * @returns The direction of the element ("ltr" | "rtl"). "ltr" is the default.
+ *
+ * @remarks
+ * Do not set the `dir` property on the element itself. Do not set the `dir`
+ * attribute on the components you are rendering. The `dir` attribute is only
+ * meant to be set by the consumers of your component. Your component is
+ * expected to respect what was set by the consumer.
+ *
+ * @remarks
+ * Prefer [useDirection()](http://localhost:5173/components/lumina/controllers/useDirection)
+ * to ensure your component is responsive to direction changes.
+ */
+export declare const unsafeGetElementDirection: (el: HTMLElement) => "ltr" | "rtl";
+/**
+ * Get the attribute value from the element or closest ancestor.
+ * Shadow DOM boundaries are also taken into account.
+ * If the attribute is not found then the fallback value is returned.
+ *
+ * @example
+ * ```ts
+ * const dir = getElementAttribute(element, "dir", "ltr");
+ * ```
+ */
+export declare const getElementAttribute: (el: Element, attributeName: string, fallbackValue: string) => string;
+/**
+ * Focus the element if it is focusable.
+ * @returns A promise that resolves once the focus is set.
+ */
+export declare const focusElement: (el: FocusableElement | undefined) => Promise<void>;
+export interface FocusableElement extends HTMLElement {
+    setFocus?: () => Promise<void>;
+}
+/**
+ * Set the focus on the element that matches the selector.
+ * It will traverse the element's ancestors to find the target element.
+ * Shadow DOM boundaries are also taken into account.
+ * If the element is not found then the focus is not set.
+ * Example: `setFocusOnElement(element, "[role='menuitem']");`
+ * @param ref The element to start the search from.
+ * @param selector The selector to match.
+ * @returns Returns true if the focus is set on the element.
+ *
+ * @deprecated This function is doing too much. Import from `focusElement(getClosestElement())` from `@arcgis/toolkit/dom` instead.
+ */
+export declare const setFocusOnElement: (ref: (Element & {
+    componentOnReady?: () => Promise<void>;
+}) | null | undefined, selector: string) => void;

package/dist/dom/index.d.ts

@@ -0,0 +1,115 @@
+import { nil } from '../type';
+/**
+ * Combine multiple class names into a single string.
+ *
+ * @remarks
+ * This function is less necessary in Lumina packages as the `class` JSX prop
+ * accepts `Record<string, boolean>` objects.
+ */
+export declare const classes: (...classes: (nil | Record<string, boolean> | string[] | string | false)[]) => string;
+/**
+ * Observe the element and its ancestors for attribute mutations.
+ * If the attributes have been changed in the ancestor tree then the callback
+ * will be invoked.
+ *
+ * @param element The element on which to observe the attribute mutations.
+ * @param attributeFilter The list of attributes to observe.
+ * @param callback The callback to invoke when the attributes have been changed.
+ * @returns A callback to unsubscribe from the observer.
+ *
+ * @example
+ * ```ts
+ * observeAncestorsMutation(
+ *   element,
+ *   ["dir", "lang"],
+ *   () => console.log(getElementAttribute(element, "dir", "ltr"))
+ * );
+ * ```
+ */
+export declare const observeAncestorsMutation: (element: Node, attributeFilter: string[], callback: () => void) => (() => void);
+/**
+ * Find the closest element that matches the selector.
+ * It will traverse the element's ancestors to find the target element.
+ * Shadow DOM boundaries are also taken into account.
+ * @param base The element to start the search from.
+ * @param selector The selector to match.
+ * @returns The closest element that matches the selector or null if not found.
+ *
+ * @remarks
+ * This is similar to [Element.closest()](https://developer.mozilla.org/en-US/docs/Web/API/Element/closest),
+ * but the DOM's utility only looks up until the first shadow boundary.
+ *
+ * @example
+ * ```ts
+ * const hostElement = getClosestElement(element, "arcgis-map, arcgis-scene");
+ * ```
+ */
+export declare const getClosestElement: <T = Element>(base: Element, selector: string) => T | undefined;
+/**
+ * Use the closest Calcite mode class name to determine the
+ * theme of the element. It will traverse the element's
+ * ancestors to find the theme. Shadow DOM boundaries are also
+ * taken into account.
+ *
+ * @param base The element to start the search from.
+ * @returns The theme of the element ("light" or "dark"). "light" is the default.
+ *
+ * @remarks
+ * It is advised to consider alternative solutions before using this utility:
+ * - Calcite CSS variables. Benefits: makes styles more consistent,
+ *   and variables are updated automatically to match dark/light theme.
+ * - Detect dark mode using CSS selectors and apply styles in CSS.
+ *   Benefit: styles update automatically when the theme changes.
+ */
+export declare function unsafeGetCalciteModeName(el: HTMLElement): "dark" | "light";
+/**
+ * Get direction property of the closest element.
+ *
+ * @param el The element to start the search from.
+ * @returns The direction of the element ("ltr" | "rtl"). "ltr" is the default.
+ *
+ * @remarks
+ * Do not set the `dir` property on the element itself. Do not set the `dir`
+ * attribute on the components you are rendering. The `dir` attribute is only
+ * meant to be set by the consumers of your component. Your component is
+ * expected to respect what was set by the consumer.
+ *
+ * @remarks
+ * Prefer [useDirection()](http://localhost:5173/components/lumina/controllers/useDirection)
+ * to ensure your component is responsive to direction changes.
+ */
+export declare const unsafeGetElementDirection: (el: HTMLElement) => "ltr" | "rtl";
+/**
+ * Get the attribute value from the element or closest ancestor.
+ * Shadow DOM boundaries are also taken into account.
+ * If the attribute is not found then the fallback value is returned.
+ *
+ * @example
+ * ```ts
+ * const dir = getElementAttribute(element, "dir", "ltr");
+ * ```
+ */
+export declare const getElementAttribute: (el: Element, attributeName: string, fallbackValue: string) => string;
+/**
+ * Focus the element if it is focusable.
+ * @returns A promise that resolves once the focus is set.
+ */
+export declare const focusElement: (el: FocusableElement | undefined) => Promise<void>;
+export interface FocusableElement extends HTMLElement {
+    setFocus?: () => Promise<void>;
+}
+/**
+ * Set the focus on the element that matches the selector.
+ * It will traverse the element's ancestors to find the target element.
+ * Shadow DOM boundaries are also taken into account.
+ * If the element is not found then the focus is not set.
+ * Example: `setFocusOnElement(element, "[role='menuitem']");`
+ * @param ref The element to start the search from.
+ * @param selector The selector to match.
+ * @returns Returns true if the focus is set on the element.
+ *
+ * @deprecated This function is doing too much. Import from `focusElement(getClosestElement())` from `@arcgis/toolkit/dom` instead.
+ */
+export declare const setFocusOnElement: (ref: (Element & {
+    componentOnReady?: () => Promise<void>;
+}) | null | undefined, selector: string) => void;

package/dist/dom/index.js

@@ -0,0 +1,161 @@
+const classes = (...classes2) => {
+  const effectiveClasses = [];
+  for (let i = 0; i < classes2.length; i++) {
+    const arg = classes2[i];
+    if (typeof arg === "string") {
+      effectiveClasses.push(arg);
+    } else if (Array.isArray(arg)) {
+      effectiveClasses.push.apply(effectiveClasses, arg);
+    } else if (typeof arg === "object") {
+      for (const prop in arg) {
+        if (arg[prop]) {
+          effectiveClasses.push(prop);
+        }
+      }
+    }
+  }
+  const className = effectiveClasses.join(" ");
+  effectiveClasses.length = 0;
+  return className;
+};
+const 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;
+};
+const observeAncestorsMutation = (element, attributeFilter, callback) => {
+  const subscribe = observe(attributeFilter).subscribe;
+  return subscribe((mutations) => {
+    const matched = mutations.some((mutation) => inTargetElement(element, mutation.target));
+    if (matched) {
+      callback();
+    }
+  });
+};
+const observers = {};
+const 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)));
+  if (globalThis.document) {
+    mutationObserver.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter,
+      subtree: true
+    });
+  }
+  const observer = {
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+        if (subscribers.size === 0) {
+          mutationObserver.disconnect();
+          observers[attributes] = void 0;
+        }
+      };
+    }
+  };
+  observers[attributes] = observer;
+  return observer;
+};
+const getClosestElement = (base, selector) => {
+  let currentElement = base;
+  while (currentElement) {
+    const element = currentElement.closest?.(selector);
+    if (element) {
+      return element;
+    }
+    const rootElement = currentElement.getRootNode?.();
+    if (rootElement === globalThis.document) {
+      return;
+    }
+    currentElement = rootElement.host;
+  }
+  return;
+};
+function unsafeGetCalciteModeName(el) {
+  const closestElWithMode = getClosestElement(el, `.calcite-mode-dark, .calcite-mode-light, .calcite-mode-auto`);
+  return closestElWithMode?.classList.contains("calcite-mode-dark") || closestElWithMode?.classList.contains("calcite-mode-auto") && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+const unsafeGetElementDirection = (el) => (
+  //#endregion unsafeGetElementDirection
+  getElementAttribute(el, "dir", "ltr")
+);
+const getElementAttribute = (el, attributeName, fallbackValue) => {
+  const closest = getClosestElement(el, `[${attributeName}]`);
+  return closest?.getAttribute(attributeName) ?? fallbackValue;
+};
+const focusElement = async (el) => {
+  if (el == null) {
+    return;
+  }
+  if (hasSetFocus(el)) {
+    await el.setFocus();
+  } else {
+    el.focus();
+  }
+};
+const hasSetFocus = (ref) => typeof ref.setFocus === "function";
+const setFocusOnElement = (ref, selector) => {
+  if (!ref?.shadowRoot) {
+    return;
+  }
+  if (ref.hasAttribute("hydrated") || ref.hasAttribute("calcite-hydrated")) {
+    setFocus(ref, selector);
+    return;
+  }
+  void Promise.resolve(ref.componentOnReady?.()).then(() => setFocus(ref, selector));
+};
+const isElement = (ref) => ref.nodeType === Node.ELEMENT_NODE;
+const setFocus = (ref, selector = "") => {
+  if (!isElement(ref)) {
+    return false;
+  }
+  if (ref.matches(selector)) {
+    if (hasSetFocus(ref)) {
+      setTimeout(() => void 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;
+};
+export {
+  classes,
+  focusElement,
+  getClosestElement,
+  getElementAttribute,
+  observeAncestorsMutation,
+  setFocusOnElement,
+  unsafeGetCalciteModeName,
+  unsafeGetElementDirection
+};

package/dist/error/index.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isEsriInternalEnv = () => (
+  //#endregion isEsriInternalEnv
+  /*
+   * `globalThis.` is important here. Some bundlers remove the `typeof process`
+   * checks, but don't remove the usages of undefined variables - this can cause
+   * runtime error. By adding `globalThis.`, we avoid having `typeof process`
+   * check removed by the bundler.
+   * This does meant tree-shaking won't happen for the isEsriInternalEnv()
+   * check, but this is ok since this check is meant to always be behind the
+   * development/test guard.
+   * See https://devtopia.esri.com/WebGIS/arcgis-web-components/pull/2087#issuecomment-5152454
+   */
+  typeof globalThis.process === "object" && !!process.env.ESRI_INTERNAL
+);
+const safeCall = (callback, thisContext, ...rest) => {
+  try {
+    return callback?.call(thisContext, ...rest);
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+};
+const safeAsyncCall = async (callback, thisContext, ...rest) => {
+  try {
+    const result = callback?.call(thisContext, ...rest);
+    return await result;
+  } catch (error) {
+    console.error(error, callback);
+  }
+  return void 0;
+};
+exports.isEsriInternalEnv = isEsriInternalEnv;
+exports.safeAsyncCall = safeAsyncCall;
+exports.safeCall = safeCall;