@rdlabo/ionic-angular-kit 0.0.13 → 0.0.15

package/fesm2022/rdlabo-ionic-angular-kit.mjs

@@ -1,20 +1,15 @@
 import * as i0 from '@angular/core';
-import { inject, Injectable, InjectionToken, makeEnvironmentProviders, ElementRef, Directive, DOCUMENT } from '@angular/core';
+import { inject, Injectable, InjectionToken, makeEnvironmentProviders, ElementRef, Directive } from '@angular/core';
 import { Storage } from '@ionic/storage-angular';
-import { ModalController, PopoverController, ToastController, AlertController, NavController } from '@ionic/angular/standalone';
+import { ModalController, PopoverController, ToastController, AlertController, LoadingController, NavController } from '@ionic/angular/standalone';
 import { Capacitor } from '@capacitor/core';
 import { Keyboard } from '@capacitor/keyboard';
 import { ImpactStyle, Haptics } from '@capacitor/haptics';
-import { StatusBar, Style } from '@capacitor/status-bar';
-import { BehaviorSubject, from, throwError, retry, timer, Observable, startWith } from 'rxjs';
-import { Preferences } from '@capacitor/preferences';
-import { InAppReview } from '@capacitor-community/in-app-review';
-import { BRLMPrinterHalftone, BRLMPrinterCustomPaperUnit, BRLMPrinterCustomPaperType, BRLMPrinterPrintQuality, BRLMPrinterHorizontalAlignment, BRLMPrinterVerticalAlignment, BRLMPrinterImageRotation, BRLMPrinterScaleMode } from '@rdlabo/capacitor-brotherprint';
-import domtoimage from 'dom-to-image-more';
 import { Router } from '@angular/router';
 import { map, mergeMap, catchError, timeout, tap } from 'rxjs/operators';
 import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
 import { Network } from '@capacitor/network';
+import { from, throwError, retry, timer, Observable, startWith } from 'rxjs';
 
 /**
  * Thin, typed wrapper around `@ionic/storage-angular`.
@@ -185,7 +180,7 @@ const watchModalKeyboard = async (modal) => {
  * constructor(private readonly overlay: KitOverlayController) {}
  *
  * async edit(): Promise<void> {
- *   const result = await this.overlay.presentModal<EditResult>(EditPage, { id: 1 });
+ *   const result = await this.overlay.presentModal(EditPage, { id: 1 });
  *   if (result) {
  *     await this.overlay.presentToast({ message: 'Saved' });
  *   }
@@ -204,22 +199,6 @@ class KitOverlayController {
      * second alert on top of the first. Shared across both methods so a confirm cannot stack over a close.
      */
     #alertPresenting = false;
-    /**
-     * Present a modal and resolve with the data passed to its dismissal.
-     *
-     * @typeParam O - type of the data returned when the modal is dismissed
-     * @param component - the component to render inside the modal
-     * @param componentProps - props to pass to the modal component
-     * @param options - additional modal options, including {@link KitModalPresentOptions.watchKeyboard}
-     * @returns the dismiss data, or `undefined` when the modal is dismissed without data
-     * @remarks
-     * Presenting a modal triggers light native haptic feedback as an intentional kit UX choice,
-     * consistent with {@link presentPopover} and {@link presentToast}.
-     * @example
-     * ```ts
-     * const data = await overlay.presentModal<{ saved: boolean }>(EditPage, { id: 1 }, { watchKeyboard: true });
-     * ```
-     */
     async presentModal(component, componentProps, options = {}) {
         void kitImpact();
         const { watchKeyboard, ...modalOptions } = options;
@@ -381,6 +360,119 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImpo
                 }]
         }] });
 
+/**
+ * Reference-counted wrapper around Ionic's `LoadingController` that keeps at most one loading
+ * indicator on screen across concurrent async work.
+ *
+ * @remarks
+ * Each {@link presentLoading} increments a counter and each {@link dismissLoading} decrements it; the
+ * indicator is presented on the `0 → 1` transition and dismissed on the `N → 0` transition. This
+ * removes the flicker / "stuck spinner" bugs that come from every service calling
+ * `LoadingController.create/dismiss` independently.
+ *
+ * All operations are serialized through an internal promise chain, so a `create → present` sequence
+ * can never interleave with a concurrent `dismiss`. That is what makes the counter race-safe: a
+ * dismiss that arrives while the indicator is still being presented runs *after* `present()` settles
+ * and therefore tears the element down instead of leaving it orphaned on screen.
+ *
+ * Always pair every `presentLoading()` with exactly one `dismissLoading()` — a `try/finally` is the
+ * safest shape.
+ *
+ * @example
+ * ```ts
+ * constructor(private readonly loading: KitLoadingController) {}
+ *
+ * async save(): Promise<void> {
+ *   await this.loading.presentLoading({ message: 'Saving…' });
+ *   try {
+ *     await this.api.save();
+ *   } finally {
+ *     await this.loading.dismissLoading();
+ *   }
+ * }
+ * ```
+ */
+class KitLoadingController {
+    #loadingCtrl = inject(LoadingController);
+    /** Outstanding {@link presentLoading} calls not yet balanced by {@link dismissLoading}. */
+    #count = 0;
+    /** The single presented loading element, or `null` when none is on screen. */
+    #loading = null;
+    /**
+     * Serializes present/dismiss operations. Each call chains onto this promise, runs after the
+     * previous operation has fully settled, then reads {@link #count} and acts accordingly.
+     */
+    #queue = Promise.resolve();
+    /**
+     * Show the loading indicator, or join the one already on screen.
+     *
+     * @param options - Ionic loading options; only applied by the call that actually creates the
+     *   indicator (the `0 → 1` transition). Ignored while an indicator is already present.
+     * @returns a Promise that resolves once the indicator is on screen (or immediately when one already is)
+     */
+    async presentLoading(options = {}) {
+        this.#count++;
+        try {
+            await this.#enqueue(async () => {
+                // Create only on the transition into "something is loading"; concurrent callers ride the same
+                // element. Re-check the count in case a dismiss already balanced this call while queued.
+                if (this.#count > 0 && this.#loading === null) {
+                    const loading = await this.#loadingCtrl.create(options);
+                    await loading.present();
+                    this.#loading = loading;
+                }
+            });
+        }
+        catch (error) {
+            // Roll back the reference this call took: a failed create/present must not leave the counter
+            // elevated, otherwise a later cycle never reaches N → 0 and the spinner stays stuck on screen.
+            this.#count--;
+            throw error;
+        }
+    }
+    /**
+     * Release one reference; dismiss the indicator once the last reference is gone.
+     *
+     * @returns a Promise that resolves once the reference is released (and the indicator dismissed if
+     *   this was the last one). No-ops when the counter is already at zero.
+     */
+    async dismissLoading() {
+        if (this.#count === 0) {
+            return;
+        }
+        this.#count--;
+        await this.#enqueue(async () => {
+            // Tear down only when the last consumer is gone. Because this runs after any in-flight
+            // present() has settled (via the queue), there is never an orphaned loading element.
+            if (this.#count === 0 && this.#loading !== null) {
+                const loading = this.#loading;
+                this.#loading = null;
+                await loading.dismiss();
+            }
+        });
+    }
+    /**
+     * Append `task` to the serialization chain and return its completion.
+     *
+     * @remarks
+     * The stored chain swallows rejections so a single failing operation cannot wedge every future
+     * overlay; the returned promise still rejects so the caller observes the error.
+     */
+    #enqueue(task) {
+        const run = this.#queue.then(task);
+        this.#queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: KitLoadingController, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: KitLoadingController, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: KitLoadingController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 /**
  * The fleet's canonical "network error → offer to reload" alert, as a stateful controller.
  *
@@ -738,323 +830,6 @@ const kitKeyboardInit = async (elementRef, type) => {
     ];
 };
 
-/**
- * Injection token carrying the {@link KitThemeConfig} for `KitThemeController`.
- *
- * @remarks
- * Provide it through {@link provideKitTheme} rather than registering it directly.
- */
-const KIT_THEME_CONFIG = new InjectionToken('@rdlabo/ionic-angular-kit:theme');
-/**
- * Wire `KitThemeController` into the application.
- *
- * @param config - theme configuration: the storage key and the light/dark class lists
- * @returns environment providers to add to the application's provider list
- * @example
- * ```ts
- * bootstrapApplication(AppComponent, {
- *   providers: [
- *     provideKitTheme({
- *       storageKey: StorageKeyEnum.theme,
- *       darkClasses: ['ion-palette-dark', 'a2ui-dark'],
- *       lightClasses: ['a2ui-light'],
- *     }),
- *   ],
- * });
- * ```
- */
-const provideKitTheme = (config) => makeEnvironmentProviders([{ provide: KIT_THEME_CONFIG, useValue: config }]);
-
-/**
- * Light/dark theme controller: persists the user's choice, follows the OS setting until the user
- * overrides it, toggles the configured palette classes, and syncs the native Android status bar.
- *
- * @remarks
- * Consolidates the theme logic that had drifted across the fleet into one behavior. Notably it fixes
- * a latent leak in one variant where the system-theme listener stayed registered after a manual
- * toggle: {@link changeTheme} always detaches the listener via {@link removeEventListener} before
- * applying the forced theme, so a later OS change can no longer silently flip an app the user pinned.
- *
- * - **Persistence** — the chosen mode is stored via {@link KitStorageService} under the configured key.
- * - **Follow OS until overridden** — on boot with nothing stored, it tracks
- *   `prefers-color-scheme` (idempotent registration); once the user calls {@link changeTheme} it stops
- *   following and honors the explicit choice.
- * - **Class toggling** — toggles {@link KitThemeConfig.darkClasses} on when dark and
- *   {@link KitThemeConfig.lightClasses} on when light, absorbing per-app CSS differences via config.
- * - **Native status bar** — on Android native only, mirrors the Ionic behavior of setting the status
- *   bar style to match (iOS derives it from the web content, so it is intentionally left untouched).
- *
- * Subscribe to {@link themeSubject} to reflect the current mode in the UI (e.g. a settings toggle).
- *
- * @example
- * ```ts
- * // On boot (app.component):
- * inject(KitThemeController).setDefaultThemeMode();
- *
- * // From a settings toggle:
- * const theme = inject(KitThemeController);
- * theme.themeSubject.subscribe((mode) => this.isDark.set(mode === 'dark'));
- * theme.changeTheme(true);
- * ```
- */
-class KitThemeController {
-    constructor() {
-        this.#storage = inject(KitStorageService);
-        this.#document = inject(DOCUMENT);
-        this.#config = inject(KIT_THEME_CONFIG);
-        /**
-         * Emits the active theme, seeded with `'light'`.
-         *
-         * @remarks
-         * A `BehaviorSubject`, so a late subscriber immediately receives the current mode; it emits again
-         * on every {@link setDefaultThemeMode} / {@link changeTheme} and on OS theme changes while following.
-         */
-        this.themeSubject = new BehaviorSubject('light');
-    }
-    #storage;
-    #document;
-    #config;
-    #prefersDark;
-    #onSystemThemeChange;
-    /**
-     * Apply the persisted theme, or start following the OS setting when nothing is stored yet.
-     *
-     * @remarks
-     * Call once on boot (e.g. from `app.component`).
-     *
-     * @returns a Promise that resolves once the initial theme has been applied
-     */
-    async setDefaultThemeMode() {
-        const stored = await this.#storage.get(this.#config.storageKey);
-        if (stored) {
-            // 保存済みの選択を強制し、OS 追従は解除する。
-            this.#unwatchSystemTheme();
-            return this.#applyTheme(stored === 'dark');
-        }
-        // 未保存 → OS の設定に追従する。
-        this.#watchSystemTheme();
-    }
-    /**
-     * Force a theme, persist it, and stop following the OS setting.
-     *
-     * @param isDark - `true` for the dark theme, `false` for light
-     * @returns a Promise that resolves once the theme has been persisted and applied
-     */
-    async changeTheme(isDark) {
-        this.#unwatchSystemTheme();
-        await this.#storage.set(this.#config.storageKey, isDark ? 'dark' : 'light');
-        await this.#applyTheme(isDark);
-    }
-    #watchSystemTheme() {
-        if (this.#prefersDark) {
-            // 既に監視中なら二重登録しない（冪等）。
-            return;
-        }
-        this.#prefersDark = window.matchMedia('(prefers-color-scheme: dark)');
-        this.#onSystemThemeChange = (e) => void this.#applyTheme(e.matches);
-        this.#prefersDark.addEventListener('change', this.#onSystemThemeChange, { passive: true });
-        void this.#applyTheme(this.#prefersDark.matches);
-    }
-    #unwatchSystemTheme() {
-        if (this.#prefersDark && this.#onSystemThemeChange) {
-            this.#prefersDark.removeEventListener('change', this.#onSystemThemeChange);
-        }
-        this.#prefersDark = undefined;
-        this.#onSystemThemeChange = undefined;
-    }
-    async #applyTheme(isDark) {
-        if (Capacitor.isNativePlatform() && Capacitor.getPlatform() === 'android') {
-            await StatusBar.setStyle({ style: isDark ? Style.Dark : Style.Light });
-        }
-        const root = this.#document.documentElement;
-        for (const cls of this.#config.darkClasses) {
-            root.classList.toggle(cls, isDark);
-        }
-        for (const cls of this.#config.lightClasses) {
-            root.classList.toggle(cls, !isDark);
-        }
-        this.themeSubject.next(isDark ? 'dark' : 'light');
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: KitThemeController, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: KitThemeController, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: KitThemeController, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * Request the native in-app review dialog, throttled so the user is prompted at most once per window.
- *
- * @remarks
- * A plain function — no DI needed (`@capacitor/preferences`, `@capacitor-community/in-app-review` and
- * `Capacitor` are all static), so the caller invokes it directly and passes its own config rather
- * than injecting a controller. A no-op on non-native platforms. When enough time has elapsed since
- * the last prompt (per {@link KitRequestReviewOptions.throttleMonths}, tracked under
- * {@link KitRequestReviewOptions.storageKey}), it briefly waits for the app to settle, calls
- * `InAppReview.requestReview()`, and records the new timestamp. The wait/throttle/record sequence
- * was previously copy-pasted verbatim across the fleet; centralizing it means a single place to tune
- * the prompt cadence.
- *
- * @param options - the storage key and throttle window; see {@link KitRequestReviewOptions}
- * @returns a Promise that resolves once the request has been made (or immediately if throttled / on web)
- * @example
- * ```ts
- * await kitRequestReview({ storageKey: StorageEnum.lastRequestRate, throttleMonths: 3 });
- * ```
- */
-const kitRequestReview = async (options) => {
-    if (!Capacitor.isNativePlatform()) {
-        return;
-    }
-    await new Promise((resolve) => setTimeout(() => resolve(), 1000));
-    const threshold = new Date();
-    threshold.setMonth(threshold.getMonth() - options.throttleMonths);
-    const { value } = await Preferences.get({ key: options.storageKey });
-    if (!value || new Date(Number(value)).getTime() < threshold.getTime()) {
-        await InAppReview.requestReview();
-        await Preferences.set({ key: options.storageKey, value: new Date().getTime().toString() });
-    }
-};
-
-/**
- * Rotate a base64 image 90°, returning a new base64 data URL of the same MIME type.
- *
- * @remarks
- * Pure DOM/canvas work — no DI. Used before sending a label to the printer when the artwork must be
- * turned to match the tape orientation. Extracted verbatim from the fleet's printer services so the
- * canvas handling lives in one place.
- *
- * @param imageData - a base64 data URL (e.g. `data:image/png;base64,...`)
- * @returns a Promise resolving to the rotated image as a base64 data URL
- */
-const kitRotationImage = async (imageData) => {
-    const imgType = imageData.substring(5, imageData.indexOf(';'));
-    const image = new Image();
-    const loaded = () => new Promise((resolve) => {
-        image.onload = () => resolve();
-    });
-    setTimeout(() => (image.src = imageData));
-    await loaded();
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    canvas.width = image.height;
-    canvas.height = image.width;
-    ctx.rotate((90 * Math.PI) / 180);
-    ctx.translate(0, -image.height);
-    ctx.drawImage(image, 0, 0, image.width, image.height);
-    return canvas.toDataURL(imgType);
-};
-/**
- * Render a DOM element to a base64 PNG for label printing, with the fleet's device-specific fixes.
- *
- * @remarks
- * Pure function — no DI (reads the platform from `Capacitor`, uses the global `document`), so the
- * caller presents its own loading UI around it. Centralizes the hard-won device quirks: on iOS it
- * pads width/height by 2px (otherwise the bottom is clipped), on Android it does not (the padding
- * introduces a black line). Retries the `dom-to-image-more` render up to 10 times because the first
- * pass can occasionally return empty. This is exactly the kind of plumbing where a future fix should
- * land in every app at once.
- *
- * @param element - the element to rasterize (e.g. the label preview host)
- * @param options - rendering options; see {@link KitDomToPngOptions}
- * @returns a Promise resolving to the PNG as a base64 data URL (empty string if every attempt failed)
- * @example
- * ```ts
- * const loading = await this.#loadingCtrl.create({ message: this.text.generating });
- * await loading.present();
- * const png = await kitDomToPng(this.preview().nativeElement, { rotate: true });
- * await loading.dismiss();
- * ```
- */
-const kitDomToPng = async (element, options) => {
-    await new Promise((resolve) => requestAnimationFrame(resolve));
-    const { clientHeight, clientWidth } = element;
-    // デバイス毎の問題解決のため、px 調整。
-    // iOS: ないと下が途切れる。Android: あると黒線が入る。
-    const addClient = Capacitor.getPlatform() === 'ios' ? 2 : 0;
-    const dataUrl = await new Promise((resolve) => {
-        void (async () => {
-            for (let i = 0; i < 10; i++) {
-                const url = await domtoimage.toPng(element, {
-                    width: clientWidth + addClient,
-                    height: clientHeight + addClient,
-                    scale: options?.scale ?? 3,
-                    copyDefaultStyles: false,
-                });
-                if (url) {
-                    resolve(url);
-                    return;
-                }
-            }
-            resolve('');
-        })();
-    });
-    return options?.rotate ? kitRotationImage(dataUrl) : dataUrl;
-};
-/**
- * Assemble the Brother `BRLMPrintOptions` for a die-cut label print, minus the transport fields.
- *
- * @remarks
- * Pure function — no DI. Centralizes the fleet's canonical print settings (fit-page scale, centered,
- * best quality, threshold halftone, 2mm/1mm margins, `gapLength` 2.0) and the tape sizing derived
- * from the label's `W<width>H<height>` code. The caller merges the printer's `port` / `channelInfo`
- * onto the result before calling `BrotherPrint.printImage()`, so channel selection and loading UI stay
- * in the app.
- *
- * @param params - model, artwork, label, copies, and halftone threshold; see {@link KitBrotherPrintSettingsParams}
- * @returns the `BRLMPrintOptions` ready to be spread with `{ port, channelInfo }`
- * @example
- * ```ts
- * const settings = kitBuildBrotherPrintSettings({
- *   modelName, printBase64, label, numberOfCopies: printOptions.printNum, halftoneThreshold: printOptions.halftoneThreshold,
- * });
- * await BrotherPrint.printImage({ ...settings, port: channel.port, channelInfo: channel.channelInfo });
- * ```
- */
-const kitBuildBrotherPrintSettings = (params) => {
-    const startPoint = params.printBase64.indexOf(',');
-    const tapeSize = params.label.match(/W(\d+)H(\d+)/);
-    const tapeWidth = tapeSize && tapeSize.length >= 2 ? parseInt(tapeSize[1], 10) : 0;
-    const tapeLength = tapeSize && tapeSize.length >= 3 ? parseInt(tapeSize[2], 10) : 0;
-    // `BRLMPrintOptions` is a `QL | TD` union; a die-cut label legitimately carries fields from both
-    // groups, so the object is composed via spreads to bypass the union's excess-property checks — the
-    // same technique the source printer services used.
-    return {
-        ...{
-            modelName: params.modelName,
-            encodedImage: params.printBase64.slice(startPoint + 1),
-            numberOfCopies: params.numberOfCopies,
-            autoCut: true,
-            scaleMode: BRLMPrinterScaleMode.FitPageAspect,
-            imageRotation: BRLMPrinterImageRotation.Rotate0,
-            verticalAlignment: BRLMPrinterVerticalAlignment.Center,
-            horizontalAlignment: BRLMPrinterHorizontalAlignment.Center,
-            printQuality: BRLMPrinterPrintQuality.Best,
-        },
-        ...{
-            labelName: params.label,
-        },
-        ...{
-            paperType: BRLMPrinterCustomPaperType.dieCutPaper,
-            paperUnit: BRLMPrinterCustomPaperUnit.mm,
-            halftone: BRLMPrinterHalftone.Threshold,
-            halftoneThreshold: params.halftoneThreshold,
-            tapeWidth: Number(tapeWidth.toFixed(1)),
-            tapeLength: Number(tapeLength.toFixed(1)),
-            gapLength: 2.0,
-            marginTop: 1.0,
-            marginRight: 2.0,
-            marginBottom: 1.0,
-            marginLeft: 2.0,
-            paperMarkPosition: 0,
-            paperMarkLength: 0,
-        },
-    };
-};
-
 /**
  * Injection token that carries the {@link KitAuthConfig} to the authentication guards.
  */
@@ -1561,12 +1336,10 @@ const disableHandler = async (event, work) => {
  * ```
  */
 const kitChangeEventDisabled = (completeEvent, disabled) => {
-    completeEvent.update((event) => {
-        if (event) {
-            event.disabled = disabled;
-        }
-        return event;
-    });
+    const event = completeEvent();
+    if (event) {
+        event.disabled = disabled;
+    }
 };
 
 /**
@@ -1613,5 +1386,5 @@ const kitCreateDidEnter = (el) => {
  * Generated bundle index. Do not edit.
  */
 
-export { KIT_AUTH_CONFIG, KIT_HTTP_CONFIG, KIT_OVERLAY_CONFIG, KIT_THEME_CONFIG, KitAutofillDirective, KitOverlayController, KitReloadAlertController, KitStorageService, KitThemeController, arrayConcatById, disableHandler, kitAuthInterceptor, kitBuildBrotherPrintSettings, kitChangeEventDisabled, kitCreateDidEnter, kitDomToPng, kitImpact, kitKeyboardInit, kitPresentAuthFailedAlert, kitPresentLanguageActionSheet, kitRequestReview, kitRequireAuthorizedGuard, kitRequireConfirmingGuard, kitRequiredUnauthorizedGuard, kitRotationImage, objectEqual, provideKitAuth, provideKitHttp, provideKitOverlay, provideKitTheme };
+export { KIT_AUTH_CONFIG, KIT_HTTP_CONFIG, KIT_OVERLAY_CONFIG, KitAutofillDirective, KitLoadingController, KitOverlayController, KitReloadAlertController, KitStorageService, arrayConcatById, disableHandler, kitAuthInterceptor, kitChangeEventDisabled, kitCreateDidEnter, kitImpact, kitKeyboardInit, kitPresentAuthFailedAlert, kitPresentLanguageActionSheet, kitRequireAuthorizedGuard, kitRequireConfirmingGuard, kitRequiredUnauthorizedGuard, objectEqual, provideKitAuth, provideKitHttp, provideKitOverlay };
 //# sourceMappingURL=rdlabo-ionic-angular-kit.mjs.map