@skra/ui 0.6.0 → 0.8.0

package/types/skra-ui-file-upload.d.ts

@@ -0,0 +1,360 @@
+import * as i0 from '@angular/core';
+import { SkraFieldContext } from '@skra/ui/field';
+
+/** Leading icon of `<skra-file-upload>`'s face. Decorative — the consumer marks it `aria-hidden`. */
+declare class SkraFileUploadStart {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileUploadStart, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileUploadStart, "[skra-start]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * REQUIRED. The visible action text of `<skra-file-upload>` ("Choose a video"). It joins the
+ * native control's accessible name through `aria-labelledby` (ADR 0056 D4, WCAG 2.5.3), so a
+ * voice-control user can say what they see.
+ */
+declare class SkraFileUploadAction {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileUploadAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileUploadAction, "[skra-file-upload-action]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The drop instruction ("or drag it here"). Its presence switches the face from the compact
+ * row to the drop-zone layout — an instruction is what invites dragging. Hidden on devices
+ * with no fine pointer, where "drag" means nothing.
+ */
+declare class SkraFileUploadInstruction {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileUploadInstruction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileUploadInstruction, "[skra-file-upload-instruction]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The selection summary in the page's language ("recording.mp4, 2.3 GB"). Rendered inside the
+ * composite's always-present `role="status"` region and linked to the control as a description,
+ * so a change is announced and the user agent's browser-language status is not the only one.
+ */
+declare class SkraFileUploadStatus {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileUploadStatus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileUploadStatus, "[skra-file-upload-status]", never, {}, {}, never, never, true, never>;
+}
+/** Leading visual of a file row — an icon or a consumer-made thumbnail (`URL.createObjectURL`). */
+declare class SkraFileItemStart {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileItemStart, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileItemStart, "[skra-start]", never, {}, {}, never, never, true, never>;
+}
+/** Row detail under the name — typically `progress[skraProgress]` or a status line. */
+declare class SkraFileItemDetail {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileItemDetail, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileItemDetail, "[skra-file-item-detail]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The row's error text. Its presence is what paints the row invalid
+ * (`data-skra-validation="invalid"`), so the colour never appears without the words
+ * (WCAG 1.4.1 by construction).
+ */
+declare class SkraFileItemError {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileItemError, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileItemError, "[skra-file-item-error]", never, {}, {}, never, never, true, never>;
+}
+/** Trailing row actions — the consumer's `button[skraButton]`s (cancel / retry / remove). */
+declare class SkraFileItemEnd {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileItemEnd, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraFileItemEnd, "[skra-end]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Format a byte count for display in `locale` (`undefined` → the host default, the ADR 0050
+ * §5 precedent): `2,3 GB` in `pl`, `2.3 GB` in `en`, one fractional digit at most.
+ *
+ * SI units (1 kB = 1000 B) because `Intl` names only those and macOS / iOS report sizes the
+ * same way. The unit label is `Intl`'s own short form, so it is translated and pluralised by
+ * the platform's locale data, never by Skra (e.g. `999 byte` in English, `999 B` in Polish —
+ * CLDR's choice, not ours). A multi-GB `File.size` is a safe integer; nothing here rounds
+ * the input.
+ *
+ * @throws RangeError for a negative or non-finite count — a size that cannot exist is a bug
+ *   in the caller, and printing `NaN byte` would hide it.
+ */
+declare function skraFormatFileSize(bytes: number, locale?: string): string;
+/**
+ * Does `file` satisfy `accept`, under the HTML attribute's own semantics?
+ *
+ * - `.ext` — a case-insensitive suffix of the file NAME;
+ * - `type/subtype` — the file's MIME type, case-insensitive, parameters ignored;
+ * - `type/*` — any subtype of `type`.
+ *
+ * An empty `accept`, or one with no token the grammar recognises, accepts everything — the
+ * picker applies no filter in that case either.
+ *
+ * **Typeless files** (`File.type === ''` — common for `.mkv` / `.heic` on some engines) are
+ * matched by extension tokens only, and PASS when `accept` has no extension token (spec Q-5).
+ * A false rejection of a legitimate 4 GB recording costs more than a junk file the consumer
+ * and the server reject anyway.
+ *
+ * `accept` is never a guarantee: every platform lets a user bypass it. Validate on the server.
+ */
+declare function skraFileMatchesAccept(file: Pick<File, 'name' | 'type'>, accept: string): boolean;
+
+/** Why the normalisation turned a file down. Every reason is a rule the PLATFORM's picker enforces. */
+type SkraFileRejectionReason = 'type' | 'count' | 'directory';
+/** A file the normalisation rejected, and why. */
+interface SkraFileRejection {
+    readonly file: File;
+    readonly reason: SkraFileRejectionReason;
+}
+
+/**
+ * `input[type="file"][skraFileInput]` — the native file control (spec
+ * `component-file-upload-spec.md`; ADR 0056 Group B). A Component-on-a-native-host
+ * (ADR 040): `<input>` is void, so `template: ''`, and `file-input.scss` is scoped to the
+ * host by Emulated encapsulation — the box from `comp.field.*`, the user agent's
+ * `::file-selector-button` painted from `comp.field.file.*` (ADR 0056 B1–B5).
+ *
+ * **No inputs.** Every constraint is a NATIVE attribute on the consumer's own host —
+ * `accept`, `multiple`, `capture`, `required`, `disabled`, `name`, `webkitdirectory`
+ * (native-attr-first, Iron Boundary #9). Skra reads them at the moment of a selection; it
+ * never mirrors them.
+ *
+ * **Agnostic value (ADR 037).** The selection is REPORTED, never held: `filesChange` carries
+ * the normalised files, `filesRejected` what the normalisation turned down. Native
+ * `(change)` keeps working and reports the RAW selection; `filesChange` is the normalised one.
+ *
+ * **Normalisation** — Skra enforces exactly what the platform's own picker enforces, on
+ * every path, and nothing more (size / count caps / duplicates are product policy):
+ *
+ * | Rule | Picker (`change`) | Drop (`drop` on the host) |
+ * | --- | --- | --- |
+ * | `accept` mismatch → `type` | possible (Windows "All files", Android) | the browser applies no `accept` to drops |
+ * | >1 file without `multiple` → `count` | impossible | possible — ALL rejected |
+ * | a directory → `directory` | impossible | possible |
+ * | assignment | `input.files` left as the platform set it | `input.files` = the ACCEPTED files, then `input` + `change` are dispatched |
+ *
+ * A drop where nothing is accepted leaves the existing selection untouched and emits only
+ * `filesRejected` — like a cancelled picker, it is not a change.
+ *
+ * **Field wiring (ADR 013 §3.7)** — the `skraInput` wiring verbatim: optional
+ * `SkraFieldContext`; `id` / `disabled` written from guarded `effect()`s so a standalone
+ * consumer's own attributes survive; `aria-describedby` / `aria-invalid` / `aria-required`
+ * host bindings. Readonly: the native `readonly` attribute does not apply to `type="file"`
+ * (HTML) and `aria-readonly` is not exposed for its `button` role (G-4, measured), so it is
+ * `aria-disabled="true"` — the focusable soft-disable — plus a behaviour guard that blocks the
+ * picker (`click`, keys other than `Tab`) and drops.
+ *
+ * **Known limitation (G-4, measured in Chromium):** "required" cannot reach assistive
+ * technology on this control — neither `aria-required` (kept: harmless, and the field's
+ * contract) nor native `required` is exposed for the `button` role. Say "required" in visible
+ * text (the label or the hint) as well.
+ *
+ * **Inside `<skra-file-upload>`** (ADR 0056 Group D) the composite's context is injected:
+ * the host reflects `data-skra-in-upload` (ADR 027 §3.9b) and its own stylesheet makes it a
+ * transparent overlay over the painted face (`opacity: 0` only — D2); its name becomes
+ * "field label + visible action text" via `aria-labelledby` (D4, WCAG 2.5.3) and the
+ * composite's status region joins its description.
+ *
+ *   <skra-field>
+ *     <label skraLabelFor>Session recording</label>
+ *     <input skraFileInput type="file" accept="video/*" #picker (filesChange)="onFiles($event)" />
+ *   </skra-field>
+ */
+declare class SkraFileInput {
+    private readonly el;
+    readonly context: SkraFieldContext | null;
+    private readonly upload;
+    /** User picked or dropped files. Fires on user interaction only, after normalisation. */
+    readonly filesChange: i0.OutputEmitterRef<readonly File[]>;
+    /** Files the normalisation rejected. Fires only when at least one was rejected. */
+    readonly filesRejected: i0.OutputEmitterRef<readonly SkraFileRejection[]>;
+    protected readonly inUpload: boolean;
+    protected readonly dragOver: i0.WritableSignal<boolean>;
+    private dragDepth;
+    protected readonly softDisabled: i0.Signal<boolean>;
+    protected readonly describedBy: i0.Signal<string | null>;
+    protected readonly labelledBy: i0.Signal<string | null>;
+    constructor();
+    /**
+     * Reset the native selection (`value = ''`) so the same file can be picked again — the
+     * queue model (`filesChange` → enqueue → `clear()`). Programmatic: emits nothing.
+     * Reach it through a template reference: `#picker` on the host resolves to this component.
+     */
+    clear(): void;
+    private get blocked();
+    /**
+     * The native constraints, read at selection time. A `webkitdirectory` picker hands over
+     * EVERY file of the chosen folder whether or not `multiple` is set, so it counts as
+     * multiple — otherwise each folder pick would be rejected whole as `count`.
+     */
+    private constraints;
+    /**
+     * The picker path — and the drop path's own dispatched `change`, already normalised.
+     *
+     * Order is part of the contract, the same on both paths: `filesChange` FIRST, then
+     * `filesRejected`. A consumer that clears its error on a new selection and sets it on a
+     * rejection then ends on the rejection message, not on a cleared one. A selection where
+     * EVERY file was rejected emits no `filesChange` at all (like a fully rejected drop): it
+     * changed nothing the consumer can use. An empty selection with no rejection (a picker
+     * that reports a cleared selection) still emits `filesChange([])`.
+     */
+    protected onChange(): void;
+    /** Readonly: `preventDefault` on `click` keeps the picker closed, for pointer and keyboard alike. */
+    protected blockWhenReadonly(event: Event): void;
+    /** Readonly: block keyboard activation; let `Tab` through. */
+    protected blockKeyWhenReadonly(event: KeyboardEvent): void;
+    protected onDragEnter(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(): void;
+    protected resetDrag(): void;
+    /** The drop path — normalise, then assign the ACCEPTED files and replay the native events. */
+    protected onDrop(event: DragEvent): void;
+    /**
+     * Directory detection has to happen INSIDE the `drop` handler: `webkitGetAsEntry()` is the
+     * only cross-engine signal (a dropped folder arrives as a `File` too), and the item list
+     * is emptied once the event returns.
+     */
+    private candidatesOf;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraFileInput, "input[type=\"file\"][skraFileInput]", never, {}, { "filesChange": "filesChange"; "filesRejected": "filesRejected"; }, never, never, true, never>;
+}
+
+/**
+ * Internal — provided by `<skra-file-upload>` per instance, injected `{ optional: true }` by
+ * the projected `input[skraFileInput]` (ADR 013 §3.6 contextual wiring). Carries ids only —
+ * never a value, never state (ADR 037; the composite owns no state, ADR 027 §3.8).
+ *
+ * Its PRESENCE is what puts the input into overlay mode (`data-skra-in-upload`, ADR 027
+ * §3.9b): Emulated encapsulation lets no parent style projected content, and DI keeps the
+ * rule in the atom's own stylesheet instead of a global slice (no O-8 bridge cost).
+ */
+declare class SkraFileUploadContext {
+    private readonly base;
+    /** The face's visible action text — the second half of the control's name (ADR 0056 D4). */
+    readonly actionId: string;
+    /** The always-present status region — a description of the control, never its name. */
+    readonly statusId: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileUploadContext, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkraFileUploadContext>;
+}
+
+/**
+ * `<skra-file-upload>` — the optional enhancement over a projected `input[skraFileInput]`
+ * (spec `component-file-upload-spec.md`; ADR 0056 Group D). It paints a localisable face —
+ * the action and the instruction in the PAGE's language, from tokens — enlarges the control
+ * into a drop zone, and hosts the live selection-status region.
+ *
+ * Why it exists: the native control's two strings ("Choose File" / "No file chosen") come
+ * from the browser's UI language, not the page's `lang`, and no CSS or attribute can replace
+ * them (ADR 0056 §1.6). The native control stays THE control (D2): transparent
+ * (`opacity: 0`, its own stylesheet, switched on by this component's context), covering the
+ * whole face, it remains the focus target, the pointer target, the drop target and the node
+ * assistive technology reads — so `required`, `aria-invalid`, the validation bubble, label
+ * activation, form submission and the iOS camera / library sheet all keep working.
+ *
+ * **State-READING** (ADR 027 §3.8, ADR 055): no inputs, no outputs; every state it paints —
+ * hover, focus-visible, drag-over, disabled, readonly, invalid — is read from the projected
+ * control through `:has()`. It owns no state, so it mirrors no ARIA.
+ *
+ * **Layout follows content (ADR 020).** No `[skra-file-upload-instruction]` → a compact,
+ * field-like row (`[icon] [action] status`); with one → the drop-zone layout (stacked,
+ * centred, dashed). Both accept drops. There is no look input (skin philosophy).
+ *
+ * **Never project interactive content** into it — the transparent control covers the whole
+ * face and swallows the clicks (D3). The file list is a SIBLING.
+ *
+ * **Page-navigation guard.** While one is mounted, a FILE drag dropped outside every drop
+ * target is cancelled instead of navigating the page to the file (spec Q-3; text / link
+ * drags, native file inputs and editable content are untouched).
+ *
+ *   <skra-field [hasError]="!!error()">
+ *     <label skraLabelFor>Session recording</label>
+ *     <skra-file-upload>
+ *       <span skra-file-upload-action>Choose a video</span>
+ *       <span skra-file-upload-instruction>or drag it here</span>
+ *       <span skra-file-upload-status>{{ summary() }}</span>
+ *       <input skraFileInput type="file" accept="video/*" (filesChange)="onFiles($event)" />
+ *     </skra-file-upload>
+ *     <skra-error>{{ error() }}</skra-error>
+ *   </skra-field>
+ */
+declare class SkraFileUpload {
+    protected readonly ctx: SkraFileUploadContext;
+    private readonly host;
+    private readonly start;
+    private readonly action;
+    private readonly instruction;
+    private readonly status;
+    private readonly inputs;
+    private readonly nestedInputs;
+    protected readonly hasStart: i0.Signal<boolean>;
+    protected readonly hasInstruction: i0.Signal<boolean>;
+    protected readonly hasStatus: i0.Signal<boolean>;
+    constructor();
+    /**
+     * Dev-only, ADR 0056 D3: the face is paint. Anything interactive projected into it sits
+     * UNDER the transparent control, so the control swallows its clicks — and inside the
+     * `aria-hidden` face it is hidden from assistive technology while still focusable. A read of
+     * the rendered face, never a write.
+     */
+    private warnInteractiveFace;
+    /** Dev-only: the composite cannot work without exactly one direct-child control and an action. */
+    private warnMisuse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileUpload, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraFileUpload, "skra-file-upload", never, {}, {}, ["start", "action", "instruction", "status", "inputs", "nestedInputs"], ["[skra-start]", "[skra-file-upload-action]", "[skra-file-upload-instruction]", "[skra-file-upload-status]", "input[skraFileInput]"], true, never>;
+}
+
+/** A file name split for middle truncation: the stem may shrink, the extension never does. */
+interface SkraFileNameParts {
+    readonly stem: string;
+    readonly ext: string;
+}
+
+/**
+ * `li[skraFileItem]` — a display row for ONE consumer-owned file (spec
+ * `component-file-upload-spec.md`). A Component-on-a-native-host (ADR 012 / ADR 040): the
+ * `<li>` keeps its list-item semantics inside the consumer's `ul[skraStack]`.
+ *
+ * Separate from `<skra-file-upload>` by SRP: a row outlives the selection (it tracks an
+ * upload), its source of truth is the consumer's queue — not `input.files` — and it is a
+ * display list item, not a form control. **Skra never uploads**: progress, retry, cancel and
+ * removal are the consumer's, projected into the row's slots.
+ *
+ * - **Name**, middle-truncated with the extension always visible — pure CSS, no measurement.
+ *   The visual split is `aria-hidden`; an `[skra-sr-only]` copy carries the whole name.
+ * - **Size** — `skraFormatFileSize(size, locale)`: SI units, `Intl` short labels, the
+ *   `locale` input or the host default (the ADR 0050 §5 precedent).
+ * - **Invalid is READ, never owned** (ADR 027 §3.8, spec Q-7): the row paints
+ *   `data-skra-validation="invalid"` only while `[skra-file-item-error]` text is projected, so
+ *   the colour never appears without the words (WCAG 1.4.1 by construction). No `aria-invalid`
+ *   — no role an `<li>` holds supports it.
+ *
+ *   <ul skraStack>
+ *     @for (u of uploads(); track u.id) {
+ *       <li skraFileItem [name]="u.file.name" [size]="u.file.size" locale="pl-PL">
+ *         <progress skraProgress skra-file-item-detail [value]="u.sent" [max]="u.file.size"
+ *                   [attr.aria-label]="'Uploading ' + u.file.name"></progress>
+ *         @if (u.error) { <span skra-file-item-error>{{ u.error }}</span> }
+ *         <button skraButton skra-end emphasis="low" (click)="cancel(u)">
+ *           Cancel<span skra-sr-only> {{ u.file.name }}</span>
+ *         </button>
+ *       </li>
+ *     }
+ *   </ul>
+ */
+declare class SkraFileItem {
+    /** The file name, shown as stem + extension. */
+    readonly name: i0.InputSignal<string>;
+    /** Size in bytes, formatted for display. `undefined` → no size shown. */
+    readonly size: i0.InputSignal<number | undefined>;
+    /** `Intl` locale for the size. `undefined` → the host default (ADR 0050 §5 precedent). */
+    readonly locale: i0.InputSignal<string | undefined>;
+    private readonly start;
+    private readonly detail;
+    private readonly error;
+    private readonly end;
+    protected readonly hasStart: i0.Signal<boolean>;
+    protected readonly hasDetail: i0.Signal<boolean>;
+    protected readonly hasError: i0.Signal<boolean>;
+    protected readonly hasEnd: i0.Signal<boolean>;
+    protected readonly parts: i0.Signal<SkraFileNameParts>;
+    protected readonly sizeLabel: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFileItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraFileItem, "li[skraFileItem]", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; }, {}, ["start", "detail", "error", "end"], ["[skra-start]", "[skra-file-item-detail]", "[skra-file-item-error]", "[skra-end]"], true, never>;
+}
+
+export { SkraFileInput, SkraFileItem, SkraFileItemDetail, SkraFileItemEnd, SkraFileItemError, SkraFileItemStart, SkraFileUpload, SkraFileUploadAction, SkraFileUploadInstruction, SkraFileUploadStart, SkraFileUploadStatus, skraFileMatchesAccept, skraFormatFileSize };
+export type { SkraFileRejection, SkraFileRejectionReason };
+//# sourceMappingURL=skra-ui-file-upload.d.ts.map

package/types/skra-ui-file-upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-file-upload.d.ts","sources":["../../../../libs/ui/file-upload/src/lib/file-upload.directives.ts","../../../../libs/ui/file-upload/src/lib/file-helpers/file-helpers.ts","../../../../libs/ui/file-upload/src/lib/file-helpers/file-partition.ts","../../../../libs/ui/file-upload/src/lib/file-input/file-input.ts","../../../../libs/ui/file-upload/src/lib/file-upload/file-upload-context.ts","../../../../libs/ui/file-upload/src/lib/file-upload/file-upload.ts","../../../../libs/ui/file-upload/src/lib/file-helpers/file-name.ts","../../../../libs/ui/file-upload/src/lib/file-item/file-item.ts"],"mappings":";;;AAUA;AACA,cAIa,mBAAmB;yCAAnB,mBAAmB;2CAAnB,mBAAmB;AAAG;AAEnC;;;;AAIG;AACH,cAIa,oBAAoB;yCAApB,oBAAoB;2CAApB,oBAAoB;AAAG;AAEpC;;;;AAIG;AACH,cAIa,yBAAyB;yCAAzB,yBAAyB;2CAAzB,yBAAyB;AAAG;AAEzC;;;;AAIG;AACH,cAIa,oBAAoB;yCAApB,oBAAoB;2CAApB,oBAAoB;AAAG;AAIpC;AACA,cAIa,iBAAiB;yCAAjB,iBAAiB;2CAAjB,iBAAiB;AAAG;AAEjC;AACA,cAIa,kBAAkB;yCAAlB,kBAAkB;2CAAlB,kBAAkB;AAAG;AAElC;;;;AAIG;AACH,cAIa,iBAAiB;yCAAjB,iBAAiB;2CAAjB,iBAAiB;AAAG;AAEjC;AACA,cAIa,eAAe;yCAAf,eAAe;2CAAf,eAAe;AAAG;;AClE/B;;;;;;;;;;;;AAYG;AACH,iBAAgB,kBAAkB;AAoDlC;;;;;;;;;;;;;;;;AAgBG;AACH,iBAAgB,qBAAqB,OAC7B,IAAI,CAAC,IAAI;;ACjGjB;AACM,KAAM,uBAAuB;AAEnC;UACiB,iBAAiB;AAChC,mBAAe,IAAI;AACnB,qBAAiB,uBAAuB;AACzC;;ACwBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACH,cAmCa,aAAa;AACxB;sBACgB,gBAAA;AAChB;;0BAGoBA,EAAA,CAAA,gBAAA,UAAA,IAAA;;4BAGEA,EAAA,CAAA,gBAAA,UAAA,iBAAA;AAEtB;AACA,iCAA2BA,EAAA,CAAA,cAAA;;AAQ3B,qCAA+BA,EAAA,CAAA,MAAA;AAI/B,oCAA8BA,EAAA,CAAA,MAAA;AAS9B,mCAA6BA,EAAA,CAAA,MAAA;;AA0C7B;;;;AAIG;AACH;;AAQA;;;;AAIG;AACH;AAKA;;;;;;;;;AASG;;;AAYH,uCAAmC,KAAK;;AAKxC,0CAAsC,aAAa;AAMnD,iCAA6B,SAAS;AAOtC,gCAA4B,SAAS;;;;AA6BrC,4BAAwB,SAAS;AA0BjC;;;;AAIG;AACH;yCArMW,aAAa;2CAAb,aAAa;AA2NzB;;ACjVD;;;;;;;;AAQG;AACH,cACa,qBAAqB;AAChC;;;;;yCADW,qBAAqB;6CAArB,qBAAqB;AAQjC;;ACID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACH,cAea,cAAc;AACzB,4BAAsB,qBAAA;AACtB;AAIA;AAGA;AAGA;AAGA;AAIA;AACA;AAIA,iCAA2BA,EAAA,CAAA,MAAA;AAC3B,uCAAiCA,EAAA,CAAA,MAAA;AACjC,kCAA4BA,EAAA,CAAA,MAAA;;AAmB5B;;;;;AAKG;AACH;;AAkBA;yCArEW,cAAc;2CAAd,cAAc;AAiG1B;;ACjLD;UACiB,iBAAiB;AAChC;AACA;AACD;;ACaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACH,cAiBa,YAAY;;mBAEVA,EAAA,CAAA,WAAA;;mBAGAA,EAAA,CAAA,WAAA;;qBAGEA,EAAA,CAAA,WAAA;AAKf;AAGA;AAGA;AAGA;AAEA,iCAA2BA,EAAA,CAAA,MAAA;AAC3B,kCAA4BA,EAAA,CAAA,MAAA;AAC5B,iCAA2BA,EAAA,CAAA,MAAA;AAC3B,+BAAyBA,EAAA,CAAA,MAAA;AAEzB,8BAAwBA,EAAA,CAAA,MAAA,CAAAC,iBAAA;AAIxB,kCAA4BD,EAAA,CAAA,MAAA;yCAjCjB,YAAY;2CAAZ,YAAY;AAsCxB;;;;","names":["_angular_core","___file_helpers_file_name.SkraFileNameParts"]}