@arcgis/toolkit 5.2.0-next.9 → 5.2.0-next.91

package/dist/intl/{index.js → dom.js}

@@ -1,5 +1,34 @@
-import { getElementAttribute, observeAncestorsMutation } from "../dom/index.js";
-import { log } from "../log/index.js";
+import { log } from "../log.js";
+import { g as getElementAttribute, o as observeAncestorsMutation } from "../dom-Bnc7oSYx.js";
+const getElementLocale$1 = (element) => {
+  const lang = getElementAttribute(element, "lang", globalThis.navigator?.language || defaultLocale);
+  return { lang, t9nLocale: normalizeLocale(lang) };
+};
+const startLocaleObserver$1 = (element, getAssetsPath, onUpdated, assetName) => {
+  let result = void 0;
+  const callback = () => updateComponentLocaleState(element, getAssetsPath(), assetName).then((newResult) => {
+    if (result?.lang !== newResult.lang || result.t9nLocale !== newResult.t9nLocale || result.t9nStrings !== newResult.t9nStrings) {
+      onUpdated(newResult);
+    }
+    result = newResult;
+  }).catch((error) => {
+    log("error", "intl", "Error updating component locale state", { detail: { error } });
+  });
+  queueMicrotask(callback);
+  return observeAncestorsMutation(element, ["lang"], callback);
+};
+const updateComponentLocaleState = async (element, assetsPath, assetName = element.localName.split("-").slice(1).join("-")) => {
+  const { lang, t9nLocale } = getElementLocale$1(element);
+  const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
+  const prefix = `messages.`;
+  const t9nStrings = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    assetName === null ? {} : await fetchT9nStringsBundle(t9nLocale, t9nAssetsPath, prefix)
+  );
+  return { lang, t9nLocale, t9nStrings };
+};
+const getElementLocale = getElementLocale$1;
+const startLocaleObserver = startLocaleObserver$1;
 const 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,no,pl,pt-BR,pt-PT,ro,ru,sk,sl,sr,sv,th,tr,uk,vi,zh-CN,zh-HK,zh-TW".split(
   ","
 );
@@ -17,7 +46,7 @@ const localeEquivalencies = {
   // We support both 'nb' and 'no' (BCP 47) for Norwegian but only `no` has corresponding bundle
   nb: "no",
   // We support both 'nn' and 'no' (BCP 47) for Norwegian but only `no` has corresponding bundle
-  // See https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/4667
+  // See https://devtopia.esri.com/WebGIS/webgis-sdk/issues/4667
   nn: "no",
   // We use `zh-CN` as base translation for chinese locales which has no corresponding bundle.
   zh: "zh-CN"
@@ -26,7 +55,7 @@ const localeEquivalencies = {
 const fetchT9nStringsBundle = async (locale, assetsPath, prefix = "") => {
   const path = `${assetsPath}/${prefix}`;
   const filePath = `${path}${locale}.json`;
-  t9nStringsCache[filePath] ?? (t9nStringsCache[filePath] = fetchBundle(locale, path));
+  t9nStringsCache[filePath] ??= fetchBundle(locale, path);
   return await t9nStringsCache[filePath];
 };
 const t9nStringsCache = {};
@@ -57,10 +86,6 @@ const fetchBundle = async (locale, path) => {
   }
   return await fetchBundle(defaultLocale, path);
 };
-const getElementLocale = (element) => {
-  const lang = getElementAttribute(element, "lang", globalThis.navigator?.language || defaultLocale);
-  return { lang, t9nLocale: normalizeLocale(lang) };
-};
 const normalizeLocale = (lang) => {
   const [rawLanguageCode, regionCode] = lang.split("-");
   const languageCode = rawLanguageCode.toLowerCase();
@@ -77,34 +102,13 @@ const normalizeLocale = (lang) => {
   }
   return defaultLocale;
 };
-const startLocaleObserver = (element, getAssetsPath, onUpdated, assetName) => {
-  let result = void 0;
-  const callback = () => updateComponentLocaleState(element, getAssetsPath(), assetName).then((newResult) => {
-    if (result?.lang !== newResult.lang || result.t9nLocale !== newResult.t9nLocale || result.t9nStrings !== newResult.t9nStrings) {
-      onUpdated(newResult);
-    }
-    result = newResult;
-  }).catch((error) => {
-    log("error", "intl", "Error updating component locale state", { detail: { error } });
-  });
-  queueMicrotask(callback);
-  return observeAncestorsMutation(element, ["lang"], callback);
-};
-const updateComponentLocaleState = async (element, assetsPath, assetName = element.localName.split("-").slice(1).join("-")) => {
-  const { lang, t9nLocale } = getElementLocale(element);
-  const t9nAssetsPath = `${assetsPath}/${assetName}/t9n`;
-  const prefix = `messages.`;
-  const t9nStrings = (
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    assetName === null ? {} : await fetchT9nStringsBundle(t9nLocale, t9nAssetsPath, prefix)
-  );
-  return { lang, t9nLocale, t9nStrings };
-};
 export {
-  defaultLocale,
-  fetchT9nStringsBundle,
-  getElementLocale,
-  normalizeLocale,
-  startLocaleObserver,
-  supportedLocales
+  supportedLocales as a,
+  defaultLocale as d,
+  fetchT9nStringsBundle as f,
+  getElementLocale as g,
+  getElementLocale$1 as getElementLocale,
+  normalizeLocale as n,
+  startLocaleObserver as s,
+  startLocaleObserver$1 as startLocaleObserver
 };

package/dist/intl.d.ts

@@ -0,0 +1,89 @@
+import { type LocaleObserverResult as LocaleObserverResultAlias } from "./intl/dom.ts";
+/**
+ * @public
+ * @deprecated import { getElementLocale } from "./intl/dom.ts" instead
+ */
+export declare const getElementLocale: (element: HTMLElement) => {
+    readonly lang: string;
+    readonly t9nLocale: SupportedLocale;
+};
+/**
+ * @public
+ * @deprecated import { startLocaleObserver } from "./intl/dom.ts" instead
+ */
+export declare const startLocaleObserver: <Strings extends GenericT9nStrings = GenericT9nStrings>(element: HTMLElement, getAssetsPath: () => string, onUpdated: (payload: LocaleObserverResultAlias<Strings>) => void, assetName?: string | null) => (() => void);
+/**
+ * @public
+ * @deprecated import type { LocaleObserverResult } from "./intl/dom.ts" instead
+ */
+export type LocaleObserverResult = LocaleObserverResultAlias;
+/**
+ * The list of supported locales for ArcGIS Maps SDK for JavaScript components.
+ *
+ * @public
+ */
+export declare const supportedLocales: Set<SupportedLocale>;
+/**
+ * TypeScript union type for each locale supported by WebGIS SDK
+ *
+ * @public
+ */
+export type SupportedLocale = "ar" | "bg" | "bs" | "ca" | "cs" | "da" | "de" | "el" | "en" | "es" | "et" | "fi" | "fr" | "he" | "hr" | "hu" | "id" | "it" | "ja" | "ko" | "lt" | "lv" | "nb" | "nl" | "no" | "pl" | "pt-BR" | "pt-PT" | "ro" | "ru" | "sk" | "sl" | "sr" | "sv" | "th" | "tr" | "uk" | "vi" | "zh-CN" | "zh-HK" | "zh-TW";
+/**
+ * The default locale for WebGIS SDK.
+ *
+ * @public
+ */
+export declare const defaultLocale = "en";
+/**
+ * Fetch the T9N strings bundle for the given locale, assets path and prefix.
+ * The locale must be one of the supported locales.
+ * If the locale is not supported, it will default to 'en'.
+ * If the T9N strings bundle cannot be found, it will default to 'en'.
+ *
+ * > Rather than using this function directly, prefer the
+ * > [useT9n()](https://webgis.esri.com/references/lumina/controllers/useT9n)
+ * > controller.
+ *
+ * > The function implements cache. Frequent calls are safe.
+ *
+ * @public
+ * @param locale The locale for which to fetch the T9N strings
+ * @param assetsPath The path to the assets folder where the T9N strings are located
+ * @param prefix The prefix to use for the T9N strings file name.
+ *
+ * @example
+ * ```ts
+ * // Will make a request for ./assets/coding-editor/t9n/messages.en.json
+ * const t9nStrings = await fetchT9nStringsBundle(
+ *   "en",
+ *   getAssetPath("./assets/coding-editor/t9n"),
+ *   "messages."
+ * );
+ * ```
+ *
+ * @see [Lumina asset handling](https://webgis.esri.com/references/lumina/assets)
+ */
+export declare const fetchT9nStringsBundle: <Strings extends GenericT9nStrings>(locale: string, assetsPath: string, prefix?: string) => Promise<Strings>;
+/**
+ * The interface for translated strings.
+ *
+ * @public
+ */
+export interface GenericT9nStrings {
+    /** @public */
+    [key: string]: GenericT9nStrings | string;
+}
+/**
+ * Try to parse any language string into one of the locales supported by WebGIS SDK.
+ *
+ * > Follows the ArcGIS Maps SDK for JavaScript locale support:
+ * > https://developers.arcgis.com/javascript/latest/localization/#locale-support
+ *
+ * > If language includes a region code, but we don't have a bundle for it, the
+ * > language is normalized to the language code only.
+ *
+ * @public
+ * @param lang
+ */
+export declare const normalizeLocale: (lang: string) => SupportedLocale;

package/dist/intl.js

@@ -0,0 +1,10 @@
+import "./log.js";
+import { d, f, g, n, s, a } from "./intl/dom.js";
+export {
+  d as defaultLocale,
+  f as fetchT9nStringsBundle,
+  g as getElementLocale,
+  n as normalizeLocale,
+  s as startLocaleObserver,
+  a as supportedLocales
+};

package/dist/{log/index.d.ts → log.d.ts}

@@ -1,4 +1,6 @@
+/** @public */
 export type LogLevel = "error" | "info" | "warn";
+/** @public */
 type CustomElementLike = {
     el: {
         localName: string;
@@ -6,17 +8,30 @@ type CustomElementLike = {
 } | {
     localName: string;
 };
+/** @public */
 type AccessorLike = {
     declaredClass: string;
 };
+/** @public */
 export type LogContext = AccessorLike | CustomElementLike | string;
+/** @public */
 type LogOptions = {
-    /** Whether the message should only be logged once. */
+    /**
+     * Whether the message should only be logged once.
+     *
+     * @public
+     */
     once?: boolean;
-    /** Additional objects to log after `message`. Use this to avoid memory leaks when logging objects to the console. Each object value will be automatically wrapped in a `WeakRef` before logging so it can be garbage-collected. */
+    /**
+     * Additional objects to log after `message`. Use this to avoid memory leaks when logging objects to the console. Each object value will be automatically wrapped in a `WeakRef` before logging so it can be garbage-collected.
+     *
+     * @public
+     */
     detail?: Record<string, unknown>;
 };
+/** @public */
 type EsriConfig = {
+    /** @public */
     log: {
         /**
          * @link {https://developers.arcgis.com/javascript/latest/references/core/config/#LogInterceptor}
@@ -25,9 +40,11 @@ type EsriConfig = {
     };
 };
 /**
- * Workaround for setting {@link https://developers.arcgis.com/javascript/latest/references/core/config/#log log interceptors} and maintaining compatibility with {@link https://devtopia.esri.com/WebGIS/arcgis-websceneviewer-app/blob/8f0a1bbcf12d1193134d94589d9e187f0afa72fa/src/js/support/ApiLoggerInstrumentation.ts#L17 js-api's interceptor usage}.
- * @see {@link https://devtopia.esri.com/WebGIS/arcgis-js-api/discussions/74935}
- * @param config {@link https://developers.arcgis.com/javascript/latest/references/core/config/}
+ * Workaround for setting [log interceptors](https://developers.arcgis.com/javascript/latest/references/core/config/#log) and maintaining compatibility with [js-api's interceptor usage](https://devtopia.esri.com/WebGIS/arcgis-websceneviewer-app/blob/8f0a1bbcf12d1193134d94589d9e187f0afa72fa/src/js/support/ApiLoggerInstrumentation.ts#L17).
+ * @see https://devtopia.esri.com/WebGIS/arcgis-js-api/discussions/74935
+ *
+ * @public
+ * @param config https://developers.arcgis.com/javascript/latest/references/core/config/
  * @example
  * ```ts
  * // IMPORTANT: do this only in config.ts or another early-loaded module
@@ -45,12 +62,13 @@ export declare const setEsriConfig: (config: EsriConfig) => void;
 /**
  * Helper utility for logging messages in a consistent manner.
  *
+ * @public
  * @param level The log level
  * @param context The context of the log message (e.g., `this` inside a Lit-like component, or just a custom string)
  * @param message A custom message to log
  * @param options Additional options for logging, such as to provide a context object
  *
- * @see [setEsriConfig](#setEsriConfig)
+ * @see {@link log!setEsriConfig}
  *
  * @example
  * ```ts
@@ -71,6 +89,7 @@ export declare const log: (level: LogLevel, context: LogContext, message: string
  * Rethrows an error and prepends context information to the error message. The error is
  * thrown asynchronously to avoid interrupting the current execution stack, so it cannot be caught
  * with `try/catch` and will bubble to the global object.
+ * @public
  * @param context From where the error is being thrown (e.g., `this` inside a Lit-like component, or just a custom string)
  * @returns A function that can be used in `try-catch`/`.catch` to rethrow an error
  *
@@ -89,10 +108,17 @@ export declare const log: (level: LogLevel, context: LogContext, message: string
  * ```
  */
 export declare const rethrowError: (context: LogContext) => ((error: unknown) => void);
+/** @public */
 type LogContextOrObject = Exclude<LogContext, string> | object;
+/**
+ * @public
+ * @privateRemarks
+ * https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+ */
 type InferPropertyType<T extends LogContextOrObject> = [object] extends [T] ? string : keyof T;
 /**
  * Returns a string that can be used in log messages for missing required properties.
+ * @public
  * @param property The name of the required property
  * @example
  * ```ts
@@ -105,6 +131,7 @@ type InferPropertyType<T extends LogContextOrObject> = [object] extends [T] ? st
 export declare const composeMissingPropertyMessage: <T extends LogContextOrObject = object>(property: InferPropertyType<T>) => string;
 /**
  * Returns a string that can be used in log messages for empty required arrays.
+ * @public
  * @param property The name of the required property
  * @example
  * ```ts
@@ -117,6 +144,11 @@ export declare const composeMissingPropertyMessage: <T extends LogContextOrObjec
 export declare const composeEmptyPropertyMessage: <T extends LogContextOrObject = object>(property: InferPropertyType<T>) => string;
 /**
  * Logs a warning message for deprecated object properties.
+ * @public
+ * @param context
+ * @param oldName
+ * @param newName
+ * @param options
  * @example
  * ```ts
  * logDeprecatedProperty(this, "oldName", "newName", {

package/dist/{number/index.d.cts → number.d.ts}

@@ -1,16 +1,17 @@
 /**
  * Clamps a value between a minimum and maximum value.
  *
+ * @public
  * @param value The number to clamp.
  * @param min The minimum value.
  * @param max The maximum value.
- *
  * @returns The clamped value.
  */
 export declare function clamp(value: number, min: number, max: number): number;
 /**
  * Linearly interpolates between two numbers.
  *
+ * @public
  * @param min - The start value.
  * @param max - The end value.
  * @param t - The interpolation factor, typically between 0 and 1.

package/dist/predicate.d.ts

@@ -0,0 +1,27 @@
+import type { nil } from "./type.ts";
+/**
+ * Safeguard to ensure that an value is not undefined.
+ * @public
+ * @param value The value to check.
+ * @returns Returns true if the value is not undefined.
+ * @example
+ * ```ts
+ * const arr = [1, undefined, 3];
+ * const result = arr.filter(isNotUndefined);
+ * ```
+ */
+export declare const isNotUndefined: <T>(value: T | undefined) => value is T;
+/**
+ * Safeguard to ensure that an value is not null.
+ * @public
+ * @param value The value to check.
+ * @returns Returns true if the value is not null.
+ */
+export declare const isNotNull: <T>(value: T | null) => value is T;
+/**
+ * Safeguard to ensure that an value is not null or undefined.
+ * @public
+ * @param value The value to check.
+ * @returns Returns true if the value is not undefined and not null.
+ */
+export declare const isNotNil: <T>(value: nil | T) => value is T;

package/dist/predicate.js

@@ -0,0 +1,8 @@
+const isNotUndefined = (value) => value !== void 0;
+const isNotNull = (value) => value !== null;
+const isNotNil = (value) => value != null;
+export {
+  isNotNil,
+  isNotNull,
+  isNotUndefined
+};

package/dist/{promise/index.d.ts → promise.d.ts}

@@ -2,6 +2,7 @@
  * A deferred promise.
  * Useful for when you want to return a promise but don't have the value yet.
  *
+ * @public
  * @example
  * ```ts
  * const deferred = new Deferred<string>();
@@ -11,29 +12,36 @@
  *
  * @deprecated
  * If browser support permits, prefer using
- * [Promise.withResolvers()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers)
+ * [Promise.withResolvers()](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers)
  */
 export declare class Deferred<T> {
     /**
      * The promise that can be awaited.
+     * @public
      */
     promise: Promise<T>;
     /**
      * Creates a new deferred promise.
+     *
+     * @public
      */
     constructor();
 }
+/** @public */
 export interface Deferred<T> {
     /**
      * Resolves the promise.
+     * @public
      * @param value The value to resolve the promise with.
-     *
      * @privateRemarks
      * Defined as a method to disable covariance checks. Overridden in constructor.
      */
     resolve(_value: PromiseLike<T> | T): void;
     /**
      * Rejects the promise.
+     *
+     * @public
+     * @param error
      */
     reject(_error: unknown): void;
 }
@@ -42,6 +50,10 @@ export interface Deferred<T> {
  * operations.
  * Useful for rate-limiting or to avoid overwhelming resources with too many concurrent operations.
  *
+ * @public
+ * @param items
+ * @param concurrency
+ * @param callback
  * @example
  * ```ts
  * const items = [...lotsOfItems];
@@ -55,6 +67,9 @@ export declare function forEachWithConcurrency<T>(items: readonly T[], concurren
  * Like setTimeout(), but does not advance the clock if the program is
  * stopped on a debugger breakpoint.
  *
+ * @public
+ * @param callback
+ * @param timeout
  * @see https://devtopia.esri.com/WebGIS/arcgis-js-api/discussions/60405
  */
 export declare const devToolsAwareTimeout: (callback: () => void, timeout: number) => ReturnType<typeof setInterval>;

package/dist/{promise/index.js → promise.js}

@@ -1,6 +1,8 @@
 class Deferred {
   /**
    * Creates a new deferred promise.
+   *
+   * @public
    */
   constructor() {
     this.promise = new Promise((resolve, reject) => {

package/dist/{string/index.d.ts → string.d.ts}

@@ -1,6 +1,8 @@
 /**
  * Convert kebab-case string to PascalCase
  *
+ * @public
+ * @param string
  * @example
  * ```ts
  * const pascal = kebabToPascal("my-component-name");
@@ -10,6 +12,8 @@ export declare const kebabToPascal: (string: string) => string;
 /**
  * Convert camelCase string to kebab-case
  *
+ * @public
+ * @param string
  * @example
  * ```ts
  * const kebab = camelToKebab("myComponentName");
@@ -20,6 +24,8 @@ export declare const camelToKebab: (string: string) => string;
 /**
  * Convert camelCase string to Sentence case.
  *
+ * @public
+ * @param string
  * @example
  * ```ts
  * const human = camelToHuman("myComponentName");
@@ -27,26 +33,44 @@ export declare const camelToKebab: (string: string) => string;
  * ```
  */
 export declare const camelToHuman: (string: string) => string;
-/** Capitalize the first letter of a string. */
+/**
+ * Capitalize the first letter of a string.
+ *
+ * @public
+ * @param string
+ */
 export declare const capitalize: <T extends string>(string: T) => Capitalize<T>;
-/** Uncapitalize the first letter of a string. */
+/**
+ * Uncapitalize the first letter of a string.
+ *
+ * @public
+ * @param string
+ */
 export declare const uncapitalize: <T extends string>(string: T) => Uncapitalize<T>;
 /**
  * Add quotes to a string for display purposes.
  * If the string contains a double quote, then single quotes will be used.
  * If the string contains a single quote, then double quotes will be used.
  * If the string contains both, then double quotes will be used and the single quotes will be escaped.
+ *
+ * @public
+ * @param value
  */
 export declare const quoteString: (value: string) => string;
 /**
  * Create a filter expression from a filter word.
  *
- * @remarks Once browser support permits, use `RegExp.escape()` instead.
+ * > Once browser support permits, use `RegExp.escape()` instead.
+ *
+ * @public
+ * @param filterWord
  * @privateRemarks TODO: DEPRECATE
  */
 export declare const createFilterExpression: (filterWord: string) => RegExp;
 /**
  * Add LTR marks to a string to ensure it is displayed as LTR even in RTL contexts.
+ *
+ * @public
  * @param value The string to add LTR marks to.
  * @returns The string with LTR marks.
  *
@@ -58,6 +82,8 @@ export declare const createFilterExpression: (filterWord: string) => RegExp;
 export declare const addLtrMark: (value: string | undefined) => string;
 /**
  * A string containing a randomly generated, 36 character long v4 UUID.
+ *
+ * @public
  */
 export type UUID = ReturnType<typeof crypto.randomUUID>;
 /**
@@ -69,6 +95,7 @@ export type UUID = ReturnType<typeof crypto.randomUUID>;
  * Avoid using GUID and other non-deterministic output in render() as they
  * cause SSR hydration issues and snapshot test instability.
  *
+ * @public
  * @example
  * ```ts
  * const id = generateGuid();
@@ -79,6 +106,8 @@ export declare const generateGuid: () => UUID;
 /**
  * Extract the major and minor version from a full version string.
  *
+ * @public
+ * @param version
  * @example
  * ```ts
  * const minorVersion = getMinorVersion("4.34.0-next.123");
@@ -93,6 +122,8 @@ export declare const getMinorVersion: (version: string) => string;
  * The version number should normally come from package.json.
  *
  * @see https://webgis.esri.com/sdk/contributing/licensing
+ * @public
+ * @param version
  * @example
  * ```ts
  * const preamble = getPreamble("5.0.1-next.456");
@@ -104,6 +135,9 @@ export declare const getPreamble: (version: string) => string;
  * Replace values in a string using the format {valueName} with the value from the values object.
  * If the value is not found in the values object, then the value is not replaced.
  *
+ * @public
+ * @param message
+ * @param values
  * @deprecated Import from https://next.gha.afd.arcgis.com/javascript/latest/references/core/intl/#substitute instead
  */
 export declare const setValuesInString: (message: string | null | undefined, values?: Record<string, string>) => string;
@@ -113,6 +147,9 @@ export declare const setValuesInString: (message: string | null | undefined, val
  *
  * Throws when the named region cannot be found or is missing its closing marker.
  *
+ * @public
+ * @param source
+ * @param regionName
  * @example
  * ```ts
  * import code from "my-code-file.ts?raw";

package/dist/{type/index.d.cts → type.d.ts}

@@ -1,15 +1,24 @@
 /**
  * A convenient alias for `null | undefined`.
- * @remarks Named `nil` over `Nil` as per https://devtopia.esri.com/WebGIS/arcgis-js-api/pull/66920
+ *
+ * > Named `nil` over `Nil` as per https://devtopia.esri.com/WebGIS/arcgis-js-api/pull/66920
+ *
+ * @public
  */
 export type nil = null | undefined;
 /**
+ * @public
  * @deprecated import type { ResourceHandle } from "@arcgis/core/core/Handles.js";
  */
 export type IHandle = {
+    /**
+     * @public
+     * @deprecated import type { ResourceHandle } from "@arcgis/core/core/Handles.js";
+     */
     remove: () => void;
 };
 /**
+ * @public
  * @deprecated Import type { nil } from `@arcgis/toolkit/type` instead
  */
 export type Nil = nil;
@@ -23,6 +32,7 @@ export type Nil = nil;
  * During production end-application build, such type tests will be removed as
  * they have no runtime impact.
  *
+ * @public
  * @privateRemarks
  * Using `0` over `undefined` to take fewer bytes if minifier is disabled.
  */

package/dist/{url/index.d.cts → url.d.ts}

@@ -1,6 +1,7 @@
 /**
  * Compares two url strings for their origin and returns true if they have the same origin.
  *
+ * @public
  * @param url1 First url string
  * @param url2 Second url string
  * @param ignoreProtocol Indicates if protocol comparison should be ignored
@@ -9,10 +10,10 @@
 export declare const hasSameOrigin: (url1: string | null | undefined, url2: string | null | undefined, ignoreProtocol?: boolean) => boolean;
 /**
  * Tests if a url string is a URL or not.
+ *
+ * @public
+ * @deprecated Use https://developer.mozilla.org/docs/Web/API/URL/parse_static instead
  * @param url The url string to test
  * @returns True if the string is a URL.
- *
- * @remarks If browser support permits, use https://developer.mozilla.org/en-US/docs/Web/API/URL/parse_static instead
- * @privateRemarks TODO: DEPRECATE
  */
 export declare const isURL: (url: string) => boolean;