init

node_modules/ng-zorro-antd/core/animation/index.d.ts

@@ -0,0 +1,112 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare class AnimationDuration {
+    static SLOW: string;
+    static BASE: string;
+    static FAST: string;
+}
+declare class AnimationCurves {
+    static EASE_BASE_OUT: string;
+    static EASE_BASE_IN: string;
+    static EASE_OUT: string;
+    static EASE_IN: string;
+    static EASE_IN_OUT: string;
+    static EASE_OUT_BACK: string;
+    static EASE_IN_BACK: string;
+    static EASE_IN_OUT_BACK: string;
+    static EASE_OUT_CIRC: string;
+    static EASE_IN_CIRC: string;
+    static EASE_IN_OUT_CIRC: string;
+    static EASE_OUT_QUINT: string;
+    static EASE_IN_QUINT: string;
+    static EASE_IN_OUT_QUINT: string;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const collapseMotion: AnimationTriggerMetadata;
+declare const treeCollapseMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const drawerMaskMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const fadeMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const helpMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const moveUpMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const notificationMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const slideMotion: AnimationTriggerMetadata;
+declare const slideAlertMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const tabSwitchMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * a move and resize transition in the horizontal or vertical direction
+ */
+interface ThumbAnimationProps {
+    transform: number;
+    width: number;
+    height?: number;
+    vertical?: boolean;
+}
+declare const thumbMotion: AnimationTriggerMetadata;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const zoomBigMotion: AnimationTriggerMetadata;
+declare const zoomBadgeMotion: AnimationTriggerMetadata;
+
+export { AnimationCurves, AnimationDuration, collapseMotion, drawerMaskMotion, fadeMotion, helpMotion, moveUpMotion, notificationMotion, slideAlertMotion, slideMotion, tabSwitchMotion, thumbMotion, treeCollapseMotion, zoomBadgeMotion, zoomBigMotion };
+export type { ThumbAnimationProps };

node_modules/ng-zorro-antd/core/animation/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-animation.mjs"
+}

node_modules/ng-zorro-antd/core/color/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare const statusColors: readonly ["success", "processing", "error", "default", "warning"];
+declare const presetColors: readonly ["pink", "red", "yellow", "orange", "cyan", "green", "blue", "purple", "geekblue", "magenta", "volcano", "gold", "lime"];
+type NzPresetColor = (typeof presetColors)[number];
+type NzStatusColor = (typeof statusColors)[number];
+declare function isPresetColor(color: string): color is NzPresetColor;
+declare function isStatusColor(color: string): color is NzPresetColor;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+interface Opts {
+    theme?: 'dark' | 'default';
+    backgroundColor?: string;
+}
+declare function generate(color: string, opts?: Opts): string[];
+
+export { generate, isPresetColor, isStatusColor, presetColors, statusColors };
+export type { NzPresetColor, NzStatusColor };

node_modules/ng-zorro-antd/core/color/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-color.mjs"
+}

node_modules/ng-zorro-antd/core/config/index.d.ts

@@ -0,0 +1,409 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, Type, InjectionToken, EnvironmentProviders, InputSignal, InputSignalWithTransform, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Direction } from '@angular/cdk/bidi';
+import { SafeUrl } from '@angular/platform-browser';
+import { ThemeType } from '@ant-design/icons-angular';
+import { NzBreakpointEnum } from 'ng-zorro-antd/core/services';
+import { NzSafeAny, NzShapeSCType, NzSizeLDSType, NzSizeDSType, NzSizeMDSType, NzTSType } from 'ng-zorro-antd/core/types';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+interface MonacoEnvironment {
+    globalAPI?: boolean;
+    baseUrl?: string;
+    getWorker?(workerId: string, label: string): Promise<Worker> | Worker;
+    getWorkerUrl?(workerId: string, label: string): string;
+}
+interface NzConfig {
+    affix?: AffixConfig;
+    select?: SelectConfig;
+    alert?: AlertConfig;
+    anchor?: AnchorConfig;
+    avatar?: AvatarConfig;
+    backTop?: BackTopConfig;
+    badge?: BadgeConfig;
+    button?: ButtonConfig;
+    card?: CardConfig;
+    carousel?: CarouselConfig;
+    cascader?: CascaderConfig;
+    codeEditor?: CodeEditorConfig;
+    collapse?: CollapseConfig;
+    collapsePanel?: CollapsePanelConfig;
+    datePicker?: DatePickerConfig;
+    descriptions?: DescriptionsConfig;
+    drawer?: DrawerConfig;
+    dropDown?: DropDownConfig;
+    empty?: EmptyConfig;
+    filterTrigger?: FilterTriggerConfig;
+    form?: FormConfig;
+    icon?: IconConfig;
+    message?: MessageConfig;
+    modal?: ModalConfig;
+    notification?: NotificationConfig;
+    pageHeader?: PageHeaderConfig;
+    pagination?: PaginationConfig;
+    progress?: ProgressConfig;
+    rate?: RateConfig;
+    segmented?: SegmentedConfig;
+    space?: SpaceConfig;
+    spin?: SpinConfig;
+    switch?: SwitchConfig;
+    table?: TableConfig;
+    tabs?: TabsConfig;
+    timePicker?: TimePickerConfig;
+    tree?: TreeConfig;
+    treeSelect?: TreeSelectConfig;
+    typography?: TypographyConfig;
+    image?: ImageConfig;
+    popconfirm?: PopConfirmConfig;
+    popover?: PopoverConfig;
+    imageExperimental?: ImageExperimentalConfig;
+    theme?: Theme;
+    prefixCls?: PrefixCls;
+}
+interface PrefixCls {
+    prefixCls?: string;
+    iconPrefixCls?: string;
+}
+interface Theme {
+    primaryColor?: string;
+    infoColor?: string;
+    successColor?: string;
+    processingColor?: string;
+    errorColor?: string;
+    warningColor?: string;
+    [key: string]: string | undefined;
+}
+interface SelectConfig {
+    nzBorderless?: boolean;
+    nzSuffixIcon?: TemplateRef<NzSafeAny> | string | null;
+    nzBackdrop?: boolean;
+    nzOptionHeightPx?: number;
+}
+interface AffixConfig {
+    nzOffsetBottom?: number;
+    nzOffsetTop?: number;
+}
+interface AlertConfig {
+    nzCloseable?: boolean;
+    nzShowIcon?: boolean;
+}
+interface AvatarConfig {
+    nzShape?: NzShapeSCType;
+    nzSize?: NzSizeLDSType | number;
+    nzGap?: number;
+}
+interface AnchorConfig {
+    nzBounds?: number;
+    nzOffsetBottom?: number;
+    nzOffsetTop?: number;
+    nzShowInkInFixed?: boolean;
+}
+interface BackTopConfig {
+    nzVisibilityHeight?: number;
+}
+interface BadgeConfig {
+    nzColor?: number;
+    nzOverflowCount?: number;
+    nzShowZero?: number;
+}
+interface ButtonConfig {
+    nzSize?: 'large' | 'default' | 'small';
+}
+interface CodeEditorConfig {
+    assetsRoot?: string | SafeUrl;
+    extraConfig?: NzSafeAny;
+    defaultEditorOption?: NzSafeAny;
+    useStaticLoading?: boolean;
+    monacoEnvironment?: MonacoEnvironment;
+    onLoad?(): void;
+    onFirstEditorInit?(): void;
+    onInit?(): void;
+}
+interface CardConfig {
+    nzSize?: NzSizeDSType;
+    nzHoverable?: boolean;
+    nzBordered?: boolean;
+}
+interface CarouselConfig {
+    nzAutoPlay?: boolean;
+    nzAutoPlaySpeed?: boolean;
+    nzDots?: boolean;
+    nzEffect?: 'scrollx' | 'fade' | string;
+    nzEnableSwipe?: boolean;
+    nzVertical?: boolean;
+    nzLoop?: boolean;
+}
+interface CascaderConfig {
+    nzSize?: string;
+    nzBackdrop?: boolean;
+}
+interface CollapseConfig {
+    nzAccordion?: boolean;
+    nzBordered?: boolean;
+    nzGhost?: boolean;
+}
+interface CollapsePanelConfig {
+    nzShowArrow?: boolean;
+}
+interface DatePickerConfig {
+    nzSeparator?: string;
+    nzSuffixIcon?: string | TemplateRef<NzSafeAny>;
+    nzBackdrop?: boolean;
+}
+interface DescriptionsConfig {
+    nzBordered?: boolean;
+    nzColumn?: Partial<Record<NzBreakpointEnum, number>> | number;
+    nzSize?: 'default' | 'middle' | 'small';
+    nzColon?: boolean;
+}
+interface DrawerConfig {
+    nzMask?: boolean;
+    nzMaskClosable?: boolean;
+    nzCloseOnNavigation?: boolean;
+    nzDirection?: Direction;
+}
+interface DropDownConfig {
+    nzBackdrop?: boolean;
+}
+interface EmptyConfig {
+    nzDefaultEmptyContent?: Type<NzSafeAny> | TemplateRef<string> | string | undefined;
+}
+interface FilterTriggerConfig {
+    nzBackdrop?: boolean;
+}
+interface FormConfig {
+    nzNoColon?: boolean;
+    nzAutoTips?: Record<string, Record<string, string>>;
+    nzTooltipIcon?: string | {
+        type: string;
+        theme: ThemeType;
+    };
+}
+interface IconConfig {
+    nzTheme?: 'fill' | 'outline' | 'twotone';
+    nzTwotoneColor?: string;
+}
+interface MessageConfig {
+    nzAnimate?: boolean;
+    nzDuration?: number;
+    nzMaxStack?: number;
+    nzPauseOnHover?: boolean;
+    nzTop?: number | string;
+    nzDirection?: Direction;
+}
+interface ModalConfig {
+    nzMask?: boolean;
+    nzMaskClosable?: boolean;
+    nzCloseOnNavigation?: boolean;
+    nzDirection?: Direction;
+}
+interface NotificationConfig extends MessageConfig {
+    nzTop?: string | number;
+    nzBottom?: string | number;
+    nzPlacement?: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'top' | 'bottom';
+}
+interface PageHeaderConfig {
+    nzGhost: boolean;
+}
+interface PaginationConfig {
+    nzSize?: 'default' | 'small';
+    nzPageSizeOptions?: number[];
+    nzShowSizeChanger?: boolean;
+    nzShowQuickJumper?: boolean;
+    nzSimple?: boolean;
+}
+interface ProgressConfig {
+    nzGapDegree?: number;
+    nzGapPosition?: 'top' | 'right' | 'bottom' | 'left';
+    nzShowInfo?: boolean;
+    nzStrokeSwitch?: number;
+    nzStrokeWidth?: number;
+    nzSize?: 'default' | 'small';
+    nzStrokeLinecap?: 'round' | 'square';
+    nzStrokeColor?: string;
+}
+interface RateConfig {
+    nzAllowClear?: boolean;
+    nzAllowHalf?: boolean;
+}
+interface SegmentedConfig {
+    nzSize?: NzSizeLDSType;
+}
+interface SpaceConfig {
+    nzSize?: 'small' | 'middle' | 'large' | number | Array<'small' | 'middle' | 'large' | number>;
+}
+interface SpinConfig {
+    nzIndicator?: TemplateRef<NzSafeAny>;
+}
+interface SwitchConfig {
+    nzSize: NzSizeDSType;
+}
+interface TableConfig {
+    nzBordered?: boolean;
+    nzSize?: NzSizeMDSType;
+    nzShowQuickJumper?: boolean;
+    nzLoadingIndicator?: TemplateRef<NzSafeAny>;
+    nzShowSizeChanger?: boolean;
+    nzSimple?: boolean;
+    nzHideOnSinglePage?: boolean;
+    /**
+     * @see {@link NzTableSortOrder}
+     */
+    nzSortDirections?: Array<string | 'ascend' | 'descend' | null>;
+}
+interface TabsConfig {
+    nzAnimated?: boolean | {
+        inkBar: boolean;
+        tabPane: boolean;
+    };
+    nzSize?: NzSizeLDSType;
+    nzType?: 'line' | 'card';
+    nzTabBarGutter?: number;
+    nzShowPagination?: boolean;
+}
+interface TimePickerConfig {
+    nzAllowEmpty?: boolean;
+    nzClearText?: string;
+    nzNowText?: string;
+    nzOkText?: string;
+    nzFormat?: string;
+    nzHourStep?: number;
+    nzMinuteStep?: number;
+    nzSecondStep?: number;
+    nzPopupClassName?: string;
+    nzUse12Hours?: string;
+    nzSuffixIcon?: string | TemplateRef<NzSafeAny>;
+    nzBackdrop?: boolean;
+}
+interface TreeConfig {
+    nzBlockNode?: boolean;
+    nzShowIcon?: boolean;
+    nzHideUnMatched?: boolean;
+}
+interface TreeSelectConfig {
+    nzShowIcon?: string;
+    nzShowLine?: boolean;
+    nzDropdownMatchSelectWidth?: boolean;
+    nzHideUnMatched?: boolean;
+    nzSize?: 'large' | 'small' | 'default';
+    nzBackdrop?: boolean;
+}
+interface TypographyConfig {
+    nzEllipsisRows?: number;
+    nzCopyTooltips?: [NzTSType, NzTSType] | null;
+    nzCopyIcons: [NzTSType, NzTSType];
+    nzEditTooltip?: null | NzTSType;
+    nzEditIcon: NzTSType;
+}
+interface ImageConfig {
+    nzFallback?: string;
+    nzPlaceholder?: string;
+    nzDisablePreview?: string;
+    nzCloseOnNavigation?: boolean;
+    nzDirection?: Direction;
+    nzScaleStep?: number;
+}
+interface ImageExperimentalConfig {
+    nzFallback?: string;
+    nzPlaceholder?: string;
+    nzDisablePreview?: string;
+    nzCloseOnNavigation?: boolean;
+    nzDirection?: Direction;
+    nzAutoSrcset?: boolean;
+    nzSrcLoader?(params: {
+        src: string;
+        width: number;
+    }): string;
+}
+interface PopConfirmConfig {
+    nzPopconfirmBackdrop?: boolean;
+    nzAutofocus?: null | 'ok' | 'cancel';
+}
+interface PopoverConfig {
+    nzPopoverBackdrop?: boolean;
+}
+type NzConfigKey = keyof NzConfig;
+/**
+ * User should provide an object implements this interface to set global configurations.
+ */
+declare const NZ_CONFIG: InjectionToken<NzConfig>;
+declare function provideNzConfig(config: NzConfig): EnvironmentProviders;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzConfigService {
+    private configUpdated$;
+    /** Global config holding property. */
+    private readonly config;
+    private readonly cspNonce;
+    constructor();
+    private _getConfigValue;
+    getConfig(): NzConfig;
+    getConfigForComponent<T extends NzConfigKey>(componentName: T): NzConfig[T];
+    getConfigChangeEventForComponent(componentName: NzConfigKey): Observable<void>;
+    set<T extends NzConfigKey>(componentName: T, value: NzConfig[T]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzConfigService>;
+}
+/**
+ * Subscribes to configuration change events for a specific NZ component after the next render cycle.
+ *
+ * This utility is intended for use within Angular injection contexts and handles automatic
+ * unsubscription via `DestroyRef`. It returns a cleanup function that can be manually called
+ * to unsubscribe early if needed.
+ *
+ * @param componentName - The name of the component (as defined in `NzConfigKey`) to listen for config changes.
+ * @param callback - A function to invoke when the component's configuration changes.
+ * @returns A cleanup function that destroys the post-render effect and unsubscribes from the config event.
+ *
+ * @throws If called outside of an Angular injection context (in dev mode).
+ */
+declare function onConfigChangeEventForComponent(componentName: NzConfigKey, callback: () => void): () => void;
+/**
+ * This decorator is used to decorate class field. If a class field is decorated and unassigned, it would try to load default value from `NZ_CONFIG`
+ *
+ * @note that the class must have `_nzModuleName`({@link NzConfigKey}) property.
+ * @example
+ * ```ts
+ * class ExampleComponent {
+ *   private readonly _nzModuleName: NzConfigKey = 'button';
+ *   @WithConfig() size: string = 'default';
+ * }
+ * ```
+ */
+declare function WithConfig<This, Value>(): (_value: undefined, context: ClassFieldDecoratorContext<This, Value>) => void;
+/**
+ * Generate a `withConfig` function for a specific component, which would try to load default value from `NZ_CONFIG`
+ * if the `input` property is not assigned by user.
+ *
+ * @param componentName The name of component (as defined in {@link NzConfigKey}) to listen for config changes.
+ * @example
+ * ```ts
+ * const withConfig = withConfigFactory('button');
+ *
+ * class ExampleComponent {
+ *   readonly nzSize = input<NzButtonSize>('default');
+ *   protected readonly size = withConfig('nzSize', this.nzSize);
+ * }
+ * ```
+ */
+declare function withConfigFactory<T extends NzConfigKey>(componentName: T): <N extends keyof NonNullable<NzConfig[T]>, V = NonNullable<NzConfig[T]>[N]>(name: N, inputSignal: InputSignal<V | undefined> | InputSignalWithTransform<V | undefined, unknown>, defaultValue: V) => Signal<V>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function getStyle(globalPrefixCls: string, theme: Theme): string;
+declare function registerTheme(globalPrefixCls: string, theme: Theme, cspNonce: string | null | undefined): void;
+
+export { NZ_CONFIG, NzConfigService, WithConfig, getStyle, onConfigChangeEventForComponent, provideNzConfig, registerTheme, withConfigFactory };
+export type { AffixConfig, AlertConfig, AnchorConfig, AvatarConfig, BackTopConfig, BadgeConfig, ButtonConfig, CardConfig, CarouselConfig, CascaderConfig, CodeEditorConfig, CollapseConfig, CollapsePanelConfig, DatePickerConfig, DescriptionsConfig, DrawerConfig, DropDownConfig, EmptyConfig, FilterTriggerConfig, FormConfig, IconConfig, ImageConfig, ImageExperimentalConfig, MessageConfig, ModalConfig, NotificationConfig, NzConfig, NzConfigKey, PageHeaderConfig, PaginationConfig, PopConfirmConfig, PopoverConfig, PrefixCls, ProgressConfig, RateConfig, SegmentedConfig, SelectConfig, SpaceConfig, SpinConfig, SwitchConfig, TableConfig, TabsConfig, Theme, TimePickerConfig, TreeConfig, TreeSelectConfig, TypographyConfig };

node_modules/ng-zorro-antd/core/config/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-config.mjs"
+}

node_modules/ng-zorro-antd/core/element-patch/index.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * A patch directive to select the element of a component.
+ */
+declare class NzElementPatchDirective {
+    elementRef: ElementRef<any>;
+    get nativeElement(): NzSafeAny;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzElementPatchDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzElementPatchDirective, "[nzElement], [nz-element]", ["nzElement"], {}, {}, never, never, true, never>;
+}
+
+declare class NzElementPatchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzElementPatchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzElementPatchModule, never, [typeof NzElementPatchDirective], [typeof NzElementPatchDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzElementPatchModule>;
+}
+
+export { NzElementPatchDirective, NzElementPatchModule };

node_modules/ng-zorro-antd/core/element-patch/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-element-patch.mjs"
+}

node_modules/ng-zorro-antd/core/environments/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare const environment: {
+    isTestMode: boolean;
+};
+
+export { environment };

node_modules/ng-zorro-antd/core/environments/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-environments.mjs"
+}

node_modules/ng-zorro-antd/core/form/index.d.ts

@@ -0,0 +1,45 @@
+import { ReplaySubject, BehaviorSubject } from 'rxjs';
+import { NzValidateStatus } from 'ng-zorro-antd/core/types';
+import * as i0 from '@angular/core';
+import { OnChanges, ChangeDetectorRef, SimpleChanges } from '@angular/core';
+
+declare class NzFormStatusService {
+    formStatusChanges: ReplaySubject<{
+        status: NzValidateStatus;
+        hasFeedback: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzFormStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzFormStatusService>;
+}
+
+/**
+ * @deprecated Will be removed in v22.0.0. This service will be removed along with input-group/input-number-group.
+ */
+declare class NzFormNoStatusService {
+    noFormStatus: BehaviorSubject<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzFormNoStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzFormNoStatusService>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const iconTypeMap: {
+    readonly error: "close-circle-fill";
+    readonly validating: "loading";
+    readonly success: "check-circle-fill";
+    readonly warning: "exclamation-circle-fill";
+};
+declare class NzFormItemFeedbackIconComponent implements OnChanges {
+    cdr: ChangeDetectorRef;
+    status: NzValidateStatus;
+    iconType: (typeof iconTypeMap)[keyof typeof iconTypeMap] | null;
+    ngOnChanges(_changes: SimpleChanges): void;
+    updateIcon(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzFormItemFeedbackIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NzFormItemFeedbackIconComponent, "nz-form-item-feedback-icon", ["nzFormFeedbackIcon"], { "status": { "alias": "status"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { NzFormItemFeedbackIconComponent, NzFormNoStatusService, NzFormStatusService };

node_modules/ng-zorro-antd/core/form/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-form.mjs"
+}

node_modules/ng-zorro-antd/core/highlight/index.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzHighlightPipe implements PipeTransform {
+    private UNIQUE_WRAPPERS;
+    transform(value: string, highlightValue: string, flags?: string, klass?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzHighlightPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NzHighlightPipe, "nzHighlight", true>;
+}
+
+/**
+ * @deprecated Will be removed in v21, use `NzHighlightPipe` directly instead.
+ */
+declare class NzHighlightModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzHighlightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzHighlightModule, never, [typeof NzHighlightPipe], [typeof NzHighlightPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzHighlightModule>;
+}
+
+export { NzHighlightModule, NzHighlightPipe };

node_modules/ng-zorro-antd/core/highlight/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-highlight.mjs"
+}

node_modules/ng-zorro-antd/core/logger/index.d.ts

@@ -0,0 +1,13 @@
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const PREFIX = "[NG-ZORRO]:";
+declare const warn: (...args: NzSafeAny[]) => void;
+declare const warnDeprecation: (...args: NzSafeAny[]) => void | (() => void);
+declare const log: (...args: NzSafeAny[]) => void;
+
+export { PREFIX, log, warn, warnDeprecation };

node_modules/ng-zorro-antd/core/logger/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-logger.mjs"
+}

node_modules/ng-zorro-antd/core/no-animation/index.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from '@angular/core';
+
+declare class NzNoAnimationDirective {
+    animationType: "NoopAnimations" | "BrowserAnimations" | null;
+    nzNoAnimation: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzNoAnimationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzNoAnimationDirective, "[nzNoAnimation]", ["nzNoAnimation"], { "nzNoAnimation": { "alias": "nzNoAnimation"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_nzNoAnimation: unknown;
+}
+
+declare class NzNoAnimationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzNoAnimationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzNoAnimationModule, never, [typeof NzNoAnimationDirective], [typeof NzNoAnimationDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzNoAnimationModule>;
+}
+
+export { NzNoAnimationDirective, NzNoAnimationModule };

node_modules/ng-zorro-antd/core/no-animation/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-no-animation.mjs"
+}

node_modules/ng-zorro-antd/core/outlet/index.d.ts

@@ -0,0 +1,34 @@
+import * as i0 from '@angular/core';
+import { OnChanges, TemplateRef, SimpleChanges } from '@angular/core';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzStringTemplateOutletDirective<_T = unknown> implements OnChanges {
+    private viewContainer;
+    private templateRef;
+    private embeddedViewRef;
+    private context;
+    nzStringTemplateOutletContext: NzSafeAny | null;
+    nzStringTemplateOutlet: NzSafeAny | TemplateRef<NzSafeAny>;
+    static ngTemplateContextGuard<T>(_dir: NzStringTemplateOutletDirective<T>, _ctx: NzSafeAny): _ctx is NzStringTemplateOutletContext;
+    private recreateView;
+    private updateContext;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzStringTemplateOutletDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzStringTemplateOutletDirective<any>, "[nzStringTemplateOutlet]", ["nzStringTemplateOutlet"], { "nzStringTemplateOutletContext": { "alias": "nzStringTemplateOutletContext"; "required": false; }; "nzStringTemplateOutlet": { "alias": "nzStringTemplateOutlet"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class NzStringTemplateOutletContext {
+    $implicit: NzSafeAny;
+}
+
+declare class NzOutletModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzOutletModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzOutletModule, never, [typeof NzStringTemplateOutletDirective], [typeof NzStringTemplateOutletDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzOutletModule>;
+}
+
+export { NzOutletModule, NzStringTemplateOutletDirective };

node_modules/ng-zorro-antd/core/outlet/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-outlet.mjs"
+}

node_modules/ng-zorro-antd/core/overlay/index.d.ts

@@ -0,0 +1,69 @@
+import * as i0 from '@angular/core';
+import { ConnectionPositionPair, ConnectedOverlayPositionChange, OverlayRef } from '@angular/cdk/overlay';
+
+declare class NzConnectedOverlayDirective {
+    private readonly cdkConnectedOverlay;
+    nzArrowPointAtCenter: boolean;
+    constructor();
+    private updateArrowPosition;
+    private getFlexibleConnectedPositionStrategyOrigin;
+    private getOriginRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzConnectedOverlayDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzConnectedOverlayDirective, "[cdkConnectedOverlay][nzConnectedOverlay]", ["nzConnectedOverlay"], { "nzArrowPointAtCenter": { "alias": "nzArrowPointAtCenter"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_nzArrowPointAtCenter: unknown;
+}
+
+declare class NzOverlayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzOverlayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzOverlayModule, never, [typeof NzConnectedOverlayDirective], [typeof NzConnectedOverlayDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzOverlayModule>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const POSITION_MAP: {
+    top: ConnectionPositionPair;
+    topCenter: ConnectionPositionPair;
+    topLeft: ConnectionPositionPair;
+    topRight: ConnectionPositionPair;
+    right: ConnectionPositionPair;
+    rightTop: ConnectionPositionPair;
+    rightBottom: ConnectionPositionPair;
+    bottom: ConnectionPositionPair;
+    bottomCenter: ConnectionPositionPair;
+    bottomLeft: ConnectionPositionPair;
+    bottomRight: ConnectionPositionPair;
+    left: ConnectionPositionPair;
+    leftTop: ConnectionPositionPair;
+    leftBottom: ConnectionPositionPair;
+};
+type POSITION_TYPE = keyof typeof POSITION_MAP;
+type POSITION_TYPE_HORIZONTAL = Extract<POSITION_TYPE, 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'topLeft' | 'topCenter' | 'topRight'>;
+declare const TOOLTIP_OFFSET_MAP: Record<string, [number, number]>;
+declare const DEFAULT_TOOLTIP_POSITIONS: ConnectionPositionPair[];
+declare const DEFAULT_CASCADER_POSITIONS: ConnectionPositionPair[];
+declare const DEFAULT_MENTION_TOP_POSITIONS: ConnectionPositionPair[];
+declare const DEFAULT_MENTION_BOTTOM_POSITIONS: ConnectionPositionPair[];
+declare function getPlacementName(position: ConnectedOverlayPositionChange): string | undefined;
+declare const DATE_PICKER_POSITION_MAP: {
+    bottomLeft: ConnectionPositionPair;
+    topLeft: ConnectionPositionPair;
+    bottomRight: ConnectionPositionPair;
+    topRight: ConnectionPositionPair;
+};
+declare const DEFAULT_DATE_PICKER_POSITIONS: ConnectionPositionPair[];
+declare function normalizeConnectedPositionOffset(offset: number | [number, number]): [number, number];
+declare function setConnectedPositionOffset(position: ConnectionPositionPair, offset: number | [number, number]): ConnectionPositionPair;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function overlayZIndexSetter(overlayRef: OverlayRef, zIndex?: number): void;
+
+export { DATE_PICKER_POSITION_MAP, DEFAULT_CASCADER_POSITIONS, DEFAULT_DATE_PICKER_POSITIONS, DEFAULT_MENTION_BOTTOM_POSITIONS, DEFAULT_MENTION_TOP_POSITIONS, DEFAULT_TOOLTIP_POSITIONS, NzConnectedOverlayDirective, NzOverlayModule, POSITION_MAP, TOOLTIP_OFFSET_MAP, getPlacementName, normalizeConnectedPositionOffset, overlayZIndexSetter, setConnectedPositionOffset };
+export type { POSITION_TYPE, POSITION_TYPE_HORIZONTAL };

node_modules/ng-zorro-antd/core/overlay/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-overlay.mjs"
+}

node_modules/ng-zorro-antd/core/pipe/index.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzTimeRangePipe implements PipeTransform {
+    transform(value: string | number, format?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzTimeRangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NzTimeRangePipe, "nzTimeRange", true>;
+}
+
+declare class NzPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzPipesModule, never, [typeof NzTimeRangePipe], [typeof NzTimeRangePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzPipesModule>;
+}
+
+export { NzPipesModule, NzTimeRangePipe };

node_modules/ng-zorro-antd/core/pipe/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-pipe.mjs"
+}

node_modules/ng-zorro-antd/core/polyfill/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare const requestAnimationFrame: typeof globalThis.requestAnimationFrame | typeof setTimeout;
+declare const cancelAnimationFrame: typeof globalThis.cancelAnimationFrame;
+
+export { cancelAnimationFrame, requestAnimationFrame };

node_modules/ng-zorro-antd/core/polyfill/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-polyfill.mjs"
+}

node_modules/ng-zorro-antd/core/render/index.d.ts

@@ -0,0 +1,17 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * An injection token representing `afterNextRender` as an observable rather
+ * than a callback-based API has been added. This might be necessary in code
+ * where streams of data are already being used and we need to wait until
+ * the change detection ends before performing any tasks.
+ */
+declare const NZ_AFTER_NEXT_RENDER$: InjectionToken<Observable<void>>;
+
+export { NZ_AFTER_NEXT_RENDER$ };

node_modules/ng-zorro-antd/core/render/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-render.mjs"
+}

node_modules/ng-zorro-antd/core/services/index.d.ts

@@ -0,0 +1,152 @@
+import { Observable, Subject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+
+declare class NzResizeService {
+    private ngZone;
+    private destroyRef;
+    private readonly resizeSource$;
+    private listeners;
+    private renderer;
+    private disposeHandle;
+    private handler;
+    constructor();
+    connect(): Observable<void>;
+    disconnet(): void;
+    private registerListener;
+    private unregisterListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzResizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzResizeService>;
+}
+
+/**
+ * Some singletons should have life cycle that is same to Angular's. This service make sure that
+ * those singletons get destroyed in HMR.
+ */
+declare class NzSingletonService {
+    private get singletonRegistry();
+    /**
+     * This registry is used to register singleton in dev mode.
+     * So that singletons get destroyed when hot module reload happens.
+     *
+     * This works in prod mode too but with no specific effect.
+     */
+    private _singletonRegistry;
+    registerSingletonWithKey(key: string, target: NzSafeAny): void;
+    unregisterSingletonWithKey(key: string): void;
+    getSingletonWithKey<T>(key: string): T | null;
+    private withNewTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzSingletonService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzSingletonService>;
+}
+
+interface Point {
+    x: number;
+    y: number;
+}
+type Delta = Point;
+/**
+ * This module provide a global dragging service to other components.
+ */
+declare class NzDragService {
+    private draggingThreshold;
+    private currentDraggingSequence;
+    private currentStartingPoint;
+    private handleRegistry;
+    private renderer;
+    requestDraggingSequence(event: MouseEvent | TouchEvent): Observable<Delta>;
+    private registerDraggingHandler;
+    private teardownDraggingSequence;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzDragService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzDragService>;
+}
+
+type EasyingFn = (t: number, b: number, c: number, d: number) => number;
+interface NzScrollToOptions {
+    /** Scroll container, default as window */
+    easing?: EasyingFn;
+    /** Scroll end callback */
+    callback?(): void;
+    /** Animation duration, default as 450 */
+    duration?: number;
+}
+declare class NzScrollService {
+    private doc;
+    private ngZone;
+    /** Set the position of the scroll bar of `el`. */
+    setScrollTop(el: Element | Window, topValue?: number): void;
+    /** Get position of `el` against window. */
+    getOffset(el: Element): {
+        top: number;
+        left: number;
+    };
+    /** Get the position of the scoll bar of `el`. */
+    getScroll(target?: Element | HTMLElement | Window | Document | null, top?: boolean): number;
+    isWindow(obj: NzSafeAny): boolean;
+    /**
+     * Scroll `el` to some position with animation.
+     *
+     * @param containerEl container, `window` by default
+     * @param y Scroll to `top`, 0 by default
+     * @param options Scroll animation options
+     */
+    scrollTo(containerEl?: Element | HTMLElement | Window | Document | null, y?: number, options?: NzScrollToOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzScrollService>;
+}
+
+declare enum NzBreakpointEnum {
+    xxl = "xxl",
+    xl = "xl",
+    lg = "lg",
+    md = "md",
+    sm = "sm",
+    xs = "xs"
+}
+type BreakpointMap = Record<NzBreakpointEnum, string>;
+type BreakpointBooleanMap = Record<NzBreakpointEnum, boolean>;
+type NzBreakpointKey = keyof typeof NzBreakpointEnum;
+declare const gridResponsiveMap: BreakpointMap;
+declare const siderResponsiveMap: BreakpointMap;
+declare class NzBreakpointService {
+    private resizeService;
+    private mediaMatcher;
+    constructor();
+    subscribe(breakpointMap: BreakpointMap): Observable<NzBreakpointEnum>;
+    subscribe(breakpointMap: BreakpointMap, fullMap: true): Observable<BreakpointBooleanMap>;
+    private matchMedia;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzBreakpointService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzBreakpointService>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzDestroyService extends Subject<void> implements OnDestroy {
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzDestroyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzDestroyService>;
+}
+
+interface PreloadOption {
+    src: string;
+    srcset?: string;
+}
+type PreloadDisposeHandle = () => void;
+declare class ImagePreloadService {
+    private counter;
+    private linkRefs;
+    private document;
+    private platform;
+    addPreload(option: PreloadOption): PreloadDisposeHandle;
+    private appendPreloadLink;
+    private removePreloadLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImagePreloadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImagePreloadService>;
+}
+
+export { ImagePreloadService, NzBreakpointEnum, NzBreakpointService, NzDestroyService, NzDragService, NzResizeService, NzScrollService, NzSingletonService, gridResponsiveMap, siderResponsiveMap };
+export type { BreakpointBooleanMap, BreakpointMap, EasyingFn, NzBreakpointKey, NzScrollToOptions, PreloadDisposeHandle };

node_modules/ng-zorro-antd/core/services/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-services.mjs"
+}

node_modules/ng-zorro-antd/core/testing/index.d.ts

@@ -0,0 +1,69 @@
+import * as i0 from '@angular/core';
+import { NgZone, EventEmitter } from '@angular/core';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+/** Utility to dispatch any event on a Node. */
+declare function dispatchEvent(node: Node | Window, event: Event): Event;
+/** Shorthand to dispatch a fake event on a specified node. */
+declare function dispatchFakeEvent(node: Node | Window, type: string, canBubble?: boolean): Event;
+/** Shorthand to dispatch a keyboard event with a specified key code. */
+declare function dispatchKeyboardEvent(node: Node, type: string, keyCode: number, target?: Element): KeyboardEvent;
+/** Shorthand to dispatch a mouse event on the specified coordinates. */
+declare function dispatchMouseEvent(node: Node, type: string, x?: number, y?: number, event?: MouseEvent): MouseEvent;
+/** Shorthand to dispatch a touch event on the specified coordinates. */
+declare function dispatchTouchEvent(node: Node, type: string, x?: number, y?: number): TouchEvent;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+/** Creates a browser MouseEvent with the specified options. */
+declare function createMouseEvent(type: string, x?: number, y?: number, button?: number): MouseEvent;
+/** Creates a browser TouchEvent with the specified pointer coordinates. */
+declare function createTouchEvent(type: string, pageX?: number, pageY?: number): UIEvent;
+/** Dispatches a keydown event from an element. */
+declare function createKeyboardEvent(type: string, keyCode: number, target?: Element, key?: string, ctrlKey?: boolean, metaKey?: boolean, shiftKey?: boolean): KeyboardEvent;
+/** Creates a fake event object with any desired event type. */
+declare function createFakeEvent(type: string, canBubble?: boolean, cancelable?: boolean): Event;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+/**
+ * Focuses an input, sets its value and dispatches
+ * the `input` event, simulating the user typing.
+ *
+ * @param value Value to be set on the input.
+ * @param element Element onto which to set the value.
+ */
+declare function typeInElement(value: string, element: HTMLInputElement | HTMLTextAreaElement): void;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * Mock synchronous NgZone implementation that can be used
+ * to flush out `onStable` subscriptions in tests.
+ *
+ * via: https://github.com/angular/angular/blob/master/packages/core/testing/src/ng_zone_mock.ts
+ *
+ * @docs-private
+ */
+declare class MockNgZone extends NgZone {
+    onStable: EventEmitter<any>;
+    constructor();
+    run(fn: () => NzSafeAny): NzSafeAny;
+    runOutsideAngular(fn: () => NzSafeAny): NzSafeAny;
+    simulateZoneExit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MockNgZone, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MockNgZone>;
+}
+
+export { MockNgZone, createFakeEvent, createKeyboardEvent, createMouseEvent, createTouchEvent, dispatchEvent, dispatchFakeEvent, dispatchKeyboardEvent, dispatchMouseEvent, dispatchTouchEvent, typeInElement };

node_modules/ng-zorro-antd/core/testing/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-testing.mjs"
+}

node_modules/ng-zorro-antd/core/time/index.d.ts

@@ -0,0 +1,100 @@
+import { IndexableObject } from 'ng-zorro-antd/core/types';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+type CandyDateMode = 'decade' | 'year' | 'quarter' | 'month' | 'day' | 'hour' | 'minute' | 'second';
+type NormalizedMode = 'decade' | 'year' | 'month';
+type WeekDayIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+type CandyDateType = CandyDate | Date | null;
+type SingleValue = CandyDate | null;
+type CompatibleValue = SingleValue | SingleValue[];
+declare function wrongSortOrder(rangeValue: SingleValue[]): boolean;
+declare function normalizeRangeValue(value: SingleValue[], hasTimePicker: boolean, type?: NormalizedMode, activePart?: 'left' | 'right'): CandyDate[];
+declare function cloneDate(value: CompatibleValue): CompatibleValue;
+/**
+ * Wrapping kind APIs for date operating and unify
+ * NOTE: every new API return new CandyDate object without side effects to the former Date object
+ * NOTE: most APIs are based on local time other than customized locale id (this needs tobe support in future)
+ * TODO: support format() against to angular's core API
+ */
+declare class CandyDate implements IndexableObject {
+    nativeDate: Date;
+    constructor(date?: Date | string | number);
+    calendarStart(options?: {
+        weekStartsOn: WeekDayIndex | undefined;
+    }): CandyDate;
+    getYear(): number;
+    getMonth(): number;
+    getDay(): number;
+    getTime(): number;
+    getDate(): number;
+    getHours(): number;
+    getMinutes(): number;
+    getSeconds(): number;
+    getMilliseconds(): number;
+    clone(): CandyDate;
+    setHms(hour: number, minute: number, second: number): CandyDate;
+    setYear(year: number): CandyDate;
+    addYears(amount: number): CandyDate;
+    setMonth(month: number): CandyDate;
+    addMonths(amount: number): CandyDate;
+    setDay(day: number, options?: {
+        weekStartsOn: WeekDayIndex;
+    }): CandyDate;
+    setDate(amount: number): CandyDate;
+    getQuarter(): number;
+    setQuarter(quarter: number): CandyDate;
+    addDays(amount: number): CandyDate;
+    add(amount: number, mode: NormalizedMode): CandyDate;
+    isSame(date: CandyDateType, grain?: CandyDateMode): boolean;
+    isSameYear(date: CandyDateType): boolean;
+    isSameQuarter(date: CandyDateType): boolean;
+    isSameMonth(date: CandyDateType): boolean;
+    isSameDay(date: CandyDateType): boolean;
+    isSameHour(date: CandyDateType): boolean;
+    isSameMinute(date: CandyDateType): boolean;
+    isSameSecond(date: CandyDateType): boolean;
+    isBefore(date: CandyDateType, grain?: CandyDateMode): boolean;
+    isBeforeYear(date: CandyDateType): boolean;
+    isBeforeQuarter(date: CandyDateType): boolean;
+    isBeforeMonth(date: CandyDateType): boolean;
+    isBeforeDay(date: CandyDateType): boolean;
+    isToday(): boolean;
+    isValid(): boolean;
+    isFirstDayOfMonth(): boolean;
+    isLastDayOfMonth(): boolean;
+    private toNativeDate;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare const timeUnits: Array<[string, number]>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+interface TimeResult {
+    hour: number | null;
+    minute: number | null;
+    second: number | null;
+    period: number | null;
+}
+declare class NgTimeParser {
+    private format;
+    private localeId;
+    regex: RegExp;
+    matchMap: Record<string, null | number>;
+    constructor(format: string, localeId: string);
+    toDate(str: string): Date;
+    getTimeResult(str: string): TimeResult | null;
+    genRegexp(): void;
+}
+
+export { CandyDate, cloneDate, normalizeRangeValue, timeUnits, wrongSortOrder, NgTimeParser as ɵNgTimeParser };
+export type { CandyDateMode, CandyDateType, CompatibleValue, NormalizedMode, SingleValue, WeekDayIndex, TimeResult as ɵTimeResult };

node_modules/ng-zorro-antd/core/time/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-time.mjs"
+}

node_modules/ng-zorro-antd/core/trans-button/index.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from '@angular/core';
+
+declare class NzTransButtonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzTransButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzTransButtonDirective, "button[nz-trans-button]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NzTransButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzTransButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzTransButtonModule, never, [typeof NzTransButtonDirective], [typeof NzTransButtonDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzTransButtonModule>;
+}
+
+export { NzTransButtonDirective, NzTransButtonModule };

node_modules/ng-zorro-antd/core/trans-button/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-trans-button.mjs"
+}

node_modules/ng-zorro-antd/core/transition-patch/index.d.ts

@@ -0,0 +1,33 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnChanges } from '@angular/core';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * hack the bug
+ * angular router change with unexpected transition trigger after calling applicationRef.attachView
+ * https://github.com/angular/angular/issues/34718
+ */
+declare class NzTransitionPatchDirective implements AfterViewInit, OnChanges {
+    private elementRef;
+    private renderer;
+    hidden: NzSafeAny;
+    setHiddenAttribute(): void;
+    constructor();
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzTransitionPatchDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzTransitionPatchDirective, "[nz-button], [nz-icon], nz-icon, [nz-menu-item], [nz-submenu], nz-select-top-control, nz-select-placeholder, nz-input-group", never, { "hidden": { "alias": "hidden"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NzTransitionPatchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzTransitionPatchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzTransitionPatchModule, never, [typeof NzTransitionPatchDirective], [typeof NzTransitionPatchDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzTransitionPatchModule>;
+}
+
+export { NzTransitionPatchDirective as ɵNzTransitionPatchDirective, NzTransitionPatchModule as ɵNzTransitionPatchModule };

node_modules/ng-zorro-antd/core/transition-patch/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-transition-patch.mjs"
+}

node_modules/ng-zorro-antd/core/tree/index.d.ts

@@ -0,0 +1,339 @@
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+interface NzFormatEmitEvent {
+    eventName: string;
+    node?: NzTreeNode | null;
+    event?: MouseEvent | DragEvent | null;
+    dragNode?: NzTreeNode;
+    selectedKeys?: NzTreeNode[];
+    checkedKeys?: NzTreeNode[];
+    matchedKeys?: NzTreeNode[];
+    nodes?: NzTreeNode[];
+    keys?: string[];
+}
+interface NzFormatBeforeDropEvent {
+    dragNode: NzTreeNode;
+    node: NzTreeNode;
+    pos: number;
+}
+interface NzTreeNodeBaseComponent {
+    markForCheck(): void;
+}
+
+declare class NzTreeBaseService {
+    DRAG_SIDE_RANGE: number;
+    DRAG_MIN_GAP: number;
+    isCheckStrictly: boolean;
+    isMultiple: boolean;
+    selectedNode: NzTreeNode;
+    rootNodes: NzTreeNode[];
+    flattenNodes$: BehaviorSubject<NzTreeNode[]>;
+    selectedNodeList: NzTreeNode[];
+    expandedNodeList: NzTreeNode[];
+    checkedNodeList: NzTreeNode[];
+    halfCheckedNodeList: NzTreeNode[];
+    matchedNodeList: NzTreeNode[];
+    /**
+     * handle to post process a tree node when it's instantiating, note that its children haven't been initiated yet
+     */
+    treeNodePostProcessor?: (node: NzTreeNode) => void;
+    /**
+     * reset tree nodes will clear default node list
+     */
+    initTree(nzNodes: NzTreeNode[]): void;
+    flattenTreeData(nzNodes: NzTreeNode[], expandedKeys?: NzTreeNodeKey[] | true): void;
+    getSelectedNode(): NzTreeNode | null;
+    /**
+     * get some list
+     */
+    getSelectedNodeList(): NzTreeNode[];
+    /**
+     * get checked node keys
+     */
+    getCheckedNodeKeys(): NzTreeNodeKey[];
+    /**
+     * return checked nodes
+     */
+    getCheckedNodeList(): NzTreeNode[];
+    getHalfCheckedNodeList(): NzTreeNode[];
+    /**
+     * return expanded nodes
+     */
+    getExpandedNodeList(): NzTreeNode[];
+    /**
+     * return search matched nodes
+     */
+    getMatchedNodeList(): NzTreeNode[];
+    isArrayOfNzTreeNode(value: NzSafeAny[]): boolean;
+    /**
+     * set drag node
+     */
+    setSelectedNode(node: NzTreeNode): void;
+    /**
+     * set node selected status
+     */
+    setNodeActive(node: NzTreeNode): void;
+    /**
+     * add or remove node to selectedNodeList
+     */
+    setSelectedNodeList(node: NzTreeNode, isMultiple?: boolean): void;
+    /**
+     * merge checked nodes
+     */
+    setHalfCheckedNodeList(node: NzTreeNode): void;
+    setCheckedNodeList(node: NzTreeNode): void;
+    /**
+     * conduct checked/selected/expanded keys
+     */
+    conductNodeState(type?: string): NzTreeNode[];
+    /**
+     * set expanded nodes
+     */
+    setExpandedNodeList(node: NzTreeNode): void;
+    setMatchedNodeList(node: NzTreeNode): void;
+    /**
+     * check state
+     *
+     * @param isCheckStrictly
+     */
+    refreshCheckState(isCheckStrictly?: boolean): void;
+    conduct(node: NzTreeNode, isCheckStrictly?: boolean): void;
+    /**
+     * 1、children half checked
+     * 2、children all checked, parent checked
+     * 3、no children checked
+     */
+    conductUp(node: NzTreeNode): void;
+    /**
+     * reset child check state
+     */
+    conductDown(node: NzTreeNode, value: boolean): void;
+    /**
+     * flush after delete node
+     */
+    afterRemove(nodes: NzTreeNode[]): void;
+    /**
+     * drag event
+     */
+    refreshDragNode(node: NzTreeNode): void;
+    resetNodeLevel(node: NzTreeNode): void;
+    calcDropPosition(event: DragEvent): number;
+    /**
+     * drop
+     * 0: inner -1: pre 1: next
+     */
+    dropAndApply(targetNode: NzTreeNode, dragPos?: number): void;
+    /**
+     * emit Structure
+     * eventName
+     * node
+     * event: MouseEvent / DragEvent
+     * dragNode
+     */
+    formatEvent(eventName: string, node: NzTreeNode | null, event: MouseEvent | DragEvent | null): NzFormatEmitEvent;
+    /**
+     * New functions for flatten nodes
+     */
+    getIndexOfArray(list: NzTreeNode[], key: string): number;
+    /**
+     * Render by nzCheckedKeys
+     * When keys equals null, just render with checkStrictly
+     *
+     * @param keys
+     * @param checkStrictly
+     */
+    conductCheck(keys: NzTreeNodeKey[] | null, checkStrictly: boolean): void;
+    conductExpandedKeys(keys?: NzTreeNodeKey[] | true): void;
+    conductSelectedKeys(keys: NzTreeNodeKey[], isMulti: boolean): void;
+    /**
+     * Expand parent nodes by child node
+     *
+     * @param node
+     */
+    expandNodeAllParentBySearch(node: NzTreeNode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzTreeBaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzTreeBaseService>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+type NzTreeNodeKey = string | number;
+interface FlattenNode {
+    parent: FlattenNode | null;
+    children: FlattenNode[];
+    pos: string;
+    data: NzTreeNode;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+interface NzTreeNodeOptions {
+    title: string;
+    key: string;
+    icon?: string;
+    isLeaf?: boolean;
+    checked?: boolean;
+    selected?: boolean;
+    selectable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    expanded?: boolean;
+    children?: NzTreeNodeOptions[];
+    [key: string]: NzSafeAny;
+}
+declare class NzTreeNode {
+    private _title;
+    key: string;
+    level: number;
+    origin: NzTreeNodeOptions;
+    parentNode: NzTreeNode | null;
+    private _icon;
+    private _children;
+    private _isLeaf;
+    private _isChecked;
+    private _isSelectable;
+    private _isDisabled;
+    private _isDisableCheckbox;
+    private _isExpanded;
+    private _isHalfChecked;
+    private _isSelected;
+    private _isLoading;
+    canHide: boolean;
+    isMatched: boolean;
+    service: NzTreeBaseService | null;
+    component: NzTreeNodeBaseComponent;
+    /** New added in Tree for easy data access */
+    isStart?: boolean[];
+    isEnd?: boolean[];
+    get treeService(): NzTreeBaseService | null;
+    /**
+     * Init nzTreeNode
+     *
+     * @param option option user's input
+     * @param parent parent node
+     * @param service base nzTreeService
+     */
+    constructor(option: NzTreeNodeOptions | NzTreeNode, parent?: NzTreeNode | null, service?: NzTreeBaseService | null);
+    /**
+     * auto generate
+     * get
+     * set
+     */
+    get title(): string;
+    set title(value: string);
+    get icon(): string;
+    set icon(value: string);
+    get children(): NzTreeNode[];
+    set children(value: NzTreeNode[]);
+    get isLeaf(): boolean;
+    set isLeaf(value: boolean);
+    get isChecked(): boolean;
+    set isChecked(value: boolean);
+    get isHalfChecked(): boolean;
+    set isHalfChecked(value: boolean);
+    get isSelectable(): boolean;
+    set isSelectable(value: boolean);
+    get isDisabled(): boolean;
+    set isDisabled(value: boolean);
+    get isDisableCheckbox(): boolean;
+    set isDisableCheckbox(value: boolean);
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    get isSelected(): boolean;
+    set isSelected(value: boolean);
+    get isLoading(): boolean;
+    set isLoading(value: boolean);
+    setSyncChecked(checked?: boolean, halfChecked?: boolean): void;
+    setChecked(checked?: boolean, halfChecked?: boolean): void;
+    setExpanded(value: boolean): void;
+    getParentNode(): NzTreeNode | null;
+    getChildren(): NzTreeNode[];
+    /**
+     * Support appending child nodes by position. Leaf node cannot be appended.
+     */
+    addChildren(children: NzSafeAny[], childPos?: number): void;
+    clearChildren(): void;
+    remove(): void;
+    afterValueChange(key: string): void;
+    update(): void;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const NzTreeHigherOrderServiceToken: InjectionToken<NzTreeBaseService>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzTreeBase {
+    nzTreeService: NzTreeBaseService;
+    constructor(nzTreeService: NzTreeBaseService);
+    /**
+     * Coerces a value({@link any[]}) to a TreeNodes({@link NzTreeNode[]})
+     */
+    coerceTreeNodes(value: NzSafeAny[]): NzTreeNode[];
+    /**
+     * Get all nodes({@link NzTreeNode})
+     */
+    getTreeNodes(): NzTreeNode[];
+    /**
+     * Get {@link NzTreeNode} with key
+     */
+    getTreeNodeByKey(key: string): NzTreeNode | null;
+    /**
+     * Get checked nodes(merged)
+     */
+    getCheckedNodeList(): NzTreeNode[];
+    /**
+     * Get selected nodes
+     */
+    getSelectedNodeList(): NzTreeNode[];
+    /**
+     * Get half checked nodes
+     */
+    getHalfCheckedNodeList(): NzTreeNode[];
+    /**
+     * Get expanded nodes
+     */
+    getExpandedNodeList(): NzTreeNode[];
+    /**
+     * Get matched nodes(if nzSearchValue is not null)
+     */
+    getMatchedNodeList(): NzTreeNode[];
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function isCheckDisabled(node: NzTreeNode): boolean;
+declare function isInArray(needle: NzSafeAny, haystack: NzSafeAny[]): boolean;
+declare function getPosition(level: string | number, index: number): string;
+declare function getKey(key: NzTreeNodeKey, pos: string): NzTreeNodeKey;
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ *
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
+ */
+declare function flattenTreeData(treeNodeList?: NzTreeNode[], expandedKeys?: NzTreeNodeKey[] | true): FlattenNode[];
+
+export { NzTreeBase, NzTreeBaseService, NzTreeHigherOrderServiceToken, NzTreeNode, flattenTreeData, getKey, getPosition, isCheckDisabled, isInArray };
+export type { FlattenNode, NzFormatBeforeDropEvent, NzFormatEmitEvent, NzTreeNodeBaseComponent, NzTreeNodeKey, NzTreeNodeOptions };

node_modules/ng-zorro-antd/core/tree/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-tree.mjs"
+}

node_modules/ng-zorro-antd/core/types/index.d.ts

@@ -0,0 +1,122 @@
+import { TemplateRef, SimpleChange } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+type NzSafeAny = any;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+type FunctionProp<T> = (...args: NzSafeAny[]) => T;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+type NzDirectionVHType = 'vertical' | 'horizontal';
+type NzFourDirectionType = 'top' | 'bottom' | 'left' | 'right';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+interface IndexableObject {
+    [key: string]: NzSafeAny;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+type NgClassType = string | string[] | NgClassInterface;
+interface NgClassInterface {
+    [klass: string]: NzSafeAny;
+}
+interface NgStyleInterface {
+    [klass: string]: NzSafeAny;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+type NzSizeLDSType = 'large' | 'default' | 'small';
+type NzSizeLMSType = 'large' | 'middle' | 'small';
+type NzSizeMDSType = 'middle' | 'default' | 'small';
+type NzSizeDSType = 'default' | 'small';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * A joined type of string and `TemplateRef<void>`.
+ */
+type NzTSType = string | TemplateRef<void>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+type NzShapeSCType = 'square' | 'circle';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+type CompareWith = (o1: NzSafeAny, o2: NzSafeAny) => boolean;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+type OnTouchedType = () => NzSafeAny;
+type OnChangeType = (value: NzSafeAny) => void;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+type BooleanInput = boolean | string | undefined | null;
+type NumberInput = number | string | undefined | null;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+interface InputObservable {
+    getInputObservable<K extends keyof this>(changeType: K): Observable<SimpleChange>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare const tuple: <T extends string[]>(...args: T) => T;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+type NzStatus = '' | 'error' | 'warning';
+type NzValidateStatus = '' | 'success' | 'warning' | 'error' | 'validating';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+type NzVariant = 'outlined' | 'filled' | 'borderless' | 'underlined';
+
+export { tuple };
+export type { BooleanInput, CompareWith, FunctionProp, IndexableObject, InputObservable, NgClassInterface, NgClassType, NgStyleInterface, NumberInput, NzDirectionVHType, NzFourDirectionType, NzSafeAny, NzShapeSCType, NzSizeDSType, NzSizeLDSType, NzSizeLMSType, NzSizeMDSType, NzStatus, NzTSType, NzValidateStatus, NzVariant, OnChangeType, OnTouchedType };

node_modules/ng-zorro-antd/core/types/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-types.mjs"
+}

node_modules/ng-zorro-antd/core/util/index.d.ts

@@ -0,0 +1,278 @@
+import { TemplateRef } from '@angular/core';
+import { IndexableObject, NzSafeAny, FunctionProp, NgStyleInterface, NzValidateStatus, NgClassInterface, NzVariant } from 'ng-zorro-antd/core/types';
+import { Observable } from 'rxjs';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare function toArray<T>(value: T | T[]): T[];
+declare function arraysEqual<T>(array1: T[], array2: T[]): boolean;
+declare function shallowCopyArray<T>(source: T[]): T[];
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function isNotNil<T>(value: T): value is NonNullable<T>;
+declare function isNil(value: unknown): value is null | undefined;
+/**
+ * Examine if two objects are shallowly equaled.
+ */
+declare function shallowEqual(objA?: IndexableObject, objB?: IndexableObject): boolean;
+declare function isNonEmptyString(value: NzSafeAny): boolean;
+declare function isTemplateRef<T>(value: TemplateRef<T> | NzSafeAny): value is TemplateRef<T>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function toBoolean(value: unknown): boolean;
+declare function numberAttributeWithZeroFallback(value: unknown): number;
+declare function numberAttributeWithOneFallback(value: unknown): number;
+declare function numberAttributeWithInfinityFallback(value: unknown): number;
+declare function toNumber(value: number | string): number;
+declare function toNumber<D>(value: number | string, fallback: D): number | D;
+declare function toCssPixel(value: number | string): string;
+/**
+ * Get the function-property type's value
+ */
+declare function valueFunctionProp<T>(prop: FunctionProp<T> | T, ...args: NzSafeAny[]): T;
+/**
+ * @deprecated Use input transform instead: `@Input({ transform })`
+ *
+ * Input decorator that handle a prop to do get/set automatically with toBoolean
+ *
+ * Why not using @InputBoolean alone without @Input? AOT needs @Input to be visible
+ *
+ * @howToUse
+ * ```
+ * @Input() @InputBoolean() visible: boolean = false;
+ *
+ * // Act as below:
+ * // @Input()
+ * // get visible() { return this.__visible; }
+ * // set visible(value) { this.__visible = value; }
+ * // __visible = false;
+ * ```
+ */
+declare function InputBoolean(): NzSafeAny;
+/**
+ * @deprecated Use input transform instead: `@Input({ transform })`
+ */
+declare function InputCssPixel(): NzSafeAny;
+/**
+ * @deprecated Use input transform instead: `@Input({ transform })`
+ */
+declare function InputNumber(fallbackValue?: NzSafeAny): NzSafeAny;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+/**
+ * This module provides utility functions to query DOM information or
+ * set properties.
+ */
+
+/**
+ * Silent an event by stopping and preventing it.
+ */
+declare function silentEvent(e: Event): void;
+declare function getElementOffset(elem: HTMLElement): {
+    top: number;
+    left: number;
+};
+/**
+ * Investigate if an event is a `TouchEvent`.
+ */
+declare function isTouchEvent(event: MouseEvent | TouchEvent): event is TouchEvent;
+declare function getEventPosition(event: MouseEvent | TouchEvent): MouseEvent | Touch;
+interface MouseTouchObserverConfig {
+    end: string;
+    move: string;
+    pluckKey: string[];
+    start: string;
+    end$?: Observable<Event>;
+    moveResolved$?: Observable<number>;
+    startPlucked$?: Observable<number>;
+    filter?(e: Event): boolean;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare function getRegExp(prefix: string | string[]): RegExp;
+declare function getMentions(value: string, prefix?: string | string[]): string[];
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+/**
+ * Much like lodash.
+ */
+declare function padStart(toPad: string, length: number, element: string): string;
+declare function padEnd(toPad: string, length: number, element: string): string;
+declare function getRepeatedElement(length: number, element: string): string;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function isPromise<T>(obj: NzSafeAny): obj is Promise<T>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function getPercent(min: number, max: number, value: number): number;
+declare function getPrecision(num: number): number;
+declare function ensureNumberInRange(num: number, min: number, max: number): number;
+declare function isNumberFinite(value: NzSafeAny): boolean;
+declare function toDecimal(value: number, decimal: number): number;
+declare function sum(input: number[], initial?: number): number;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare function scrollIntoView(node: HTMLElement): void;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare const properties: string[];
+interface Coordinates {
+    top: number;
+    left: number;
+    height: number;
+}
+declare function getCaretCoordinates(element: HTMLInputElement | HTMLTextAreaElement, position: number, options?: {
+    debug?: boolean;
+}): Coordinates;
+declare function createDebugEle(element: HTMLInputElement | HTMLTextAreaElement, coordinates: Coordinates): void;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function isStyleSupport(styleName: string | string[]): boolean;
+declare function getStyleAsText(styles?: NgStyleInterface): string;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+interface MeasureResult {
+    finished: boolean;
+    node: Node | null;
+}
+declare function pxToNumber(value: string | null): number;
+declare function measure(originEle: HTMLElement, rows: number, contentNodes: Node[], fixedContent: HTMLElement[], ellipsisStr: string, suffixStr?: string): {
+    contentNodes: Node[];
+    text: string;
+    ellipsis: boolean;
+};
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare function measureScrollbar(direction?: 'vertical' | 'horizontal', prefix?: string): number;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare function ensureInBounds(value: number, boundValue: number): number;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function inNextTick(): Observable<void>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function wrapIntoObservable<T>(value: T | Promise<T> | Observable<T>): Observable<T>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+/**
+ * Sync from rc-util [https://github.com/react-component/util]
+ */
+declare function canUseDom(): boolean;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+interface Options {
+    attachTo?: Element;
+    cspNonce?: string | null;
+    prepend?: boolean;
+    mark?: string;
+}
+declare function injectCSS(css: string, options?: Options): HTMLStyleElement | null;
+declare function removeCSS(key: string, option?: Options): void;
+declare function updateCSS(css: string, key: string, options?: Options): HTMLStyleElement | null;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function getStatusClassNames(prefixCls: string, status?: NzValidateStatus, hasFeedback?: boolean): NgClassInterface;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * This function replaces `runOutsideAngular` with `fromEvent`, introducing a
+ * lot of boilerplate where we need to inject the `NgZone` service and then subscribe
+ * to `fromEvent` within the `runOutsideAngular` callback.
+ */
+declare function fromEventOutsideAngular<TEvent extends Event>(target: EventTarget | null | undefined, name: string, options?: boolean | AddEventListenerOptions): Observable<TEvent>;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare function getVariantClassNames(prefixCls: string, variant?: NzVariant, borderless?: boolean): NgClassInterface;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+/**
+ * Escapes all potentially dangerous characters, so that the
+ * resulting string can be safely inserted into attribute or
+ * element text.
+ */
+declare function encodeEntities(value: string): string;
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+declare function generateClassName(prefix: string, suffix: string): string;
+
+export { InputBoolean, InputCssPixel, InputNumber, arraysEqual, canUseDom, createDebugEle, encodeEntities, ensureInBounds, ensureNumberInRange, fromEventOutsideAngular, generateClassName, getCaretCoordinates, getElementOffset, getEventPosition, getMentions, getPercent, getPrecision, getRegExp, getRepeatedElement, getStatusClassNames, getStyleAsText, getVariantClassNames, inNextTick, injectCSS, isNil, isNonEmptyString, isNotNil, isNumberFinite, isPromise, isStyleSupport, isTemplateRef, isTouchEvent, measure, measureScrollbar, numberAttributeWithInfinityFallback, numberAttributeWithOneFallback, numberAttributeWithZeroFallback, padEnd, padStart, properties, pxToNumber, removeCSS, scrollIntoView, shallowCopyArray, shallowEqual, silentEvent, sum, toArray, toBoolean, toCssPixel, toDecimal, toNumber, updateCSS, valueFunctionProp, wrapIntoObservable };
+export type { Coordinates, MeasureResult, MouseTouchObserverConfig };

node_modules/ng-zorro-antd/core/util/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-util.mjs"
+}

node_modules/ng-zorro-antd/core/wave/index.d.ts

@@ -0,0 +1,71 @@
+import { Platform } from '@angular/cdk/platform';
+import * as i0 from '@angular/core';
+import { NgZone, InjectionToken, EnvironmentProviders, OnInit, OnDestroy } from '@angular/core';
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzWaveRenderer {
+    private triggerElement;
+    private ngZone;
+    private insertExtraNode;
+    private platform;
+    private cspNonce?;
+    private waveTransitionDuration;
+    private styleForPseudo;
+    private extraNode;
+    private lastTime;
+    clickHandler: (event: MouseEvent) => void;
+    get waveAttributeName(): string;
+    constructor(triggerElement: HTMLElement, ngZone: NgZone, insertExtraNode: boolean, platform: Platform, cspNonce?: string | null | undefined);
+    onClick: (event: MouseEvent) => void;
+    bindTriggerEvent(): void;
+    removeTriggerEvent(): void;
+    removeStyleAndExtraNode(): void;
+    destroy(): void;
+    private fadeOutWave;
+    private isValidColor;
+    private isNotGrey;
+    private getWaveColor;
+    private runTimeoutOutsideZone;
+}
+
+interface NzWaveConfig {
+    disabled?: boolean;
+}
+declare const NZ_WAVE_GLOBAL_DEFAULT_CONFIG: NzWaveConfig;
+declare const NZ_WAVE_GLOBAL_CONFIG: InjectionToken<NzWaveConfig>;
+declare function provideNzWave(config: NzWaveConfig): EnvironmentProviders;
+declare class NzWaveDirective implements OnInit, OnDestroy {
+    nzWaveExtraNode: boolean;
+    private waveRenderer?;
+    private waveDisabled;
+    get disabled(): boolean;
+    get rendererRef(): NzWaveRenderer | undefined;
+    private cspNonce;
+    private platform;
+    private config;
+    private animationType;
+    private ngZone;
+    private elementRef;
+    constructor();
+    isConfigDisabled(): boolean;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    renderWaveIfEnabled(): void;
+    disable(): void;
+    enable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzWaveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzWaveDirective, "[nz-wave],button[nz-button]:not([nzType=\"link\"]):not([nzType=\"text\"])", ["nzWave"], { "nzWaveExtraNode": { "alias": "nzWaveExtraNode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NzWaveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzWaveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzWaveModule, never, [typeof NzWaveDirective], [typeof NzWaveDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzWaveModule>;
+}
+
+export { NZ_WAVE_GLOBAL_CONFIG, NZ_WAVE_GLOBAL_DEFAULT_CONFIG, NzWaveDirective, NzWaveModule, NzWaveRenderer, provideNzWave };
+export type { NzWaveConfig };

node_modules/ng-zorro-antd/core/wave/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../../fesm2022/ng-zorro-antd-core-wave.mjs"
+}