@odx/angular 6.0.0 → 6.1.0

package/esm2022/localization/lib/localization.service.mjs

@@ -8,16 +8,48 @@ export class LocalizationService {
         this.localizationConfig = injectLocalizationConfig();
         this.injector = inject(Injector);
         this.localeState$ = new BehaviorSubject(new Intl.Locale(this.localizationConfig.availableLanguages[0]));
+        /**
+         * Represents an observable stream of the active language in the localization service.
+         * The active language is determined by the locale state.
+         *
+         * @emits {string} The active language.
+         */
         this.activeLanguage$ = this.localeState$.pipe(filter(Boolean), map((x) => x.baseName), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+        /**
+         * Gets the list of available languages for localization.
+         *
+         * @type {string[]} The list of available languages.
+         */
         this.availableLanguages = this.localizationConfig.availableLanguages;
+        /** Default language derived from the first entry in the available languages list.
+         *
+         * @type {string}
+         */
         this.defaultLanguage = this.availableLanguages[0];
     }
+    /**
+     * Retrieves the currently active language. Falls back to the default language if
+     * no active language is set.
+     *
+     * @returns {string} Full locale name e.g. 'en-US' or just 'en' if no region info is attached.
+     */
     getActiveLanguage() {
-        return this.localeState$.getValue()?.baseName ?? new Intl.Locale(this.defaultLanguage).baseName; // returns full locale name e.g. 'en-US' or just 'en' if no region info is attached
+        return this.localeState$.getValue()?.baseName ?? new Intl.Locale(this.defaultLanguage).baseName;
     }
+    /**
+     * Retrieves the active language subtag.
+     *
+     * @returns {string} The two-digit language subtag, e.g. 'en', 'fr'.
+     */
     getActiveLanguageSubtag() {
-        return this.localeState$.getValue()?.language ?? new Intl.Locale(this.defaultLanguage).language; // returns two digits language subtag, e.g. 'en', 'fr'
+        return this.localeState$.getValue()?.language ?? new Intl.Locale(this.defaultLanguage).language;
     }
+    /**
+     * Sets the active language based on the provided language code. If the language is not
+     * recognized, it logs an error and does not change the active language.
+     *
+     * @param {string} language The language code to set as the active language.
+     */
     setActiveLanguage(language) {
         try {
             const locale = new Intl.Locale(language);
@@ -32,6 +64,13 @@ export class LocalizationService {
             logger.error(error);
         }
     }
+    /**
+     * Loads the active language for the localization service.
+     * This method runs in an injection context and sets the active language based on the result of the active language loader.
+     * If the active language loader fails, the default language is set as the active language.
+     *
+     * @returns {Promise<void>} A promise that resolves when the active language is loaded and set.
+     */
     async loadActiveLanguage() {
         return runInInjectionContext(this.injector, async () => {
             const activeLanguageLoader$ = this.createActiveLanguageLoader$();
@@ -56,4 +95,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.service.js","sourceRoot":"","sources":["../../../../../../libs/angular/localization/src/lib/localization.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,eAAe,EAAc,oBAAoB,EAAE,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,EAAE,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAC3I,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,MAAM,MAAM,uBAAuB,CAAC;;AAG3C,MAAM,OAAO,mBAAmB;IADhC;QAEmB,uBAAkB,GAAG,wBAAwB,EAAE,CAAC;QAChD,aAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5B,iBAAY,GAAG,IAAI,eAAe,CAA0B,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE7I;;;;;WAKG;QACa,oBAAe,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CACtD,MAAM,CAAC,OAAO,CAAC,EACf,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EACtB,oBAAoB,EAAE,EACtB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAC/C,CAAC;QAEF;;;;WAIG;QACa,uBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC;QAEhF;;;WAGG;QACa,oBAAe,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;KAiE9D;IA/DC;;;;;OAKG;IACI,iBAAiB;QACtB,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,QAAQ,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC;IAClG,CAAC;IAED;;;;OAIG;IACI,uBAAuB;QAC5B,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,QAAQ,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC;IAClG,CAAC;IAED;;;;;OAKG;IACI,iBAAiB,CAAC,QAAgB;QACvC,IAAI;YACF,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACzC,IAAI,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;gBAC1G,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAChC;iBAAM;gBACL,MAAM,IAAI,KAAK,CAAC,4BAA4B,QAAQ,mFAAmF,CAAC,CAAC;aAC1I;SACF;QAAC,OAAO,KAAK,EAAE;YACd,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;SACrB;IACH,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,kBAAkB;QAC7B,OAAO,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;YACrD,MAAM,qBAAqB,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;YACjE,MAAM,cAAc,GAAG,MAAM,cAAc,CAAC,qBAAqB,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;YACrF,IAAI,CAAC,iBAAiB,CAAC,cAAc,IAAI,IAAI,CAAC,eAAe,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,2BAA2B;QACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,oBAAoB,EAAE,EAAE,CAAC;QAClE,IAAI,YAAY,CAAC,QAAQ,CAAC,EAAE;YAC1B,OAAO,QAAQ,CAAC;SACjB;QACD,IAAI,QAAQ,YAAY,OAAO,EAAE;YAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC;SACvB;QACD,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC;IACtB,CAAC;+GA7FU,mBAAmB;mHAAnB,mBAAmB,cADN,MAAM;;4FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable, Injector, inject, runInInjectionContext } from '@angular/core';\nimport { BehaviorSubject, Observable, distinctUntilChanged, filter, firstValueFrom, from, isObservable, map, of, shareReplay } from 'rxjs';\nimport { injectLocalizationConfig } from './localization.config';\nimport logger from './localization.logger';\n\n@Injectable({ providedIn: 'root' })\nexport class LocalizationService {\n  private readonly localizationConfig = injectLocalizationConfig();\n  private readonly injector = inject(Injector);\n  private readonly localeState$ = new BehaviorSubject<Intl.Locale | undefined>(new Intl.Locale(this.localizationConfig.availableLanguages[0]));\n\n  /**\n   * Represents an observable stream of the active language in the localization service.\n   * The active language is determined by the locale state.\n   *\n   * @emits {string} The active language.\n   */\n  public readonly activeLanguage$ = this.localeState$.pipe(\n    filter(Boolean),\n    map((x) => x.baseName),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Gets the list of available languages for localization.\n   *\n   * @type {string[]} The list of available languages.\n   */\n  public readonly availableLanguages = this.localizationConfig.availableLanguages;\n\n  /** Default language derived from the first entry in the available languages list.\n   *\n   * @type {string}\n   */\n  public readonly defaultLanguage = this.availableLanguages[0];\n\n  /**\n   * Retrieves the currently active language. Falls back to the default language if\n   * no active language is set.\n   *\n   * @returns {string} Full locale name e.g. 'en-US' or just 'en' if no region info is attached.\n   */\n  public getActiveLanguage(): string {\n    return this.localeState$.getValue()?.baseName ?? new Intl.Locale(this.defaultLanguage).baseName;\n  }\n\n  /**\n   * Retrieves the active language subtag.\n   *\n   * @returns {string} The two-digit language subtag, e.g. 'en', 'fr'.\n   */\n  public getActiveLanguageSubtag(): string {\n    return this.localeState$.getValue()?.language ?? new Intl.Locale(this.defaultLanguage).language;\n  }\n\n  /**\n   * Sets the active language based on the provided language code. If the language is not\n   * recognized, it logs an error and does not change the active language.\n   *\n   * @param {string} language The language code to set as the active language.\n   */\n  public setActiveLanguage(language: string): void {\n    try {\n      const locale = new Intl.Locale(language);\n      if (this.availableLanguages.includes(locale.baseName) || this.availableLanguages.includes(locale.language)) {\n        this.localeState$.next(locale);\n      } else {\n        throw new Error(`Unrecognizable language '${language}'. Make sure it's a part of availableLanguages inside LocalizationService config.`);\n      }\n    } catch (error) {\n      logger.error(error);\n    }\n  }\n\n  /**\n   * Loads the active language for the localization service.\n   * This method runs in an injection context and sets the active language based on the result of the active language loader.\n   * If the active language loader fails, the default language is set as the active language.\n   *\n   * @returns {Promise<void>} A promise that resolves when the active language is loaded and set.\n   */\n  public async loadActiveLanguage(): Promise<void> {\n    return runInInjectionContext(this.injector, async () => {\n      const activeLanguageLoader$ = this.createActiveLanguageLoader$();\n      const activeLanguage = await firstValueFrom(activeLanguageLoader$).catch(() => null);\n      this.setActiveLanguage(activeLanguage ?? this.defaultLanguage);\n    });\n  }\n\n  private createActiveLanguageLoader$(): Observable<string | undefined> {\n    const language = this.localizationConfig.activeLanguageLoader?.();\n    if (isObservable(language)) {\n      return language;\n    }\n    if (language instanceof Promise) {\n      return from(language);\n    }\n    return of(language);\n  }\n}\n"]}

package/esm2022/localization/lib/models/localization-feature.mjs

@@ -1,4 +1,11 @@
+/**
+ * @internal
+ * Creates a feature provider for the localization module.
+ *
+ * @param {Provider[] | EnvironmentProviders} provider - The providers to be used for the localization feature.
+ * @returns {LocalizationFeature} The localization feature provider.
+ */
 export function makeLocalizationFeature(provider) {
     return provider;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemF0aW9uLWZlYXR1cmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvbG9jYWxpemF0aW9uL3NyYy9saWIvbW9kZWxzL2xvY2FsaXphdGlvbi1mZWF0dXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sVUFBVSx1QkFBdUIsQ0FBQyxRQUEyQztJQUNqRixPQUFPLFFBQXdDLENBQUM7QUFDbEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVudmlyb25tZW50UHJvdmlkZXJzLCBQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgdHlwZSBMb2NhbGl6YXRpb25GZWF0dXJlID0gRW52aXJvbm1lbnRQcm92aWRlcnMgJiB7IMm1b2R4QnJhbmQ6ICdAb2R4L2FuZ3VsYXIvbG9jYWxpemF0aW9uOjpMb2NhbGl6YXRpb25GZWF0dXJlJyB9O1xuXG5leHBvcnQgZnVuY3Rpb24gbWFrZUxvY2FsaXphdGlvbkZlYXR1cmUocHJvdmlkZXI6IFByb3ZpZGVyW10gfCBFbnZpcm9ubWVudFByb3ZpZGVycyk6IExvY2FsaXphdGlvbkZlYXR1cmUge1xuICByZXR1cm4gcHJvdmlkZXIgYXMgbmV2ZXIgYXMgTG9jYWxpemF0aW9uRmVhdHVyZTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemF0aW9uLWZlYXR1cmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvbG9jYWxpemF0aW9uL3NyYy9saWIvbW9kZWxzL2xvY2FsaXphdGlvbi1mZWF0dXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSx1QkFBdUIsQ0FBQyxRQUEyQztJQUNqRixPQUFPLFFBQXdDLENBQUM7QUFDbEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVudmlyb25tZW50UHJvdmlkZXJzLCBQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgdHlwZSBMb2NhbGl6YXRpb25GZWF0dXJlID0gRW52aXJvbm1lbnRQcm92aWRlcnMgJiB7IMm1b2R4QnJhbmQ6ICdAb2R4L2FuZ3VsYXIvbG9jYWxpemF0aW9uOjpMb2NhbGl6YXRpb25GZWF0dXJlJyB9O1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICogQ3JlYXRlcyBhIGZlYXR1cmUgcHJvdmlkZXIgZm9yIHRoZSBsb2NhbGl6YXRpb24gbW9kdWxlLlxuICpcbiAqIEBwYXJhbSB7UHJvdmlkZXJbXSB8IEVudmlyb25tZW50UHJvdmlkZXJzfSBwcm92aWRlciAtIFRoZSBwcm92aWRlcnMgdG8gYmUgdXNlZCBmb3IgdGhlIGxvY2FsaXphdGlvbiBmZWF0dXJlLlxuICogQHJldHVybnMge0xvY2FsaXphdGlvbkZlYXR1cmV9IFRoZSBsb2NhbGl6YXRpb24gZmVhdHVyZSBwcm92aWRlci5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1ha2VMb2NhbGl6YXRpb25GZWF0dXJlKHByb3ZpZGVyOiBQcm92aWRlcltdIHwgRW52aXJvbm1lbnRQcm92aWRlcnMpOiBMb2NhbGl6YXRpb25GZWF0dXJlIHtcbiAgcmV0dXJuIHByb3ZpZGVyIGFzIG5ldmVyIGFzIExvY2FsaXphdGlvbkZlYXR1cmU7XG59XG4iXX0=

package/esm2022/rxjs/index.mjs

@@ -1,6 +1,6 @@
 export * from './lib/delay-until';
-export * from './lib/form-query-list';
 export * from './lib/from-element-mutation';
 export * from './lib/from-element-resize';
 export * from './lib/from-events';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvcnhqcy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvZGVsYXktdW50aWwnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZm9ybS1xdWVyeS1saXN0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Zyb20tZWxlbWVudC1tdXRhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9mcm9tLWVsZW1lbnQtcmVzaXplJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Zyb20tZXZlbnRzJztcbiJdfQ==
+export * from './lib/from-query-list';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvcnhqcy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvZGVsYXktdW50aWwnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZnJvbS1lbGVtZW50LW11dGF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Zyb20tZWxlbWVudC1yZXNpemUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZnJvbS1ldmVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZnJvbS1xdWVyeS1saXN0JztcbiJdfQ==

package/esm2022/rxjs/lib/delay-until.mjs

@@ -1,5 +1,27 @@
 import { map, switchMap, takeUntil, timer } from 'rxjs';
+/**
+ * Delays the emission of each value from the source Observable by a time span determined by the `delay` function.
+ * If the `notifier` Observable emits before the delay expires, the delayed emission is cancelled.
+ *
+ * This operator is useful for postponing the observable emissions until certain conditions are met,
+ * represented by the passage of time defined by `delay`. It also allows for a way to preemptively
+ * cancel the delay in response to another observable's emission.
+ *
+ * @template T The type of items emitted by the source Observable.
+ * @param {() => number} delay A function that returns the delay (in milliseconds) before the source Observable's values are emitted.
+ * @param {Observable<unknown>} notifier An Observable that cancels the delay when it emits.
+ * @returns {MonoTypeOperatorFunction<T>} An Observable that emits the source Observable's items with a delay if not cancelled.
+ * @example
+ * ```ts
+ * // Delay each number emission by 1 second, unless the 'cancel' button is clicked.
+ * const delayedNumbers$ = of(1, 2, 3).pipe(
+ *   delayUntil(() => 1000, fromEvent(cancelButton, 'click'))
+ * );
+ *
+ * delayedNumbers$.subscribe(console.log);
+ * ```
+ */
 export function delayUntil(delay, notifier) {
     return (source$) => source$.pipe(switchMap((value) => timer(delay()).pipe(map(() => value), takeUntil(notifier))));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXktdW50aWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvcnhqcy9zcmMvbGliL2RlbGF5LXVudGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxHQUFHLEVBQXdDLFNBQVMsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRTlGLE1BQU0sVUFBVSxVQUFVLENBQUksS0FBbUIsRUFBRSxRQUE2QjtJQUM5RSxPQUFPLENBQUMsT0FBc0IsRUFBRSxFQUFFLENBQ2hDLE9BQU8sQ0FBQyxJQUFJLENBQ1YsU0FBUyxDQUFDLENBQUMsS0FBUSxFQUFFLEVBQUUsQ0FDckIsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUMsSUFBSSxDQUNqQixHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsS0FBSyxDQUFDLEVBQ2hCLFNBQVMsQ0FBQyxRQUFRLENBQUMsQ0FDcEIsQ0FDRixDQUNGLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbWFwLCBNb25vVHlwZU9wZXJhdG9yRnVuY3Rpb24sIE9ic2VydmFibGUsIHN3aXRjaE1hcCwgdGFrZVVudGlsLCB0aW1lciB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgZnVuY3Rpb24gZGVsYXlVbnRpbDxUPihkZWxheTogKCkgPT4gbnVtYmVyLCBub3RpZmllcjogT2JzZXJ2YWJsZTx1bmtub3duPik6IE1vbm9UeXBlT3BlcmF0b3JGdW5jdGlvbjxUPiB7XG4gIHJldHVybiAoc291cmNlJDogT2JzZXJ2YWJsZTxUPikgPT5cbiAgICBzb3VyY2UkLnBpcGUoXG4gICAgICBzd2l0Y2hNYXAoKHZhbHVlOiBUKSA9PlxuICAgICAgICB0aW1lcihkZWxheSgpKS5waXBlKFxuICAgICAgICAgIG1hcCgoKSA9PiB2YWx1ZSksXG4gICAgICAgICAgdGFrZVVudGlsKG5vdGlmaWVyKVxuICAgICAgICApXG4gICAgICApXG4gICAgKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsYXktdW50aWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvcnhqcy9zcmMvbGliL2RlbGF5LXVudGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxHQUFHLEVBQXdDLFNBQVMsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRTlGOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FxQkc7QUFDSCxNQUFNLFVBQVUsVUFBVSxDQUFJLEtBQW1CLEVBQUUsUUFBNkI7SUFDOUUsT0FBTyxDQUFDLE9BQXNCLEVBQUUsRUFBRSxDQUNoQyxPQUFPLENBQUMsSUFBSSxDQUNWLFNBQVMsQ0FBQyxDQUFDLEtBQVEsRUFBRSxFQUFFLENBQ3JCLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FDakIsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLEtBQUssQ0FBQyxFQUNoQixTQUFTLENBQUMsUUFBUSxDQUFDLENBQ3BCLENBQ0YsQ0FDRixDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG1hcCwgTW9ub1R5cGVPcGVyYXRvckZ1bmN0aW9uLCBPYnNlcnZhYmxlLCBzd2l0Y2hNYXAsIHRha2VVbnRpbCwgdGltZXIgfSBmcm9tICdyeGpzJztcblxuLyoqXG4gKiBEZWxheXMgdGhlIGVtaXNzaW9uIG9mIGVhY2ggdmFsdWUgZnJvbSB0aGUgc291cmNlIE9ic2VydmFibGUgYnkgYSB0aW1lIHNwYW4gZGV0ZXJtaW5lZCBieSB0aGUgYGRlbGF5YCBmdW5jdGlvbi5cbiAqIElmIHRoZSBgbm90aWZpZXJgIE9ic2VydmFibGUgZW1pdHMgYmVmb3JlIHRoZSBkZWxheSBleHBpcmVzLCB0aGUgZGVsYXllZCBlbWlzc2lvbiBpcyBjYW5jZWxsZWQuXG4gKlxuICogVGhpcyBvcGVyYXRvciBpcyB1c2VmdWwgZm9yIHBvc3Rwb25pbmcgdGhlIG9ic2VydmFibGUgZW1pc3Npb25zIHVudGlsIGNlcnRhaW4gY29uZGl0aW9ucyBhcmUgbWV0LFxuICogcmVwcmVzZW50ZWQgYnkgdGhlIHBhc3NhZ2Ugb2YgdGltZSBkZWZpbmVkIGJ5IGBkZWxheWAuIEl0IGFsc28gYWxsb3dzIGZvciBhIHdheSB0byBwcmVlbXB0aXZlbHlcbiAqIGNhbmNlbCB0aGUgZGVsYXkgaW4gcmVzcG9uc2UgdG8gYW5vdGhlciBvYnNlcnZhYmxlJ3MgZW1pc3Npb24uXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgb2YgaXRlbXMgZW1pdHRlZCBieSB0aGUgc291cmNlIE9ic2VydmFibGUuXG4gKiBAcGFyYW0geygpID0+IG51bWJlcn0gZGVsYXkgQSBmdW5jdGlvbiB0aGF0IHJldHVybnMgdGhlIGRlbGF5IChpbiBtaWxsaXNlY29uZHMpIGJlZm9yZSB0aGUgc291cmNlIE9ic2VydmFibGUncyB2YWx1ZXMgYXJlIGVtaXR0ZWQuXG4gKiBAcGFyYW0ge09ic2VydmFibGU8dW5rbm93bj59IG5vdGlmaWVyIEFuIE9ic2VydmFibGUgdGhhdCBjYW5jZWxzIHRoZSBkZWxheSB3aGVuIGl0IGVtaXRzLlxuICogQHJldHVybnMge01vbm9UeXBlT3BlcmF0b3JGdW5jdGlvbjxUPn0gQW4gT2JzZXJ2YWJsZSB0aGF0IGVtaXRzIHRoZSBzb3VyY2UgT2JzZXJ2YWJsZSdzIGl0ZW1zIHdpdGggYSBkZWxheSBpZiBub3QgY2FuY2VsbGVkLlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiAvLyBEZWxheSBlYWNoIG51bWJlciBlbWlzc2lvbiBieSAxIHNlY29uZCwgdW5sZXNzIHRoZSAnY2FuY2VsJyBidXR0b24gaXMgY2xpY2tlZC5cbiAqIGNvbnN0IGRlbGF5ZWROdW1iZXJzJCA9IG9mKDEsIDIsIDMpLnBpcGUoXG4gKiAgIGRlbGF5VW50aWwoKCkgPT4gMTAwMCwgZnJvbUV2ZW50KGNhbmNlbEJ1dHRvbiwgJ2NsaWNrJykpXG4gKiApO1xuICpcbiAqIGRlbGF5ZWROdW1iZXJzJC5zdWJzY3JpYmUoY29uc29sZS5sb2cpO1xuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWxheVVudGlsPFQ+KGRlbGF5OiAoKSA9PiBudW1iZXIsIG5vdGlmaWVyOiBPYnNlcnZhYmxlPHVua25vd24+KTogTW9ub1R5cGVPcGVyYXRvckZ1bmN0aW9uPFQ+IHtcbiAgcmV0dXJuIChzb3VyY2UkOiBPYnNlcnZhYmxlPFQ+KSA9PlxuICAgIHNvdXJjZSQucGlwZShcbiAgICAgIHN3aXRjaE1hcCgodmFsdWU6IFQpID0+XG4gICAgICAgIHRpbWVyKGRlbGF5KCkpLnBpcGUoXG4gICAgICAgICAgbWFwKCgpID0+IHZhbHVlKSxcbiAgICAgICAgICB0YWtlVW50aWwobm90aWZpZXIpLFxuICAgICAgICApLFxuICAgICAgKSxcbiAgICApO1xufVxuIl19

package/esm2022/rxjs/lib/from-element-mutation.mjs

@@ -1,5 +1,26 @@
 import { createMutationObserver } from '@odx/angular/utils';
 import { Observable } from 'rxjs';
+/**
+ * Creates an RxJS Observable that emits mutation records for changes in a DOM element's attributes,
+ * child list, and subtree. It uses the `MutationObserver` Web API to observe mutations on the specified
+ * element according to the options provided.
+ *
+ * @param {Element} element The DOM element to observe for mutations.
+ * @param {MutationObserverInit} options An object that specifies which DOM mutations should be reported.
+ * Options include attributes, childList, subtree, attributeOldValue, characterData, characterDataOldValue,
+ * and attributeFilter.
+ * @returns {Observable<MutationRecord>} An Observable that emits a `MutationRecord` each time a mutation
+ * matching the specified options occurs in the observed element.
+ * @example
+ * ```ts
+ * // Observing changes to the child list of an element
+ * const element = document.getElementById('my-element');
+ * const mutationOptions = { childList: true };
+ *
+ * fromElementMutation$(element, mutationOptions).subscribe((mutation) => console.log('Mutation detected:', mutation));
+ * ```
+ * Note: Always remember to unsubscribe from the observable to prevent memory leaks.
+ */
 export function fromElementMutation$(element, options) {
     return new Observable((observer) => {
         const mutationObserver = createMutationObserver(observer, (events) => events.length > 0);
@@ -7,4 +28,4 @@ export function fromElementMutation$(element, options) {
         mutationObserver.observe(element, options);
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvbS1lbGVtZW50LW11dGF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3J4anMvc3JjL2xpYi9mcm9tLWVsZW1lbnQtbXV0YXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDNUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUVsQyxNQUFNLFVBQVUsb0JBQW9CLENBQUMsT0FBZ0IsRUFBRSxPQUE2QjtJQUNsRixPQUFPLElBQUksVUFBVSxDQUFpQixDQUFDLFFBQVEsRUFBRSxFQUFFO1FBQ2pELE1BQU0sZ0JBQWdCLEdBQUcsc0JBQXNCLENBQUMsUUFBUSxFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDO1FBQ3pGLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsZ0JBQWdCLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztRQUNsRCxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQzdDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNyZWF0ZU11dGF0aW9uT2JzZXJ2ZXIgfSBmcm9tICdAb2R4L2FuZ3VsYXIvdXRpbHMnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgZnVuY3Rpb24gZnJvbUVsZW1lbnRNdXRhdGlvbiQoZWxlbWVudDogRWxlbWVudCwgb3B0aW9uczogTXV0YXRpb25PYnNlcnZlckluaXQpOiBPYnNlcnZhYmxlPE11dGF0aW9uUmVjb3JkPiB7XG4gIHJldHVybiBuZXcgT2JzZXJ2YWJsZTxNdXRhdGlvblJlY29yZD4oKG9ic2VydmVyKSA9PiB7XG4gICAgY29uc3QgbXV0YXRpb25PYnNlcnZlciA9IGNyZWF0ZU11dGF0aW9uT2JzZXJ2ZXIob2JzZXJ2ZXIsIChldmVudHMpID0+IGV2ZW50cy5sZW5ndGggPiAwKTtcbiAgICBvYnNlcnZlci5hZGQoKCkgPT4gbXV0YXRpb25PYnNlcnZlci5kaXNjb25uZWN0KCkpO1xuICAgIG11dGF0aW9uT2JzZXJ2ZXIub2JzZXJ2ZShlbGVtZW50LCBvcHRpb25zKTtcbiAgfSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/rxjs/lib/from-element-resize.mjs

@@ -1,5 +1,29 @@
 import { createResizeObserver } from '@odx/angular/utils';
 import { debounceTime, Observable } from 'rxjs';
+/**
+ * Creates an RxJS Observable that emits an array of `ResizeObserverEntry` objects whenever
+ * the target element's size changes. This function provides a reactive way to observe
+ * and respond to changes in an element's dimensions, using the `ResizeObserver` Web API.
+ *
+ * The observable debounces the emitted values to improve performance and reduce the frequency
+ * of change detection runs in Angular applications. The debounce time can be adjusted via
+ * the `debounceDuration` parameter.
+ *
+ * @param {Element} element The DOM element to observe for size changes.
+ * @param {number} [debounceDuration=50] The time, in milliseconds, to debounce the emitted
+ * values. Defaults to 50ms.
+ * @returns {Observable<ResizeObserverEntry[]>} An Observable that emits the resize events
+ * for the observed element. Each emission is an array of `ResizeObserverEntry` objects, one
+ * for each observed element that experienced a resize.
+ * @example
+ * ```ts
+ * // Observing resize events of an element with a 100ms debounce duration
+ * const element = document.getElementById('resizable-element');
+ * fromElementResize$(element, 100).subscribe((entries) => console.log('Element resized:', entries));
+ * ```
+ *
+ * Always unsubscribe from the observable to clean up resources and prevent memory leaks.
+ */
 export function fromElementResize$(element, debounceDuration = 50) {
     return new Observable((observer) => {
         const resizeObserver = createResizeObserver((events) => {
@@ -11,4 +35,4 @@ export function fromElementResize$(element, debounceDuration = 50) {
         resizeObserver.observe(element);
     }).pipe(debounceTime(debounceDuration));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvbS1lbGVtZW50LXJlc2l6ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9yeGpzL3NyYy9saWIvZnJvbS1lbGVtZW50LXJlc2l6ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMxRCxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUVoRCxNQUFNLFVBQVUsa0JBQWtCLENBQUMsT0FBZ0IsRUFBRSxnQkFBZ0IsR0FBRyxFQUFFO0lBQ3hFLE9BQU8sSUFBSSxVQUFVLENBQXdCLENBQUMsUUFBUSxFQUFFLEVBQUU7UUFDeEQsTUFBTSxjQUFjLEdBQUcsb0JBQW9CLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRTtZQUNyRCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFO2dCQUNyQixRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2FBQ3ZCO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFDSCxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO1FBQ2hELGNBQWMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDbEMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7QUFDMUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNyZWF0ZVJlc2l6ZU9ic2VydmVyIH0gZnJvbSAnQG9keC9hbmd1bGFyL3V0aWxzJztcbmltcG9ydCB7IGRlYm91bmNlVGltZSwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgZnVuY3Rpb24gZnJvbUVsZW1lbnRSZXNpemUkKGVsZW1lbnQ6IEVsZW1lbnQsIGRlYm91bmNlRHVyYXRpb24gPSA1MCk6IE9ic2VydmFibGU8UmVzaXplT2JzZXJ2ZXJFbnRyeVtdPiB7XG4gIHJldHVybiBuZXcgT2JzZXJ2YWJsZTxSZXNpemVPYnNlcnZlckVudHJ5W10+KChvYnNlcnZlcikgPT4ge1xuICAgIGNvbnN0IHJlc2l6ZU9ic2VydmVyID0gY3JlYXRlUmVzaXplT2JzZXJ2ZXIoKGV2ZW50cykgPT4ge1xuICAgICAgaWYgKGV2ZW50cy5sZW5ndGggPiAwKSB7XG4gICAgICAgIG9ic2VydmVyLm5leHQoZXZlbnRzKTtcbiAgICAgIH1cbiAgICB9KTtcbiAgICBvYnNlcnZlci5hZGQoKCkgPT4gcmVzaXplT2JzZXJ2ZXIuZGlzY29ubmVjdCgpKTtcbiAgICByZXNpemVPYnNlcnZlci5vYnNlcnZlKGVsZW1lbnQpO1xuICB9KS5waXBlKGRlYm91bmNlVGltZShkZWJvdW5jZUR1cmF0aW9uKSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/rxjs/lib/from-events.mjs

@@ -1,5 +1,29 @@
 import { fromEvent, merge } from 'rxjs';
+/**
+ * Creates an Observable that emits events of a specific type from one or multiple event targets.
+ * It listens to multiple event types on the given target(s) and emits the events through a single
+ * Observable stream, simplifying the handling of related event types.
+ *
+ * @template T The event object type that the Observable will emit.
+ * @param {HasEventTargetAddRemove<T> | HasEventTargetAddRemove<T>[]} target The DOM element(s) or event target(s) to listen on.
+ * @param {...string[]} events The names of the events to listen for on the target(s).
+ * @returns {Observable<T>} An Observable that emits an event each time one of the specified events occurs on the given target(s).
+ *
+ * @example
+ * ```ts
+ * // Listen to both 'click' and 'keyup' events on document
+ * fromEvents(document, 'click', 'keyup').subscribe(event => {
+ *   console.log('Event occurred:', event);
+ * });
+ *
+ * // Listen to 'mousemove' event on multiple elements
+ * const elements = [document.getElementById('first'), document.getElementById('second')];
+ * fromEvents(elements, 'mousemove').subscribe(event => {
+ *   console.log('Mouse moved over:', event.target);
+ * });
+ * ```
+ */
 export function fromEvents(target, ...events) {
     return merge(...events.map((event) => fromEvent(target, event)));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvbS1ldmVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvcnhqcy9zcmMvbGliL2Zyb20tZXZlbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFjLE1BQU0sTUFBTSxDQUFDO0FBR3BELE1BQU0sVUFBVSxVQUFVLENBQUksTUFBaUUsRUFBRSxHQUFHLE1BQWdCO0lBQ2xILE9BQU8sS0FBSyxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbkUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGZyb21FdmVudCwgbWVyZ2UsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IEhhc0V2ZW50VGFyZ2V0QWRkUmVtb3ZlIH0gZnJvbSAncnhqcy9pbnRlcm5hbC9vYnNlcnZhYmxlL2Zyb21FdmVudCc7XG5cbmV4cG9ydCBmdW5jdGlvbiBmcm9tRXZlbnRzPFQ+KHRhcmdldDogSGFzRXZlbnRUYXJnZXRBZGRSZW1vdmU8VD4gfCBIYXNFdmVudFRhcmdldEFkZFJlbW92ZTxUPltdLCAuLi5ldmVudHM6IHN0cmluZ1tdKTogT2JzZXJ2YWJsZTxUPiB7XG4gIHJldHVybiBtZXJnZSguLi5ldmVudHMubWFwKChldmVudCkgPT4gZnJvbUV2ZW50KHRhcmdldCwgZXZlbnQpKSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/rxjs/lib/from-query-list.mjs

@@ -0,0 +1,24 @@
+import { startWith } from 'rxjs';
+/**
+ * Creates an Observable from an Angular QueryList. The Observable emits the initial state
+ * of the QueryList and continues to emit updates every time the QueryList changes.
+ * This utility function is useful for integrating Angular's QueryList changes into
+ * the RxJS reactive data flow, allowing developers to apply RxJS operators and
+ * subscriptions to respond to QueryList updates.
+ *
+ * @template T The type of elements contained within the QueryList.
+ * @param {QueryList<T>} queryList The QueryList instance to observe.
+ * @returns {Observable<QueryList<T>>} An Observable that emits the current state of the QueryList
+ * and updates whenever the QueryList changes.
+ * @example
+ * ```ts
+ * // Assuming 'items' is a QueryList of component instances or DOM elements
+ * fromQueryList(items).subscribe(queryList => {
+ *   console.log('QueryList changed:', queryList);
+ * });
+ * ```
+ */
+export function fromQueryList(queryList) {
+    return queryList.changes.pipe(startWith(queryList));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/sdk/lib/application-environment.mjs

@@ -1,10 +1,60 @@
 import { inject, InjectionToken } from '@angular/core';
 import { bootstrapApplication } from '@angular/platform-browser';
 import { CacheStorageClient } from '@odx/angular/utils';
+/**
+ * Creates a loader function for fetching application environment data over HTTP and caching it.
+ * Utilizes `CacheStorageClient` for caching the fetched data to optimize performance and reduce network load.
+ *
+ * @template Data The type of the data expected from the HTTP request.
+ * @param {Function} handler - A function that processes the fetched data and returns a promise resolving to the desired environment data format.
+ * @returns {ApplicationEnvironmentLoader<Data, Parameters<CacheStorageClient['request']>>} A loader function that fetches, caches, and processes environment data.
+ * @example
+ * const environmentLoader = createHttpApplicationEnvironmentLoader(async (dto) => {
+ *   return { apiEndpoint: dto.apiEndpoint, featureFlags: dto.featureFlags };
+ * });
+ */
 export function createHttpApplicationEnvironmentLoader(handler) {
     const cache = new CacheStorageClient('@odx/angular/sdk::ApplicationEnvironment');
     return (...args) => cache.request(...args).then((dto) => handler(dto));
 }
+/**
+ * The application environment module can be used to load environment data before application startup,
+ * that can be used to load environment variables from an external URL.
+ *
+ * @template Data The type of the environment data.
+ * @template Params The types of the parameters accepted by the loader function.
+ * @param {ApplicationEnvironmentLoader<Data, Params>} loader - A loader function that asynchronously loads the environment data.
+ * @returns An object containing utilities for working with the application environment, including the InjectionToken
+ *          and functions for loading and bootstrapping the application with the environment.
+ * @example
+ * To add an application environment to your Angular application, follow the following steps:
+ * 1. Create the application environment with your loader:
+ * ```ts
+ * import { createApplicationEnvironment, createHttpApplicationEnvironmentLoader } from '@odx/angular/sdk';
+ * import { z } from 'zod';
+ *
+ * export const ApplicationConfigSchema = z.object({
+ *   environment: z.enum(['dev', 'stage', 'prod']),
+ *   appName: z.string().default('App'),
+ * });
+ *
+ * const httpEnvironmentLoader = createHttpApplicationEnvironmentLoader((res) => res.json().then(ApplicationConfigSchema.parse));
+ * export const { injectApplicationEnvironment, bootstrapApplicationWithEnvironment } = createApplicationEnvironment(httpEnvironmentLoader);
+ * ```
+ * This example creates an HTTP environment loader which parses the response as JSON and validate it against a schema
+ *
+ * 2. Provide the application environment:
+ * ```ts
+ * bootstrapApplicationWithEnvironment(['assets/config.json'], AppComponent, { providers: [] });
+ * ```
+ *
+ * 3. Use the application environment via DI
+ * ```ts
+ * class MyService {
+ *   private readonly environment = injectApplicationEnvironment();
+ * }
+ * ```
+ */
 export function createApplicationEnvironment(loader) {
     let environment;
     const APPLICATION_ENVIRONMENT = new InjectionToken('@odx/angular/sdk::ApplicationEnvironment', {
@@ -32,4 +82,4 @@ export function createApplicationEnvironment(loader) {
         loadApplicationEnvironment,
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application-environment.js","sourceRoot":"","sources":["../../../../../../libs/angular/sdk/src/lib/application-environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,MAAM,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAaxD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sCAAsC,CACpD,OAAwC;IAExC,MAAM,KAAK,GAAG,IAAI,kBAAkB,CAAC,0CAA0C,CAAC,CAAC;IAEjF,OAAO,CAAC,GAAG,IAA+C,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAU,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7H,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,UAAU,4BAA4B,CAAiC,MAAkD;IAC7H,IAAI,WAAiB,CAAC;IACtB,MAAM,uBAAuB,GAAG,IAAI,cAAc,CAAO,0CAA0C,EAAE;QACnG,UAAU,EAAE,MAAM;QAClB,OAAO,EAAE,GAAG,EAAE,CAAC,WAAmB;KACnC,CAAC,CAAC;IAEH,SAAS,4BAA4B;QACnC,OAAO,MAAM,CAAC,uBAAuB,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,UAAU,0BAA0B,CAAC,GAAG,IAA+B;QAC1E,WAAW,GAAG,MAAM,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,WAAW,EAAE;YAChB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;SAC3E;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,KAAK,UAAU,mCAAmC,CAChD,MAAiC,EACjC,GAAG,IAA6C;QAEhD,MAAM,0BAA0B,CAAC,GAAG,MAAM,CAAC,CAAC;QAE5C,OAAO,oBAAoB,CAAC,GAAG,IAAI,CAAC,CAAC;IACvC,CAAC;IAED,OAAO;QACL,uBAAuB;QACvB,4BAA4B;QAC5B,mCAAmC;QACnC,0BAA0B;KAC3B,CAAC;AACJ,CAAC","sourcesContent":["import { ApplicationRef, inject, InjectionToken } from '@angular/core';\nimport { bootstrapApplication } from '@angular/platform-browser';\nimport { CacheStorageClient } from '@odx/angular/utils';\n\n/**\n * A function type definition for loading environment data for an application.\n * It's a generic loader function that accepts parameters and returns a Promise of environment data.\n *\n * @template EnvironmentData The type of the environment data to be loaded.\n * @template Params The types of the parameters accepted by the loader function.\n * @param {...Params} args - Parameters passed to the loader function.\n * @returns {Promise<EnvironmentData>} A promise resolving to the loaded environment data.\n */\nexport type ApplicationEnvironmentLoader<EnvironmentData, Params extends unknown[]> = (...args: Params) => Promise<EnvironmentData>;\n\n/**\n * Creates a loader function for fetching application environment data over HTTP and caching it.\n * Utilizes `CacheStorageClient` for caching the fetched data to optimize performance and reduce network load.\n *\n * @template Data The type of the data expected from the HTTP request.\n * @param {Function} handler - A function that processes the fetched data and returns a promise resolving to the desired environment data format.\n * @returns {ApplicationEnvironmentLoader<Data, Parameters<CacheStorageClient['request']>>} A loader function that fetches, caches, and processes environment data.\n * @example\n * const environmentLoader = createHttpApplicationEnvironmentLoader(async (dto) => {\n *   return { apiEndpoint: dto.apiEndpoint, featureFlags: dto.featureFlags };\n * });\n */\nexport function createHttpApplicationEnvironmentLoader<Data>(\n  handler: (dto: unknown) => Promise<Data>,\n): ApplicationEnvironmentLoader<Data, Parameters<CacheStorageClient['request']>> {\n  const cache = new CacheStorageClient('@odx/angular/sdk::ApplicationEnvironment');\n\n  return (...args: Parameters<CacheStorageClient['request']>) => cache.request<unknown>(...args).then((dto) => handler(dto));\n}\n\n/**\n * The application environment module can be used to load environment data before application startup,\n * that can be used to load environment variables from an external URL.\n *\n * @template Data The type of the environment data.\n * @template Params The types of the parameters accepted by the loader function.\n * @param {ApplicationEnvironmentLoader<Data, Params>} loader - A loader function that asynchronously loads the environment data.\n * @returns An object containing utilities for working with the application environment, including the InjectionToken\n *          and functions for loading and bootstrapping the application with the environment.\n * @example\n * To add an application environment to your Angular application, follow the following steps:\n * 1. Create the application environment with your loader:\n * ```ts\n * import { createApplicationEnvironment, createHttpApplicationEnvironmentLoader } from '@odx/angular/sdk';\n * import { z } from 'zod';\n *\n * export const ApplicationConfigSchema = z.object({\n *   environment: z.enum(['dev', 'stage', 'prod']),\n *   appName: z.string().default('App'),\n * });\n *\n * const httpEnvironmentLoader = createHttpApplicationEnvironmentLoader((res) => res.json().then(ApplicationConfigSchema.parse));\n * export const { injectApplicationEnvironment, bootstrapApplicationWithEnvironment } = createApplicationEnvironment(httpEnvironmentLoader);\n * ```\n * This example creates an HTTP environment loader which parses the response as JSON and validate it against a schema\n *\n * 2. Provide the application environment:\n * ```ts\n * bootstrapApplicationWithEnvironment(['assets/config.json'], AppComponent, { providers: [] });\n * ```\n *\n * 3. Use the application environment via DI\n * ```ts\n * class MyService {\n *   private readonly environment = injectApplicationEnvironment();\n * }\n * ```\n */\nexport function createApplicationEnvironment<Data, Params extends unknown[]>(loader: ApplicationEnvironmentLoader<Data, Params>) {\n  let environment: Data;\n  const APPLICATION_ENVIRONMENT = new InjectionToken<Data>('@odx/angular/sdk::ApplicationEnvironment', {\n    providedIn: 'root',\n    factory: () => environment as Data,\n  });\n\n  function injectApplicationEnvironment(): Data {\n    return inject(APPLICATION_ENVIRONMENT);\n  }\n\n  async function loadApplicationEnvironment(...args: Parameters<typeof loader>): Promise<Data> {\n    environment = await loader(...args);\n    if (!environment) {\n      throw new Error('[@odx/angular/sdk] Failed load application environment');\n    }\n    return environment;\n  }\n\n  async function bootstrapApplicationWithEnvironment(\n    params: Parameters<typeof loader>,\n    ...args: Parameters<typeof bootstrapApplication>\n  ): Promise<ApplicationRef> {\n    await loadApplicationEnvironment(...params);\n\n    return bootstrapApplication(...args);\n  }\n\n  return {\n    APPLICATION_ENVIRONMENT,\n    injectApplicationEnvironment,\n    bootstrapApplicationWithEnvironment,\n    loadApplicationEnvironment,\n  };\n}\n"]}

package/esm2022/theming/lib/helpers/prefers-dark-theme.mjs

@@ -1,4 +1,22 @@
+/**
+ * Determines whether the user's system preferences indicate a preference for dark themes.
+ * This is achieved by querying the '(prefers-color-scheme: dark)' media feature, which reflects
+ * the user's preference for a light or dark color scheme in their operating system's UI.
+ *
+ * @param {Window} view - The window object, typically `window`, from which to access the matchMedia method.
+ * @returns {boolean} `true` if the user prefers a dark theme, otherwise `false`.
+ *
+ * @example
+ * Example usage in a web application to toggle themes:
+ * ```ts
+ * if (prefersDarkTheme(window)) {
+ *   document.body.classList.add('dark-theme');
+ * } else {
+ *   document.body.classList.remove('dark-theme');
+ * }
+ * ```
+ */
 export function prefersDarkTheme(view) {
     return !!view.matchMedia?.('(prefers-color-scheme: dark)')?.matches;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlZmVycy1kYXJrLXRoZW1lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3RoZW1pbmcvc3JjL2xpYi9oZWxwZXJzL3ByZWZlcnMtZGFyay10aGVtZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsSUFBWTtJQUMzQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUMsOEJBQThCLENBQUMsRUFBRSxPQUFPLENBQUM7QUFDdEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBwcmVmZXJzRGFya1RoZW1lKHZpZXc6IFdpbmRvdyk6IGJvb2xlYW4ge1xuICByZXR1cm4gISF2aWV3Lm1hdGNoTWVkaWE/LignKHByZWZlcnMtY29sb3Itc2NoZW1lOiBkYXJrKScpPy5tYXRjaGVzO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlZmVycy1kYXJrLXRoZW1lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3RoZW1pbmcvc3JjL2xpYi9oZWxwZXJzL3ByZWZlcnMtZGFyay10aGVtZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFFSCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsSUFBWTtJQUMzQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUMsOEJBQThCLENBQUMsRUFBRSxPQUFPLENBQUM7QUFDdEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGV0ZXJtaW5lcyB3aGV0aGVyIHRoZSB1c2VyJ3Mgc3lzdGVtIHByZWZlcmVuY2VzIGluZGljYXRlIGEgcHJlZmVyZW5jZSBmb3IgZGFyayB0aGVtZXMuXG4gKiBUaGlzIGlzIGFjaGlldmVkIGJ5IHF1ZXJ5aW5nIHRoZSAnKHByZWZlcnMtY29sb3Itc2NoZW1lOiBkYXJrKScgbWVkaWEgZmVhdHVyZSwgd2hpY2ggcmVmbGVjdHNcbiAqIHRoZSB1c2VyJ3MgcHJlZmVyZW5jZSBmb3IgYSBsaWdodCBvciBkYXJrIGNvbG9yIHNjaGVtZSBpbiB0aGVpciBvcGVyYXRpbmcgc3lzdGVtJ3MgVUkuXG4gKlxuICogQHBhcmFtIHtXaW5kb3d9IHZpZXcgLSBUaGUgd2luZG93IG9iamVjdCwgdHlwaWNhbGx5IGB3aW5kb3dgLCBmcm9tIHdoaWNoIHRvIGFjY2VzcyB0aGUgbWF0Y2hNZWRpYSBtZXRob2QuXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn0gYHRydWVgIGlmIHRoZSB1c2VyIHByZWZlcnMgYSBkYXJrIHRoZW1lLCBvdGhlcndpc2UgYGZhbHNlYC5cbiAqXG4gKiBAZXhhbXBsZVxuICogRXhhbXBsZSB1c2FnZSBpbiBhIHdlYiBhcHBsaWNhdGlvbiB0byB0b2dnbGUgdGhlbWVzOlxuICogYGBgdHNcbiAqIGlmIChwcmVmZXJzRGFya1RoZW1lKHdpbmRvdykpIHtcbiAqICAgZG9jdW1lbnQuYm9keS5jbGFzc0xpc3QuYWRkKCdkYXJrLXRoZW1lJyk7XG4gKiB9IGVsc2Uge1xuICogICBkb2N1bWVudC5ib2R5LmNsYXNzTGlzdC5yZW1vdmUoJ2RhcmstdGhlbWUnKTtcbiAqIH1cbiAqIGBgYFxuICovXG5cbmV4cG9ydCBmdW5jdGlvbiBwcmVmZXJzRGFya1RoZW1lKHZpZXc6IFdpbmRvdyk6IGJvb2xlYW4ge1xuICByZXR1cm4gISF2aWV3Lm1hdGNoTWVkaWE/LignKHByZWZlcnMtY29sb3Itc2NoZW1lOiBkYXJrKScpPy5tYXRjaGVzO1xufVxuIl19

package/esm2022/theming/lib/helpers/resolve-theme.mjs

@@ -1,5 +1,30 @@
 import { availableThemes } from '../models';
+/**
+ * Resolves the specified theme by checking if it exists in the predefined list of available themes.
+ * This function ensures that only valid themes are used in the application, providing a safeguard
+ * against invalid theme names and facilitating the dynamic application of themes.
+ *
+ * @param {string | null} [theme] - The name of the theme to resolve. It's optional and can be `null`.
+ * @returns {Theme | null} - Returns the resolved `Theme` object if the theme is found within the list of `availableThemes`;
+ * otherwise, returns `null` to indicate the theme is not recognized or available.
+ *
+ * @example
+ * ```ts
+ * // Assuming 'dark' and 'light' are in the availableThemes array
+ * console.log(resolveTheme('dark')); // Outputs the 'dark' Theme object
+ * console.log(resolveTheme('unknown')); // Outputs null
+ *
+ * // Using resolveTheme to apply a user-selected theme
+ * const userSelectedTheme = getUserSelectedTheme(); // This function gets the user's theme choice
+ * const themeToApply = resolveTheme(userSelectedTheme);
+ * if (themeToApply) {
+ *   applyTheme(themeToApply); // This function applies the resolved theme to the application
+ * } else {
+ *   console.warn('Selected theme is not available.');
+ * }
+ * ```
+ */
 export function resolveTheme(theme) {
     return availableThemes.find((t) => t === theme) ?? null;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS10aGVtZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci90aGVtaW5nL3NyYy9saWIvaGVscGVycy9yZXNvbHZlLXRoZW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQVMsTUFBTSxXQUFXLENBQUM7QUFFbkQsTUFBTSxVQUFVLFlBQVksQ0FBQyxLQUFxQjtJQUNoRCxPQUFPLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxLQUFLLENBQUMsSUFBSSxJQUFJLENBQUM7QUFDMUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGF2YWlsYWJsZVRoZW1lcywgVGhlbWUgfSBmcm9tICcuLi9tb2RlbHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZVRoZW1lKHRoZW1lPzogc3RyaW5nIHwgbnVsbCk6IFRoZW1lIHwgbnVsbCB7XG4gIHJldHVybiBhdmFpbGFibGVUaGVtZXMuZmluZCgodCkgPT4gdCA9PT0gdGhlbWUpID8/IG51bGw7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/theming/lib/helpers/theme-storage.mjs

@@ -1,5 +1,26 @@
 import { resolveTheme } from './resolve-theme';
+/**
+ * The key used to store the selected theme in `Storage`.
+ * This constant ensures consistent access to the theme setting across the application.
+ */
 export const THEME_STORAGE_NAME = '@odx/angular/theming:SelectedTheme';
+/**
+ * Saves the specified theme to storage. This function abstracts the storage interaction,
+ * providing a fail-safe mechanism to avoid exceptions if the storage is not available.
+ *
+ * @param {Storage | null | undefined} storage - The storage mechanism to use, typically `localStorage` or `sessionStorage`.
+ * @param {Theme} theme - The theme to save. Should be a value that is recognized by the application's theming system.
+ * @throws Will silently catch and ignore any exceptions caused by storage limitations or permissions.
+ *
+ * @example
+ * ```ts
+ * // Example usage with localStorage
+ * saveTheme(localStorage, 'dark');
+ *
+ * // Using sessionStorage instead
+ * saveTheme(sessionStorage, 'light');
+ * ```
+ */
 export function saveTheme(storage, theme) {
     try {
         storage?.setItem(THEME_STORAGE_NAME, theme);
@@ -8,6 +29,27 @@ export function saveTheme(storage, theme) {
         //
     }
 }
+/**
+ * Reads the theme from storage, attempting to resolve it to a valid application theme.
+ * If the theme cannot be found or is invalid, `null` is returned. This function also provides
+ * error handling for any storage access issues, ensuring the application can gracefully handle
+ * scenarios where storage is not available or accessible.
+ *
+ * @param {Storage | null} [storage] - The storage mechanism to use, typically `localStorage` or `sessionStorage`.
+ * @returns {Theme | null} - The resolved theme if found and valid; otherwise, `null`.
+ * @throws Will silently catch and ignore any exceptions caused by storage access, returning `null`.
+ *
+ * @example
+ * ```ts
+ * // Reading theme from localStorage
+ * const theme = readTheme(localStorage);
+ * if (theme) {
+ *   applyTheme(theme); // Assuming applyTheme is a function to apply the theme
+ * } else {
+ *   console.warn('No saved theme found or theme is invalid.');
+ * }
+ * ```
+ */
 export function readTheme(storage) {
     try {
         return resolveTheme(storage?.getItem(THEME_STORAGE_NAME)) ?? null;
@@ -16,4 +58,4 @@ export function readTheme(storage) {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtc3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci90aGVtaW5nL3NyYy9saWIvaGVscGVycy90aGVtZS1zdG9yYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxvQ0FBb0MsQ0FBQztBQUV2RSxNQUFNLFVBQVUsU0FBUyxDQUFDLE9BQW1DLEVBQUUsS0FBWTtJQUN6RSxJQUFJO1FBQ0YsT0FBTyxFQUFFLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxLQUFLLENBQUMsQ0FBQztLQUM3QztJQUFDLE1BQU07UUFDTixFQUFFO0tBQ0g7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLFNBQVMsQ0FBQyxPQUF3QjtJQUNoRCxJQUFJO1FBQ0YsT0FBTyxZQUFZLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDO0tBQ25FO0lBQUMsTUFBTTtRQUNOLE9BQU8sSUFBSSxDQUFDO0tBQ2I7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGhlbWUgfSBmcm9tICcuLi9tb2RlbHMnO1xuaW1wb3J0IHsgcmVzb2x2ZVRoZW1lIH0gZnJvbSAnLi9yZXNvbHZlLXRoZW1lJztcblxuZXhwb3J0IGNvbnN0IFRIRU1FX1NUT1JBR0VfTkFNRSA9ICdAb2R4L2FuZ3VsYXIvdGhlbWluZzpTZWxlY3RlZFRoZW1lJztcblxuZXhwb3J0IGZ1bmN0aW9uIHNhdmVUaGVtZShzdG9yYWdlOiBTdG9yYWdlIHwgbnVsbCB8IHVuZGVmaW5lZCwgdGhlbWU6IFRoZW1lKTogdm9pZCB7XG4gIHRyeSB7XG4gICAgc3RvcmFnZT8uc2V0SXRlbShUSEVNRV9TVE9SQUdFX05BTUUsIHRoZW1lKTtcbiAgfSBjYXRjaCB7XG4gICAgLy9cbiAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gcmVhZFRoZW1lKHN0b3JhZ2U/OiBTdG9yYWdlIHwgbnVsbCk6IFRoZW1lIHwgbnVsbCB7XG4gIHRyeSB7XG4gICAgcmV0dXJuIHJlc29sdmVUaGVtZShzdG9yYWdlPy5nZXRJdGVtKFRIRU1FX1NUT1JBR0VfTkFNRSkpID8/IG51bGw7XG4gIH0gY2F0Y2gge1xuICAgIHJldHVybiBudWxsO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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