@slotted/angular 0.0.0-stage → 0.1.0-beta.0

package/types/slotted-angular-listbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-listbox.d.ts","sources":["../../listbox/src/listbox-defaults.ts","../../listbox/src/listbox-context.ts","../../listbox/src/listbox.ts","../../listbox/src/listbox-parts.ts"],"mappings":"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","names":[]}

package/types/slotted-angular-loading-overlay.d.ts

@@ -0,0 +1,219 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, LoadingOverlayMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+/**
+ * What is covered. `region` is the box the family wraps and the safe default;
+ * `page` is the whole viewport, and `docs/component-features.md` §9 warns
+ * against reaching for it over a local operation.
+ */
+type LoadingOverlayScope = 'region' | 'page';
+/** How the covered content is obscured. `none` blocks and dims nothing. */
+type LoadingOverlayVeil = 'wash' | 'blur' | 'none';
+type LoadingOverlaySize = 'sm' | 'md' | 'lg';
+/**
+ * Whether the wait announces itself. `skeleton`'s own axis and vocabulary:
+ * `off` is for a page that already says the same thing somewhere else.
+ */
+type LoadingOverlayLive = 'polite' | 'off';
+/**
+ * Why a cancellation was asked for. `dismiss` is the reader pressing the
+ * control; `escape` is the key. There is no third: the family holds no timer
+ * and the application does not ask itself to cancel.
+ */
+type LoadingOverlayCancelReason = 'dismiss' | 'escape';
+/**
+ * The ask, and it commits nothing.
+ *
+ * There is deliberately no `cancel()` on it, which is the one place this
+ * request differs from every other in the library. A request can be refused
+ * only where something would otherwise commit, and nothing does here: the
+ * family does not lower `loading`, does not hide itself and does not move
+ * focus. The consumer aborts its own work and lowers `loading` when it has.
+ */
+interface LoadingOverlayCancelRequest {
+    readonly reason: LoadingOverlayCancelReason;
+    /** The event the ask came from: a press on the control, or the key. */
+    readonly source: Event;
+}
+
+/**
+ * The mark the consumer puts in the panel, in place of the family's own.
+ *
+ * It writes nothing and behaves in no way: it exists so the overlay can ask
+ * whether a mark was projected at all, which decides whether the slot centres
+ * its contents or lets them fill it. A determinate bar has no intrinsic width
+ * to be centred at.
+ */
+declare class SlLoadingOverlayIndicator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlLoadingOverlayIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlLoadingOverlayIndicator, "[slLoadingOverlayIndicator]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A region of the page taken out of reach while a wait the consumer owns runs.
+ *
+ * The content stays: in the document, measured, and the thing the region's
+ * geometry comes from. That is the whole difference from `skeleton`, which
+ * stands in for content that has not arrived, and the reason this family
+ * writes `inert` rather than replacing anything.
+ *
+ * The selector is a bare attribute, so the element stays the consumer's: a
+ * region is whatever already wraps the content — a `section`, a card, a list
+ * item — and wrapping it in a second element would change their layout to
+ * carry an attribute. `skeleton`'s region is written the same way and for the
+ * same reason.
+ *
+ * Four things are composed rather than written here. `@slotted/core/loading`
+ * decides when the layer is painted; `@slotted/core/presence` keeps the panel
+ * in the document through the wash's exit; `@slotted/core/focus` moves focus
+ * out of the content before it goes inert and puts it back after; and, in page
+ * scope, `@slotted/core/dismissable-layer` in modal mode makes the rest of the
+ * document inert and locks its scroll.
+ */
+declare class SlLoadingOverlay {
+    /**
+     * Whether the data is still on its way. The consumer's own fact: the family
+     * never moves it, so there is no `model()` here and no request for it.
+     *
+     * Blocking is the default, because a consumer who forgets the input sees a
+     * covered region on the first render, while the other default leaves a
+     * region reachable during a real wait and says nothing.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly scope: _angular_core.InputSignal<LoadingOverlayScope>;
+    readonly veil: _angular_core.InputSignal<LoadingOverlayVeil | undefined>;
+    readonly size: _angular_core.InputSignal<LoadingOverlaySize | undefined>;
+    readonly live: _angular_core.InputSignal<LoadingOverlayLive | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * short line (`label`), painted in the panel and announced once, and the
+     * cancel control's words (`cancel`).
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<LoadingOverlayMessages> | undefined>;
+    readonly loadedLabel: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly cancellable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly minDuration: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Where the page-scoped layer is portalled. Defaults to the document body. */
+    readonly container: _angular_core.InputSignal<HTMLElement | null | undefined>;
+    /**
+     * Asks to stop, carrying the reason and the event. The family commits
+     * nothing: abort the work and lower `loading` when it has stopped.
+     */
+    readonly cancel: _angular_core.OutputEmitterRef<LoadingOverlayCancelRequest>;
+    /**
+     * The moment the covered content is reachable again, which is later than
+     * `loading` turning false whenever `minDuration` is holding the layer. An
+     * application moving focus on the input would move it under the wash.
+     */
+    readonly reveal: _angular_core.OutputEmitterRef<void>;
+    private readonly defaults;
+    /** The family's words in the language in force, with this overlay's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<LoadingOverlayMessages>;
+    private readonly host;
+    /**
+     * Whether the mark in the panel is the family's own. A consumer's mark fills
+     * the slot and the family's is centred in it, and only a content query can
+     * tell the two apart: `ng-content` fallback content leaves no trace in the
+     * DOM that CSS could ask about without reaching into the nested family.
+     */
+    private readonly projectedMark;
+    protected readonly ownMark: _angular_core.Signal<boolean>;
+    private readonly contentRef;
+    private readonly scrimRef;
+    private readonly panelRef;
+    readonly sizeValue: _angular_core.Signal<LoadingOverlaySize>;
+    readonly veilValue: _angular_core.Signal<LoadingOverlayVeil>;
+    readonly liveValue: _angular_core.Signal<LoadingOverlayLive>;
+    readonly labelValue: _angular_core.Signal<string>;
+    private readonly delayValue;
+    private readonly holdValue;
+    /** Whether the layer is painted, which is not the `loading` input. */
+    readonly painted: _angular_core.WritableSignal<boolean>;
+    /** Whether the panel belongs in the document, which outlives `painted`. */
+    readonly mounted: _angular_core.WritableSignal<boolean>;
+    /**
+     * Emptying a live region announces nothing, which is what makes one wait one
+     * announcement rather than two. A completion message is opt-in for the same
+     * reason: a page of six regions would otherwise say six things nobody asked
+     * to hear. `skeleton` established the rule and this family takes it whole.
+     */
+    readonly announcement: _angular_core.Signal<string>;
+    private machine;
+    private timer;
+    private presence;
+    private portal;
+    private layer;
+    constructor();
+    /**
+     * `Escape` in region scope, where there is no dismissable layer to take it.
+     * The listener is on the layer rather than on the document, so the key only
+     * asks when focus is inside the thing it is about: an overlay covering a card
+     * in the corner of a page has no claim on a key pressed elsewhere.
+     */
+    protected onEscape(event: Event): void;
+    /**
+     * Public because the projection directive below calls it: a consumer's own
+     * control is the same ask as the family's own.
+     */
+    requestCancel(source: Event): void;
+    private ask;
+    /**
+     * One step of the shared machine, plus at most one timer. The rule lives in
+     * `@slotted/core/loading` rather than here so React and Angular cannot
+     * disagree about when a layer appears — a difference no test that looked at
+     * either binding alone would report.
+     */
+    private settle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlLoadingOverlay, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlLoadingOverlay, "[slLoadingOverlay]", ["slLoadingOverlay"], { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "scope": { "alias": "scope"; "required": false; "isSignal": true; }; "veil": { "alias": "veil"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "loadedLabel": { "alias": "loadedLabel"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "cancellable": { "alias": "cancellable"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "minDuration": { "alias": "minDuration"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": false; "isSignal": true; }; }, { "cancel": "cancel"; "reveal": "reveal"; }, ["projectedMark"], ["*", "[slLoadingOverlayIndicator]", "[slLoadingOverlayCancel]"], true, never>;
+}
+/**
+ * A consumer's own control, put where the family's would have been.
+ *
+ * It writes the part and takes the press; everything else about the element is
+ * the consumer's, including its paint — the family's own control rules are
+ * written `:not([data-ui])`, so a `sl-button` here is a button and not a button
+ * wearing this family's clothes as well.
+ */
+declare class SlLoadingOverlayCancel {
+    protected readonly overlay: SlLoadingOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlLoadingOverlayCancel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlLoadingOverlayCancel, "[slLoadingOverlayCancel]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * What every overlay in an application looks like, and how a wait is timed,
+ * before any of them states anything of its own.
+ *
+ * The two durations are here rather than on an overlay because the policy is
+ * an application's: a team decides once that a wait under two hundred
+ * milliseconds is not worth reporting, and every region inherits it. The
+ * family ships both at zero because it cannot know them, so an application
+ * that sets neither pays for no timer.
+ */
+interface LoadingOverlayDefaults {
+    delay?: number;
+    live?: LoadingOverlayLive;
+    loadedLabel?: string;
+    minDuration?: number;
+    size?: LoadingOverlaySize;
+    veil?: LoadingOverlayVeil;
+}
+declare const LOADING_OVERLAY_DEFAULTS_TOKEN: InjectionToken<LoadingOverlayDefaults>;
+/**
+ * An overlay that states any of these still wins: an explicit input is never
+ * overridden by the token. The words the family writes come from the language
+ * in force (`provideSlotted`).
+ */
+declare function provideLoadingOverlayDefaults(defaults: LoadingOverlayDefaults): {
+    provide: InjectionToken<LoadingOverlayDefaults>;
+    useValue: LoadingOverlayDefaults;
+};
+declare function injectLoadingOverlayDefaults(): LoadingOverlayDefaults;
+
+export { LOADING_OVERLAY_DEFAULTS_TOKEN, SlLoadingOverlay, SlLoadingOverlayCancel, SlLoadingOverlayIndicator, injectLoadingOverlayDefaults, provideLoadingOverlayDefaults };
+export type { LoadingOverlayCancelReason, LoadingOverlayCancelRequest, LoadingOverlayDefaults, LoadingOverlayLive, LoadingOverlayScope, LoadingOverlaySize, LoadingOverlayVeil };
+//# sourceMappingURL=slotted-angular-loading-overlay.d.ts.map

package/types/slotted-angular-loading-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-loading-overlay.d.ts","sources":["../../loading-overlay/src/loading-overlay.constants.ts","../../loading-overlay/src/loading-overlay.ts","../../loading-overlay/src/loading-overlay-defaults.ts"],"mappings":";;;;;AAAA;;;;AAIG;KACS,mBAAmB;AAE/B;AACM,KAAM,kBAAkB;AAExB,KAAM,kBAAkB;AAE9B;;;AAGG;KACS,kBAAkB;AAE9B;;;;AAIG;KACS,0BAA0B;AAEtC;;;;;;;;AAQG;UACc,2BAA2B;AAC1C,qBAAiB,0BAA0B;;AAE3C,qBAAiB,KAAK;AACvB;;ACWD;;;;;;;AAOG;AACH,cACa,yBAAyB;oDAAzB,yBAAyB;sDAAzB,yBAAyB;AAAG;AAEzC;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,cAkEa,gBAAgB;AAC3B;;;;;;;AAOG;sBACa,aAAA,CAAA,wBAAA;oBACF,aAAA,CAAA,WAAA,CAAA,mBAAA;mBACD,aAAA,CAAA,WAAA,CAAA,kBAAA;mBACA,aAAA,CAAA,WAAA,CAAA,kBAAA;mBACA,aAAA,CAAA,WAAA,CAAA,kBAAA;AACb;;;;AAIG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,sBAAA;0BACG,aAAA,CAAA,WAAA;0BACA,aAAA,CAAA,WAAA;0BACA,aAAA,CAAA,wBAAA;oBACN,aAAA,CAAA,wBAAA;0BACM,aAAA,CAAA,wBAAA;;wBAIF,aAAA,CAAA,WAAA,CAAA,WAAA;AAElB;;;AAGG;qBACY,aAAA,CAAA,gBAAA,CAAA,2BAAA;AACf;;;;AAIG;qBACY,aAAA,CAAA,gBAAA;AAEf;;gBAEU,kBAAA,CAAA,gBAAA,CAAA,sBAAA;AACV;AAEA;;;;;AAKG;AACH;AACA,gCAA0B,aAAA,CAAA,MAAA;AAE1B;AACA;AACA;wBAEkB,aAAA,CAAA,MAAA,CAAA,kBAAA;wBAGA,aAAA,CAAA,MAAA,CAAA,kBAAA;wBAGA,aAAA,CAAA,MAAA,CAAA,kBAAA;yBAGC,aAAA,CAAA,MAAA;AACnB;AACA;;sBAGgB,aAAA,CAAA,cAAA;;sBAEA,aAAA,CAAA,cAAA;AAEhB;;;;;AAKG;2BACkB,aAAA,CAAA,MAAA;;;;;;;AA+HrB;;;;;AAKG;AACH,8BAA0B,KAAK;AAM/B;;;AAGG;0BACmB,KAAK;AAI3B;AAIA;;;;;AAKG;AACH;oDAjPW,gBAAgB;sDAAhB,gBAAgB;AA6P5B;AAWD;;;;;;;AAOG;AACH,cAQa,sBAAsB;AACjC,gCAA0B,gBAAA;oDADf,sBAAsB;sDAAtB,sBAAsB;AAElC;;ACraD;;;;;;;;;AASG;UACc,sBAAsB;;WAE9B,kBAAkB;;;WAGlB,kBAAkB;WAClB,kBAAkB;AAC1B;AAED,cAAa,8BAA8B,EAAA,cAAA,CAAA,sBAAA;AAK3C;;;;AAIG;AACH,iBAAgB,6BAA6B,WAAW,sBAAsB;;;AAE7E;AAED,iBAAgB,4BAA4B,IAAI,sBAAsB;;","names":[]}

package/types/slotted-angular-markdown.d.ts

@@ -0,0 +1,172 @@
+import * as _slotted_core_markdown from '@slotted/core/markdown';
+import { MarkdownUrlKind, MarkdownNode, MarkdownKind, MarkdownElement, MarkdownAlertElement, MarkdownFootnote, MarkdownItemElement } from '@slotted/core/markdown';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, MarkdownMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ProseSize, ProseFlow } from '@slotted/angular/prose';
+
+/** Where a link that leaves the application opens. */
+type MarkdownExternal = 'new-tab' | 'same-tab';
+/** What an application sets once for every document under it. */
+interface MarkdownDefaults {
+    alerts?: boolean | undefined;
+    allow?: readonly string[] | undefined;
+    external?: MarkdownExternal | undefined;
+    headingAnchors?: boolean | undefined;
+    isExternal?: ((href: string) => boolean) | undefined;
+    transformUrl?: ((url: string, kind: MarkdownUrlKind, node: MarkdownNode) => string | null) | undefined;
+}
+declare const MARKDOWN_DEFAULTS: InjectionToken<MarkdownDefaults>;
+/**
+ * An application decides once how its documents treat links, alerts, anchors
+ * and URLs. A document that states any of them itself still wins. Its words
+ * come from the language in force (`provideSlotted`).
+ */
+declare function provideMarkdownDefaults(defaults: MarkdownDefaults): {
+    provide: InjectionToken<MarkdownDefaults>;
+    useValue: MarkdownDefaults;
+};
+declare function injectMarkdownDefaults(): MarkdownDefaults;
+
+/** Whether the source arrived. `loading` is separate, because a refresh keeps what is on screen. */
+type MarkdownStatus = 'ready' | 'error';
+/** What a task checkbox asks for; the box moves when the consumer's tree does. */
+interface MarkdownTaskChange {
+    index: number;
+    checked: boolean;
+    offset: number | null;
+    request: ChangeRequest<boolean>;
+}
+/** Whether the retry was a press with a pointer or with a key. */
+type MarkdownRetryReason = 'pointer' | 'keyboard';
+type KeysOf<U> = U extends unknown ? keyof U : never;
+type ValueOf<U, K extends PropertyKey> = U extends unknown ? K extends keyof U ? U[K] : never : never;
+/**
+ * A prepared element as a template reads it: every field any kind carries,
+ * optional. A template names one kind, and Angular's type checker cannot
+ * narrow a union on the string the directive was given, so the fields of the
+ * kind it names have to be reachable without a cast.
+ */
+type MarkdownTemplateElement = {
+    readonly kind: MarkdownKind;
+    readonly key: string;
+} & {
+    readonly [K in Exclude<KeysOf<MarkdownElement>, 'kind' | 'key'>]?: ValueOf<MarkdownElement, K>;
+};
+/** What a node template receives. */
+interface MarkdownNodeContext {
+    $implicit: MarkdownTemplateElement;
+}
+/**
+ * Replaces the family's element for one kind — `link`, `code`, `image` — or
+ * renders a node type the family does not know — `math`, `html`, a directive
+ * — by the node's own `type`. The template receives the prepared element; its
+ * children are rendered with `slMarkdownChildren`.
+ */
+declare class SlMarkdownNode {
+    readonly kind: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<MarkdownNodeContext>;
+    static ngTemplateContextGuard(_directive: SlMarkdownNode, context: unknown): context is MarkdownNodeContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMarkdownNode, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMarkdownNode, "ng-template[slMarkdownNode]", never, { "kind": { "alias": "slMarkdownNode"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** The empty part's content, projected in place of `messages.empty`. */
+declare class SlMarkdownEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMarkdownEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMarkdownEmpty, "[slMarkdownEmpty]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A document rendered from a tree, in `prose`'s typography.
+ *
+ * The family never receives HTML. It takes mdast — remark's output as it is,
+ * or marked's through `fromMarkedTokens` — and `prepareMarkdown` from
+ * `@slotted/core/markdown` decides everything that is not an element. This
+ * component maps each prepared kind to an element, or to the family that
+ * already owns it: `slLink`, `slCodeBlock`, `slAlert`, `slCheckbox`.
+ *
+ * The document is one recursive `ng-template` rendered through
+ * `NgTemplateOutlet`, never a recursive component: a component host between
+ * a `ul` and its `li`, or between the region and its first block, would break
+ * `prose`'s child combinators.
+ */
+declare class SlMarkdown {
+    /** The document, as mdast — remark's `fromMarkdown`, or `fromMarkedTokens(marked.lexer(source))`. */
+    readonly tree: _angular_core.InputSignal<MarkdownNode | null | undefined>;
+    readonly size: _angular_core.InputSignal<ProseSize | undefined>;
+    readonly flow: _angular_core.InputSignal<ProseFlow | undefined>;
+    readonly status: _angular_core.InputSignal<MarkdownStatus>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly streaming: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly external: _angular_core.InputSignal<MarkdownExternal | undefined>;
+    readonly headingAnchors: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly headingOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly idPrefix: _angular_core.InputSignal<string>;
+    readonly alerts: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly allow: _angular_core.InputSignal<readonly string[] | undefined>;
+    readonly unwrapDisallowed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly transformUrl: _angular_core.InputSignal<((url: string, kind: MarkdownUrlKind, node: MarkdownNode) => string | null) | undefined>;
+    readonly isExternal: _angular_core.InputSignal<((href: string) => boolean) | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * empty, error, retry and loading texts, the footnotes heading, the back
+     * link, the heading permalink, and each alert's title (`alerts.note`).
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<MarkdownMessages> | undefined>;
+    /**
+     * Enables the task checkboxes. React reads the presence of its handler; an
+     * Angular output cannot tell whether anyone listens, so the template says so.
+     */
+    readonly editableTasks: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Draws the retry button in the error part, for the same reason. */
+    readonly retryable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** A task the reader ticked, with its index; the box moves when the tree does. */
+    readonly taskChange: _angular_core.OutputEmitterRef<MarkdownTaskChange>;
+    readonly retry: _angular_core.OutputEmitterRef<MarkdownRetryReason>;
+    private readonly templates;
+    private readonly nodesTemplate;
+    private readonly defaults;
+    private readonly proseDefaults;
+    private readonly skeletonDefaults;
+    protected readonly resolvedFlow: _angular_core.Signal<ProseFlow>;
+    protected readonly resolvedExternal: _angular_core.Signal<MarkdownExternal>;
+    protected readonly resolvedHeadingAnchors: _angular_core.Signal<boolean>;
+    /** The family's words in the language in force, with this document's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<MarkdownMessages>;
+    private readonly templateMap;
+    /** The prepared document: headings, footnotes and the outline a table of contents reads. */
+    readonly document: _angular_core.Signal<_slotted_core_markdown.MarkdownDocument>;
+    protected readonly painted: _angular_core.WritableSignal<boolean>;
+    private visibility;
+    private timer;
+    constructor();
+    /** @internal The template a node's children render through, for `slMarkdownChildren`. */
+    childrenTemplate(): TemplateRef<unknown>;
+    protected alertTitle(element: MarkdownAlertElement): string;
+    protected templateFor(element: MarkdownElement): TemplateRef<MarkdownNodeContext> | undefined;
+    protected footnoteLead(footnote: MarkdownFootnote): readonly MarkdownElement[];
+    protected footnoteTail(footnote: MarkdownFootnote): _slotted_core_markdown.MarkdownParentElement | null;
+    protected onTask(element: MarkdownItemElement, request: ChangeRequest<boolean>): void;
+    private tick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMarkdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMarkdown, "[slMarkdown]", ["slMarkdown"], { "tree": { "alias": "tree"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "flow": { "alias": "flow"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "external": { "alias": "external"; "required": false; "isSignal": true; }; "headingAnchors": { "alias": "headingAnchors"; "required": false; "isSignal": true; }; "headingOffset": { "alias": "headingOffset"; "required": false; "isSignal": true; }; "idPrefix": { "alias": "idPrefix"; "required": false; "isSignal": true; }; "alerts": { "alias": "alerts"; "required": false; "isSignal": true; }; "allow": { "alias": "allow"; "required": false; "isSignal": true; }; "unwrapDisallowed": { "alias": "unwrapDisallowed"; "required": false; "isSignal": true; }; "transformUrl": { "alias": "transformUrl"; "required": false; "isSignal": true; }; "isExternal": { "alias": "isExternal"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "editableTasks": { "alias": "editableTasks"; "required": false; "isSignal": true; }; "retryable": { "alias": "retryable"; "required": false; "isSignal": true; }; }, { "taskChange": "taskChange"; "retry": "retry"; }, ["templates"], ["[slMarkdownEmpty]"], true, never>;
+}
+/**
+ * Renders an element's children inside a node template, adding no element of
+ * its own: `<ng-container [slMarkdownChildren]="element" />`.
+ */
+declare class SlMarkdownChildren {
+    readonly element: _angular_core.InputSignal<{
+        readonly children?: readonly MarkdownElement[];
+    }>;
+    private readonly markdown;
+    private readonly container;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMarkdownChildren, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMarkdownChildren, "[slMarkdownChildren]", never, { "element": { "alias": "slMarkdownChildren"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { MARKDOWN_DEFAULTS, SlMarkdown, SlMarkdownChildren, SlMarkdownEmpty, SlMarkdownNode, injectMarkdownDefaults, provideMarkdownDefaults };
+export type { MarkdownDefaults, MarkdownExternal, MarkdownNodeContext, MarkdownRetryReason, MarkdownStatus, MarkdownTaskChange, MarkdownTemplateElement };
+//# sourceMappingURL=slotted-angular-markdown.d.ts.map

package/types/slotted-angular-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-markdown.d.ts","sources":["../../markdown/src/markdown-defaults.ts","../../markdown/src/markdown.ts"],"mappings":";;;;;;;;;AAGA;KACY,gBAAgB;AAE5B;UACiB,gBAAgB;AAC/B;AACA;AACA,eAAW,gBAAgB;AAC3B;AACA;wCAEuB,eAAe,QAAQ,YAAY;AAC3D;AAED,cAAa,iBAAiB,EAAA,cAAA,CAAA,gBAAA;AAK9B;;;;AAIG;AACH,iBAAgB,uBAAuB,WAAW,gBAAgB;;;AAEjE;AAED,iBAAgB,sBAAsB,IAAI,gBAAgB;;AC4B1D;KACY,cAAc;AAE1B;UACiB,kBAAkB;;;AAGjC;AACA,aAAS,aAAa;AACvB;AAED;KACY,mBAAmB;AAE/B,KAAK,MAAM;AACX,KAAK,OAAO,cAAc,WAAW;AAMrC;;;;;AAKG;AACG,KAAM,uBAAuB;AAAK,mBAAe,YAAY;AAAE;;mBACpD,OAAO,CAAC,MAAM,CAAC,eAAe,sBAAsB,OAAO,CAAC,eAAe;;AAG5F;UACiB,mBAAmB;eACvB,uBAAuB;AACnC;AAED;;;;;AAKG;AACH,cACa,cAAc;mBACZ,aAAA,CAAA,WAAA;uBACI,WAAA,CAAA,mBAAA;AAEjB,8CACc,cAAc,gCAEd,mBAAmB;oDAPtB,cAAc;sDAAd,cAAc;AAU1B;AAED;AACA,cACa,eAAe;oDAAf,eAAe;sDAAf,eAAe;AAAG;AAuB/B;;;;;;;;;;;;;AAaG;AACH,cA2Va,UAAU;;mBAER,aAAA,CAAA,WAAA,CAAA,YAAA;mBACA,aAAA,CAAA,WAAA,CAAA,SAAA;mBACA,aAAA,CAAA,WAAA,CAAA,SAAA;qBACE,aAAA,CAAA,WAAA,CAAA,cAAA;sBACC,aAAA,CAAA,wBAAA;wBACE,aAAA,CAAA,wBAAA;uBACD,aAAA,CAAA,WAAA,CAAA,gBAAA;6BACM,aAAA,CAAA,wBAAA;4BAGD,aAAA,CAAA,wBAAA;uBACL,aAAA,CAAA,WAAA;qBACF,aAAA,CAAA,wBAAA;oBAGD,aAAA,CAAA,WAAA;+BACW,aAAA,CAAA,wBAAA;AACzB,2BAAqB,aAAA,CAAA,WAAA,sBACE,eAAe,QAAQ,YAAY;AAE1D,yBAAmB,aAAA,CAAA,WAAA;AACnB;;;;AAIG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,gBAAA;AACjB;;;AAGG;4BACmB,aAAA,CAAA,wBAAA;;wBAEJ,aAAA,CAAA,wBAAA;;yBAGC,aAAA,CAAA,gBAAA,CAAA,kBAAA;oBACL,aAAA,CAAA,gBAAA,CAAA,mBAAA;AAEd;AACA;AAEA;AACA;AACA;AAEA,qCAA+B,aAAA,CAAA,MAAA,CAAA,SAAA;AAC/B,yCAAmC,aAAA,CAAA,MAAA,CAAA,gBAAA;AAGnC,+CAAyC,aAAA,CAAA,MAAA;;gBAI/B,kBAAA,CAAA,gBAAA,CAAA,gBAAA;AAEV;;uBAOiB,aAAA,CAAA,MAAA,CAAA,sBAAA,CAAA,gBAAA;AAkBjB,gCAA0B,aAAA,CAAA,cAAA;;;;;AAa1B,wBAAoB,WAAW;AAI/B,kCAA8B,oBAAoB;AAIlD,mCAA+B,eAAe,GAAG,WAAW,CAAC,mBAAmB;qCAI/C,gBAAgB,YAAY,eAAe;AAM5E,qCAAiC,gBAAgB,GAAA,sBAAA,CAAA,qBAAA;AAKjD,8BAA0B,mBAAmB,WAAW,aAAa;AASrE;oDAhIW,UAAU;sDAAV,UAAU;AA+ItB;AAED;;;AAGG;AACH,cACa,kBAAkB;AAC7B,sBAAgB,aAAA,CAAA,WAAA;AAAwC,qCAAS,eAAe;AAE7E;AACH;AACA;;oDALW,kBAAkB;sDAAlB,kBAAkB;AAkB9B;;","names":[]}