cty-mui-angular 1.0.0

package/fesm2022/cty-mui-angular-standalone.mjs

@@ -0,0 +1,1834 @@
+import * as i1 from 'cty-mui-angular/common';
+import { ValueAccessor, ConfigToken, OverlayBaseController } from 'cty-mui-angular/common';
+export { AudioRecorderService, Config, DeviceInfoService, ImagePickerService, KeyboardService, MediaDownloaderService, NetworkService, PaymentService, ScreenOrientationService, ShareService, StatusBarService, UtilsService, VideoCaptureService, VolumeControlService, WechatService } from 'cty-mui-angular/common';
+import { __decorate } from 'tslib';
+import * as i0 from '@angular/core';
+import { forwardRef, Component, ChangeDetectionStrategy, HostListener, CUSTOM_ELEMENTS_SCHEMA, makeEnvironmentProviders, APP_INITIALIZER, Injectable } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { defineCustomElement as defineCustomElement$1 } from 'cty-mui-core/components/cty-agree.js';
+import { fromEvent } from 'rxjs';
+import { defineCustomElement as defineCustomElement$2 } from 'cty-mui-core/components/cty-rate.js';
+import { register } from 'swiper/element/bundle';
+import { defineCustomElement as defineCustomElement$3 } from 'cty-mui-core/components/cty-segment-slides.js';
+import { defineCustomElement as defineCustomElement$4 } from 'cty-mui-core/components/cty-stepper.js';
+import { defineCustomElement as defineCustomElement$5 } from 'cty-mui-core/components/cty-swiper.js';
+import { defineCustomElement as defineCustomElement$6 } from 'cty-mui-core/components/cty-action-sheet.js';
+import { defineCustomElement as defineCustomElement$7 } from 'cty-mui-core/components/cty-alert.js';
+import { defineCustomElement as defineCustomElement$8 } from 'cty-mui-core/components/cty-answer-sheet.js';
+import { defineCustomElement as defineCustomElement$9 } from 'cty-mui-core/components/cty-article-card.js';
+import { defineCustomElement as defineCustomElement$a } from 'cty-mui-core/components/cty-audio.js';
+import { defineCustomElement as defineCustomElement$b } from 'cty-mui-core/components/cty-banner.js';
+import { defineCustomElement as defineCustomElement$c } from 'cty-mui-core/components/cty-camera-photo.js';
+import { defineCustomElement as defineCustomElement$d } from 'cty-mui-core/components/cty-canvas-board.js';
+import { defineCustomElement as defineCustomElement$e } from 'cty-mui-core/components/cty-canvas-video.js';
+import { defineCustomElement as defineCustomElement$f } from 'cty-mui-core/components/cty-cascader.js';
+import { defineCustomElement as defineCustomElement$g } from 'cty-mui-core/components/cty-circle.js';
+import { defineCustomElement as defineCustomElement$h } from 'cty-mui-core/components/cty-count-down.js';
+import { defineCustomElement as defineCustomElement$i } from 'cty-mui-core/components/cty-crop-image.js';
+import { defineCustomElement as defineCustomElement$j } from 'cty-mui-core/components/cty-divider.js';
+import { defineCustomElement as defineCustomElement$k } from 'cty-mui-core/components/cty-empty.js';
+import { defineCustomElement as defineCustomElement$l } from 'cty-mui-core/components/cty-floating-bubble.js';
+import { defineCustomElement as defineCustomElement$m } from 'cty-mui-core/components/cty-floating-panel.js';
+import { defineCustomElement as defineCustomElement$n } from 'cty-mui-core/components/cty-icon.js';
+import { defineCustomElement as defineCustomElement$o } from 'cty-mui-core/components/cty-image-upload.js';
+import { defineCustomElement as defineCustomElement$p } from 'cty-mui-core/components/cty-image-viewer.js';
+import { defineCustomElement as defineCustomElement$q } from 'cty-mui-core/components/cty-index-bar.js';
+import { defineCustomElement as defineCustomElement$r } from 'cty-mui-core/components/cty-keyboard.js';
+import { defineCustomElement as defineCustomElement$s } from 'cty-mui-core/components/cty-loading.js';
+import { defineCustomElement as defineCustomElement$t } from 'cty-mui-core/components/cty-media-capture.js';
+import { defineCustomElement as defineCustomElement$u } from 'cty-mui-core/components/cty-nav-bar.js';
+import { defineCustomElement as defineCustomElement$v } from 'cty-mui-core/components/cty-notice-bar.js';
+import { defineCustomElement as defineCustomElement$w } from 'cty-mui-core/components/cty-overlay.js';
+import { defineCustomElement as defineCustomElement$x } from 'cty-mui-core/components/cty-pdf-viewer.js';
+import { defineCustomElement as defineCustomElement$y } from 'cty-mui-core/components/cty-permission-purpose.js';
+import { defineCustomElement as defineCustomElement$z } from 'cty-mui-core/components/cty-progress.js';
+import { defineCustomElement as defineCustomElement$A } from 'cty-mui-core/components/cty-quick-access.js';
+import { defineCustomElement as defineCustomElement$B } from 'cty-mui-core/components/cty-record.js';
+import { defineCustomElement as defineCustomElement$C } from 'cty-mui-core/components/cty-share-sheet.js';
+import { defineCustomElement as defineCustomElement$D } from 'cty-mui-core/components/cty-step.js';
+import { defineCustomElement as defineCustomElement$E } from 'cty-mui-core/components/cty-steps.js';
+import { defineCustomElement as defineCustomElement$F } from 'cty-mui-core/components/cty-swipe.js';
+import { defineCustomElement as defineCustomElement$G } from 'cty-mui-core/components/cty-swipe-item.js';
+import { defineCustomElement as defineCustomElement$H } from 'cty-mui-core/components/cty-text-ellipsis.js';
+import { defineCustomElement as defineCustomElement$I } from 'cty-mui-core/components/cty-tour.js';
+import { defineCustomElement as defineCustomElement$J } from 'cty-mui-core/components/cty-tutorial.js';
+import { defineCustomElement as defineCustomElement$K } from 'cty-mui-core/components/cty-video.js';
+import { defineCustomElement as defineCustomElement$L } from 'cty-mui-core/components/cty-virtual-list.js';
+import { initialize, alertController, actionSheetController, cameraPhotoController, cascaderController, loadingController, imageViewerController, overlayController, recordController, shareSheetController, tutorialController } from 'cty-mui-core/components';
+export { CTYCityData, DownloadMediaType, Easing, ImagePickerType, MediaSourceType, ModalFade, ModalRotate, ModalSlide, ModalZoom, ShareContentType, SharePlatformType, SlidePosition, UploadProgressTip, WechatMiniProgramType, WechatShareScene, addDays, addHours, addMinutes, addMonths, addSeconds, addYears, camelToKebab, checkScrollEnd, clamp, clipboard, closest, convertDate, convertNumber, convertTimeZone, deepClone, diff, fileSize, formatDate, formatDateTime, fromBase64, getElementRect, getEventClientCoords, getEventPageCoords, getFormatForDatePicker, getFormatForDateTimePicker, getTimeZone, getUTCDate, getUTCDateTime, getValueByKey, identityCodeValid, isDef, isEmail, isEmptyArray, isEmptyObject, isHttp, isJSONObject, isMobileNo, isPrimitive, isPromise, isRealNameForm, isValidDate, kebabToCamel, localDelete, localGet, localSave, mergeObj, numberToChinese, numberToLetter, numericName, pad, parseArray, parseJson, percent, price, randomNum, scrollElementBottom, scrollElementTop, scrollToPoint, secondsToVehicle, sessionDelete, sessionGet, sessionSave, toBase64 } from 'cty-mui-core/components';
+import { defineCustomElement as defineCustomElement$M } from 'cty-mui-core/components/cty-action-sheet';
+import { defineCustomElement as defineCustomElement$N } from 'cty-mui-core/components/cty-camera-photo';
+import { defineCustomElement as defineCustomElement$O } from 'cty-mui-core/components/cty-cascader';
+import { defineCustomElement as defineCustomElement$P } from 'cty-mui-core/components/cty-loading';
+import { defineCustomElement as defineCustomElement$Q } from 'cty-mui-core/components/cty-record';
+import { defineCustomElement as defineCustomElement$R } from 'cty-mui-core/components/cty-share-sheet';
+import { defineCustomElement as defineCustomElement$S } from 'cty-mui-core/components/cty-tutorial';
+import { actionSheetController as actionSheetController$1, alertController as alertController$1, loadingController as loadingController$1, modalController, pickerController, popoverController, toastController } from '@ionic/core/components';
+
+/* eslint-disable */
+/* tslint:disable */
+const proxyInputs = (Cmp, inputs) => {
+    const Prototype = Cmp.prototype;
+    inputs.forEach((item) => {
+        Object.defineProperty(Prototype, item, {
+            get() {
+                return this.el[item];
+            },
+            set(val) {
+                this.z.runOutsideAngular(() => (this.el[item] = val));
+            },
+            /**
+             * In the event that proxyInputs is called
+             * multiple times re-defining these inputs
+             * will cause an error to be thrown. As a result
+             * we set configurable: true to indicate these
+             * properties can be changed.
+             */
+            configurable: true,
+        });
+    });
+};
+const proxyMethods = (Cmp, methods) => {
+    const Prototype = Cmp.prototype;
+    methods.forEach((methodName) => {
+        Prototype[methodName] = function () {
+            const args = arguments;
+            return this.z.runOutsideAngular(() => this.el[methodName].apply(this.el, args));
+        };
+    });
+};
+const proxyOutputs = (instance, el, events) => {
+    events.forEach((eventName) => (instance[eventName] = fromEvent(el, eventName)));
+};
+const defineCustomElement = (tagName, customElement) => {
+    if (customElement !== undefined && typeof customElements !== 'undefined' && !customElements.get(tagName)) {
+        customElements.define(tagName, customElement);
+    }
+};
+// tslint:disable-next-line: only-arrow-functions
+function ProxyCmp(opts) {
+    const decorator = function (cls) {
+        const { defineCustomElementFn, inputs, methods } = opts;
+        if (defineCustomElementFn !== undefined) {
+            defineCustomElementFn();
+        }
+        if (inputs) {
+            proxyInputs(cls, inputs);
+        }
+        if (methods) {
+            proxyMethods(cls, methods);
+        }
+        return cls;
+    };
+    return decorator;
+}
+
+const INPUTS$4 = ['disabled', 'spinner', 'triggerArea', 'value'];
+/**
+ * Pulling the provider into an object and using PURE works
+ * around an ng-packagr issue that causes
+ * components with multiple decorators and
+ * a provider to be re-assigned. This re-assignment
+ * is not supported by Webpack and causes treeshaking
+ * to not work on these kinds of components.
+ */
+const accessorProvider$2 = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: /*@__PURE__*/ forwardRef(() => CtyAgree),
+    multi: true,
+};
+let CtyAgree = class CtyAgree extends ValueAccessor {
+    z;
+    el;
+    constructor(c, r, z, injector) {
+        super(injector, r);
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyChange']);
+    }
+    handleIonChange(el) {
+        this.handleValueChange(el, el.value);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAgree, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyAgree, isStandalone: true, selector: "cty-agree", inputs: { disabled: "disabled", spinner: "spinner", triggerArea: "triggerArea", value: "value" }, host: { listeners: { "ctyChange": "handleIonChange($event.target)" } }, providers: [accessorProvider$2], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyAgree = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$1,
+        inputs: INPUTS$4,
+    })
+], CtyAgree);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAgree, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-agree',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: INPUTS$4,
+                    providers: [accessorProvider$2],
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { handleIonChange: [{
+                type: HostListener,
+                args: ['ctyChange', ['$event.target']]
+            }] } });
+
+const INPUTS$3 = ['clearable', 'count', 'disabled', 'half', 'icon', 'readonly', 'touchable', 'value', 'voidIcon'];
+/**
+ * Pulling the provider into an object and using PURE works
+ * around an ng-packagr issue that causes
+ * components with multiple decorators and
+ * a provider to be re-assigned. This re-assignment
+ * is not supported by Webpack and causes treeshaking
+ * to not work on these kinds of components.
+ */
+const accessorProvider$1 = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: /*@__PURE__*/ forwardRef(() => CtyRate),
+    multi: true,
+};
+let CtyRate = class CtyRate extends ValueAccessor {
+    z;
+    el;
+    constructor(c, r, z, injector) {
+        super(injector, r);
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyChange']);
+    }
+    handleIonChange(el) {
+        this.handleValueChange(el, el.value);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyRate, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyRate, isStandalone: true, selector: "cty-rate", inputs: { clearable: "clearable", count: "count", disabled: "disabled", half: "half", icon: "icon", readonly: "readonly", touchable: "touchable", value: "value", voidIcon: "voidIcon" }, host: { listeners: { "ctyChange": "handleIonChange($event.target)" } }, providers: [accessorProvider$1], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyRate = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$2,
+        inputs: INPUTS$3,
+    })
+], CtyRate);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyRate, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-rate',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: INPUTS$3,
+                    providers: [accessorProvider$1],
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { handleIonChange: [{
+                type: HostListener,
+                args: ['ctyChange', ['$event.target']]
+            }] } });
+
+register();
+const INPUTS$2 = ['segments', 'autoHeight', 'top', 'segmentProps', 'layout', 'observer', 'observerParents'];
+let CtySegmentSlides = class CtySegmentSlides {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctySlideChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySegmentSlides, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtySegmentSlides, isStandalone: true, selector: "cty-segment-slides", inputs: { segments: "segments", autoHeight: "autoHeight", top: "top", segmentProps: "segmentProps", layout: "layout", observer: "observer", observerParents: "observerParents" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtySegmentSlides = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$3,
+        inputs: INPUTS$2,
+        methods: ['doSlideTo', 'getActiveIndex']
+    })
+], CtySegmentSlides);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySegmentSlides, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-segment-slides',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: INPUTS$2,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+
+const INPUTS$1 = ['disabled', 'disableInput', 'disableMinus', 'disablePlus', 'integer', 'max', 'min', 'minusText', 'plusText', 'readonly', 'showInput', 'showMinus', 'showPlus', 'step', 'value'];
+/**
+ * Pulling the provider into an object and using PURE works
+ * around an ng-packagr issue that causes
+ * components with multiple decorators and
+ * a provider to be re-assigned. This re-assignment
+ * is not supported by Webpack and causes treeshaking
+ * to not work on these kinds of components.
+ */
+const accessorProvider = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: /*@__PURE__*/ forwardRef(() => CtyStepper),
+    multi: true,
+};
+let CtyStepper = class CtyStepper extends ValueAccessor {
+    z;
+    el;
+    constructor(c, r, z, injector) {
+        super(injector, r);
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyBlur', 'ctyChange', 'ctyFocus', 'ctyMinus', 'ctyPlus']);
+    }
+    handleIonChange(el) {
+        this.handleValueChange(el, el.value);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyStepper, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyStepper, isStandalone: true, selector: "cty-stepper", inputs: { disabled: "disabled", disableInput: "disableInput", disableMinus: "disableMinus", disablePlus: "disablePlus", integer: "integer", max: "max", min: "min", minusText: "minusText", plusText: "plusText", readonly: "readonly", showInput: "showInput", showMinus: "showMinus", showPlus: "showPlus", step: "step", value: "value" }, host: { listeners: { "ctyChange": "handleIonChange($event.target)" } }, providers: [accessorProvider], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyStepper = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$4,
+        inputs: INPUTS$1,
+        methods: ['handleMinus', 'handlePlus'],
+    })
+], CtyStepper);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyStepper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-stepper',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: INPUTS$1,
+                    providers: [accessorProvider],
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { handleIonChange: [{
+                type: HostListener,
+                args: ['ctyChange', ['$event.target']]
+            }] } });
+
+register();
+const INPUTS = ['swipers', 'props', 'autoplay', 'loop', 'direction', 'pagination', 'observer', 'observerParents', 'swiperModules', 'attrs'];
+let CtySwiper = class CtySwiper {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctySlideChange', 'ctySlideClick']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySwiper, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtySwiper, isStandalone: true, selector: "cty-swiper", inputs: { swipers: "swipers", props: "props", autoplay: "autoplay", loop: "loop", direction: "direction", pagination: "pagination", observer: "observer", observerParents: "observerParents", swiperModules: "swiperModules", attrs: "attrs" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtySwiper = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$5,
+        inputs: INPUTS,
+        methods: ['prev', 'next', 'slideTo', 'getSwiper', 'refreshSwiper']
+    })
+], CtySwiper);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySwiper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-swiper',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: INPUTS,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+
+let CtyActionSheet = class CtyActionSheet {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyTap', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyActionSheet, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyActionSheet, isStandalone: true, selector: "cty-action-sheet", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", cancelText: "cancelText", closeIcon: "closeIcon", closeable: "closeable", cssClass: "cssClass", enterAnimation: "enterAnimation", leaveAnimation: "leaveAnimation", options: "options", root: "root", subtitle: "subtitle", title: "title", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyActionSheet = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$6,
+        inputs: ['animated', 'backdropDismiss', 'cancelText', 'closeIcon', 'closeable', 'cssClass', 'enterAnimation', 'leaveAnimation', 'options', 'root', 'subtitle', 'title', 'trigger'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyActionSheet);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyActionSheet, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-action-sheet',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'cancelText', 'closeIcon', 'closeable', 'cssClass', 'enterAnimation', 'leaveAnimation', 'options', 'root', 'subtitle', 'title', 'trigger'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyAlert = class CtyAlert {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyTap', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAlert, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyAlert, isStandalone: true, selector: "cty-alert", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", buttons: "buttons", closeable: "closeable", content: "content", cssClass: "cssClass", enterAnimation: "enterAnimation", img: "img", leaveAnimation: "leaveAnimation", root: "root", title: "title", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyAlert = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$7,
+        inputs: ['animated', 'backdropDismiss', 'buttons', 'closeable', 'content', 'cssClass', 'enterAnimation', 'img', 'leaveAnimation', 'root', 'title', 'trigger'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyAlert);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAlert, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-alert',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'buttons', 'closeable', 'content', 'cssClass', 'enterAnimation', 'img', 'leaveAnimation', 'root', 'title', 'trigger'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyAnswerSheet = class CtyAnswerSheet {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyTap']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAnswerSheet, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyAnswerSheet, isStandalone: true, selector: "cty-answer-sheet", inputs: { answers: "answers", categories: "categories", displayTotal: "displayTotal", distinguish: "distinguish", placement: "placement", props: "props", results: "results", totalText: "totalText" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyAnswerSheet = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$8,
+        inputs: ['answers', 'categories', 'displayTotal', 'distinguish', 'placement', 'props', 'results', 'totalText']
+    })
+], CtyAnswerSheet);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAnswerSheet, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-answer-sheet',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['answers', 'categories', 'displayTotal', 'distinguish', 'placement', 'props', 'results', 'totalText'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyArticleCard = class CtyArticleCard {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyArticleCard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyArticleCard, isStandalone: true, selector: "cty-article-card", inputs: { layout: "layout", thumbnails: "thumbnails", title: "title" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyArticleCard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$9,
+        inputs: ['layout', 'thumbnails', 'title']
+    })
+], CtyArticleCard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyArticleCard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-article-card',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['layout', 'thumbnails', 'title'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyAudio = class CtyAudio {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyEnd', 'ctyTimeupdate', 'ctyProgress', 'ctyCanplay', 'ctyPlay', 'ctyPause', 'ctyError']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAudio, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyAudio, isStandalone: true, selector: "cty-audio", inputs: { allowBackward: "allowBackward", allowForward: "allowForward", autoplay: "autoplay", cycleRate: "cycleRate", initialTime: "initialTime", playCtrl: "playCtrl", rate: "rate", rateVisible: "rateVisible", rates: "rates", trafficMsg: "trafficMsg", unAllowForwardMsg: "unAllowForwardMsg", unAllowRateMsg: "unAllowRateMsg", url: "url" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyAudio = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$a,
+        inputs: ['allowBackward', 'allowForward', 'autoplay', 'cycleRate', 'initialTime', 'playCtrl', 'rate', 'rateVisible', 'rates', 'trafficMsg', 'unAllowForwardMsg', 'unAllowRateMsg', 'url'],
+        methods: ['switchAudio', 'play', 'pause', 'setPlayRate', 'getAudioElement']
+    })
+], CtyAudio);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAudio, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-audio',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['allowBackward', 'allowForward', 'autoplay', 'cycleRate', 'initialTime', 'playCtrl', 'rate', 'rateVisible', 'rates', 'trafficMsg', 'unAllowForwardMsg', 'unAllowRateMsg', 'url'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyBanner = class CtyBanner {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctySwipeChange', 'ctySwipeTap']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyBanner, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyBanner, isStandalone: true, selector: "cty-banner", inputs: { autoplay: "autoplay", banners: "banners", duration: "duration", indicator: "indicator", initialIndex: "initialIndex", loop: "loop", props: "props", touchable: "touchable", vertical: "vertical" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyBanner = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$b,
+        inputs: ['autoplay', 'banners', 'duration', 'indicator', 'initialIndex', 'loop', 'props', 'touchable', 'vertical'],
+        methods: ['swipeNext', 'swipePrev', 'swipeTo']
+    })
+], CtyBanner);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyBanner, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-banner',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoplay', 'banners', 'duration', 'indicator', 'initialIndex', 'loop', 'props', 'touchable', 'vertical'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyCameraPhoto = class CtyCameraPhoto {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyTapStart', 'ctyTap', 'ctyDismiss', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCameraPhoto, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyCameraPhoto, isStandalone: true, selector: "cty-camera-photo", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", cancelText: "cancelText", clipCancelText: "clipCancelText", clipCconfirmText: "clipCconfirmText", clipImageBg: "clipImageBg", clipImageQuality: "clipImageQuality", clipImageSuffix: "clipImageSuffix", clipImageWidth: "clipImageWidth", clipMaxScale: "clipMaxScale", clipMinScale: "clipMinScale", clipPt: "clipPt", closeIcon: "closeIcon", closeable: "closeable", count: "count", cssClass: "cssClass", enterAnimation: "enterAnimation", file: "file", leaveAnimation: "leaveAnimation", options: "options", overlay: "overlay", permissionPurpose: "permissionPurpose", photoOption: "photoOption", root: "root", title: "title", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyCameraPhoto = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$c,
+        inputs: ['animated', 'backdropDismiss', 'cancelText', 'clipCancelText', 'clipCconfirmText', 'clipImageBg', 'clipImageQuality', 'clipImageSuffix', 'clipImageWidth', 'clipMaxScale', 'clipMinScale', 'clipPt', 'closeIcon', 'closeable', 'count', 'cssClass', 'enterAnimation', 'file', 'leaveAnimation', 'options', 'overlay', 'permissionPurpose', 'photoOption', 'root', 'title', 'trigger'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyCameraPhoto);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCameraPhoto, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-camera-photo',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'cancelText', 'clipCancelText', 'clipCconfirmText', 'clipImageBg', 'clipImageQuality', 'clipImageSuffix', 'clipImageWidth', 'clipMaxScale', 'clipMinScale', 'clipPt', 'closeIcon', 'closeable', 'count', 'cssClass', 'enterAnimation', 'file', 'leaveAnimation', 'options', 'overlay', 'permissionPurpose', 'photoOption', 'root', 'title', 'trigger'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyCanvasBoard = class CtyCanvasBoard {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyClear', 'ctyStart', 'ctyMove', 'ctyEnd', 'ctyConfirm']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCanvasBoard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyCanvasBoard, isStandalone: true, selector: "cty-canvas-board", inputs: { bgColor: "bgColor", bgIcon: "bgIcon", clearIcon: "clearIcon", clearLabel: "clearLabel", confirmLabel: "confirmLabel", dpr: "dpr", eraserIcon: "eraserIcon", footerOpn: "footerOpn", headerOpn: "headerOpn", lineCap: "lineCap", lineWidths: "lineWidths", pencilIcon: "pencilIcon", quality: "quality", redoIcon: "redoIcon", showButtons: "showButtons", strokeColor: "strokeColor", strokeWidth: "strokeWidth", suffix: "suffix", undoIcon: "undoIcon" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyCanvasBoard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$d,
+        inputs: ['bgColor', 'bgIcon', 'clearIcon', 'clearLabel', 'confirmLabel', 'dpr', 'eraserIcon', 'footerOpn', 'headerOpn', 'lineCap', 'lineWidths', 'pencilIcon', 'quality', 'redoIcon', 'showButtons', 'strokeColor', 'strokeWidth', 'suffix', 'undoIcon'],
+        methods: ['undo', 'redo', 'clear', 'getDataURL']
+    })
+], CtyCanvasBoard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCanvasBoard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-canvas-board',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['bgColor', 'bgIcon', 'clearIcon', 'clearLabel', 'confirmLabel', 'dpr', 'eraserIcon', 'footerOpn', 'headerOpn', 'lineCap', 'lineWidths', 'pencilIcon', 'quality', 'redoIcon', 'showButtons', 'strokeColor', 'strokeWidth', 'suffix', 'undoIcon'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyCanvasVideo = class CtyCanvasVideo {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctySlideChange', 'ctySlidePrev', 'ctySlideNext', 'ctyLongPress', 'ctyVideoUpdate', 'ctyVideoEnd', 'ctyTapName', 'ctyTapAvatar', 'ctyTapLike', 'ctyTapCollect', 'ctyTapShare']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCanvasVideo, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyCanvasVideo, isStandalone: true, selector: "cty-canvas-video", inputs: { autoplay: "autoplay", avatarButton: "avatarButton", next: "next", preload: "preload", props: "props", slice: "slice", videos: "videos" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyCanvasVideo = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$e,
+        inputs: ['autoplay', 'avatarButton', 'next', 'preload', 'props', 'slice', 'videos'],
+        methods: ['slideToPrev', 'slideToNext']
+    })
+], CtyCanvasVideo);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCanvasVideo, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-canvas-video',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoplay', 'avatarButton', 'next', 'preload', 'props', 'slice', 'videos'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyCascader = class CtyCascader {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyChange', 'ctyComfirm', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCascader, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyCascader, isStandalone: true, selector: "cty-cascader", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", cancelText: "cancelText", cascade: "cascade", childrenKey: "childrenKey", columns: "columns", columnsCount: "columnsCount", confirmText: "confirmText", cssClass: "cssClass", defaultValues: "defaultValues", enterAnimation: "enterAnimation", leaveAnimation: "leaveAnimation", optionCount: "optionCount", optionHeight: "optionHeight", root: "root", textKey: "textKey", title: "title", trigger: "trigger", type: "type", valueKey: "valueKey" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyCascader = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$f,
+        inputs: ['animated', 'backdropDismiss', 'cancelText', 'cascade', 'childrenKey', 'columns', 'columnsCount', 'confirmText', 'cssClass', 'defaultValues', 'enterAnimation', 'leaveAnimation', 'optionCount', 'optionHeight', 'root', 'textKey', 'title', 'trigger', 'type', 'valueKey'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyCascader);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCascader, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-cascader',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'cancelText', 'cascade', 'childrenKey', 'columns', 'columnsCount', 'confirmText', 'cssClass', 'defaultValues', 'enterAnimation', 'leaveAnimation', 'optionCount', 'optionHeight', 'root', 'textKey', 'title', 'trigger', 'type', 'valueKey'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyCircle = class CtyCircle {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCircle, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyCircle, isStandalone: true, selector: "cty-circle", inputs: { clockwise: "clockwise", color: "color", rad: "rad", rate: "rate", text: "text", width: "width", zeroTransparent: "zeroTransparent" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyCircle = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$g,
+        inputs: ['clockwise', 'color', 'rad', 'rate', 'text', 'width', 'zeroTransparent']
+    })
+], CtyCircle);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCircle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-circle',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['clockwise', 'color', 'rad', 'rate', 'text', 'width', 'zeroTransparent'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyCountDown = class CtyCountDown {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyChange', 'ctyFinish']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCountDown, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyCountDown, isStandalone: true, selector: "cty-count-down", inputs: { autoStart: "autoStart", dateFormatUnit: "dateFormatUnit", format: "format", millisecond: "millisecond", time: "time", unit: "unit" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyCountDown = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$h,
+        inputs: ['autoStart', 'dateFormatUnit', 'format', 'millisecond', 'time', 'unit'],
+        methods: ['start', 'reset', 'pause']
+    })
+], CtyCountDown);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCountDown, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-count-down',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoStart', 'dateFormatUnit', 'format', 'millisecond', 'time', 'unit'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyCropImage = class CtyCropImage {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyCancel', 'ctyConfirm']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCropImage, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyCropImage, isStandalone: true, selector: "cty-crop-image", inputs: { cancelText: "cancelText", confirmText: "confirmText", imageBackground: "imageBackground", imageWidth: "imageWidth", maxScale: "maxScale", minScale: "minScale", quality: "quality", suffix: "suffix", url: "url" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyCropImage = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$i,
+        inputs: ['cancelText', 'confirmText', 'imageBackground', 'imageWidth', 'maxScale', 'minScale', 'quality', 'suffix', 'url'],
+        methods: ['getCanvasImg']
+    })
+], CtyCropImage);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCropImage, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-crop-image',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['cancelText', 'confirmText', 'imageBackground', 'imageWidth', 'maxScale', 'minScale', 'quality', 'suffix', 'url'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyDivider = class CtyDivider {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyDivider, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyDivider, isStandalone: true, selector: "cty-divider", inputs: { placement: "placement", vertical: "vertical" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyDivider = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$j,
+        inputs: ['placement', 'vertical']
+    })
+], CtyDivider);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyDivider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-divider',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['placement', 'vertical'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyEmpty = class CtyEmpty {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyEmpty, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyEmpty, isStandalone: true, selector: "cty-empty", inputs: { description: "description", image: "image" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyEmpty = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$k,
+        inputs: ['description', 'image']
+    })
+], CtyEmpty);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyEmpty, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-empty',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['description', 'image'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyFloatingBubble = class CtyFloatingBubble {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyMoveStart', 'ctyMove', 'ctyMoveEnd', 'ctyClick']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyFloatingBubble, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyFloatingBubble, isStandalone: true, selector: "cty-floating-bubble", inputs: { axis: "axis", gap: "gap", icon: "icon", magnetic: "magnetic", offset: "offset" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyFloatingBubble = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$l,
+        inputs: ['axis', 'gap', 'icon', 'magnetic', 'offset']
+    })
+], CtyFloatingBubble);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyFloatingBubble, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-floating-bubble',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['axis', 'gap', 'icon', 'magnetic', 'offset'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyFloatingPanel = class CtyFloatingPanel {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyHeightChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyFloatingPanel, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyFloatingPanel, isStandalone: true, selector: "cty-floating-panel", inputs: { anchors: "anchors", contentDraggable: "contentDraggable", damp: "damp", endAnchor: "endAnchor", icon: "icon" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyFloatingPanel = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$m,
+        inputs: ['anchors', 'contentDraggable', 'damp', 'endAnchor', 'icon']
+    })
+], CtyFloatingPanel);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyFloatingPanel, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-floating-panel',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['anchors', 'contentDraggable', 'damp', 'endAnchor', 'icon'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyIcon = class CtyIcon {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyIcon, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyIcon, isStandalone: true, selector: "cty-icon", inputs: { color: "color", flipRtl: "flipRtl", lazy: "lazy", name: "name", sanitize: "sanitize", size: "size" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyIcon = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$n,
+        inputs: ['color', 'flipRtl', 'lazy', 'name', 'sanitize', 'size']
+    })
+], CtyIcon);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyIcon, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-icon',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['color', 'flipRtl', 'lazy', 'name', 'sanitize', 'size'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyImageUpload = class CtyImageUpload {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyImagePicker', 'ctyAddImageTap', 'ctyImageTap', 'ctyDeleteImage', 'ctImageViewerDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyImageUpload, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyImageUpload, isStandalone: true, selector: "cty-image-upload", inputs: { addIcon: "addIcon", addImage: "addImage", cameraPhotoOptions: "cameraPhotoOptions", count: "count", deleteable: "deleteable", imageViewer: "imageViewer", imageViewerOptions: "imageViewerOptions", images: "images" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyImageUpload = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$o,
+        inputs: ['addIcon', 'addImage', 'cameraPhotoOptions', 'count', 'deleteable', 'imageViewer', 'imageViewerOptions', 'images']
+    })
+], CtyImageUpload);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyImageUpload, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-image-upload',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['addIcon', 'addImage', 'cameraPhotoOptions', 'count', 'deleteable', 'imageViewer', 'imageViewerOptions', 'images'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyImageViewer = class CtyImageViewer {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctySlideChange', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyImageViewer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyImageViewer, isStandalone: true, selector: "cty-image-viewer", inputs: { animated: "animated", attrs: "attrs", backdropDismiss: "backdropDismiss", closeable: "closeable", cssClass: "cssClass", enterAnimation: "enterAnimation", images: "images", initialSlide: "initialSlide", leaveAnimation: "leaveAnimation", loop: "loop", pager: "pager", root: "root", speed: "speed", trigger: "trigger", zoom: "zoom" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyImageViewer = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$p,
+        inputs: ['animated', 'attrs', 'backdropDismiss', 'closeable', 'cssClass', 'enterAnimation', 'images', 'initialSlide', 'leaveAnimation', 'loop', 'pager', 'root', 'speed', 'trigger', 'zoom'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss', 'slideTo']
+    })
+], CtyImageViewer);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyImageViewer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-image-viewer',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'attrs', 'backdropDismiss', 'closeable', 'cssClass', 'enterAnimation', 'images', 'initialSlide', 'leaveAnimation', 'loop', 'pager', 'root', 'speed', 'trigger', 'zoom'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyIndexBar = class CtyIndexBar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyScrollToPoint']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyIndexBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyIndexBar, isStandalone: true, selector: "cty-index-bar", inputs: { alphabet: "alphabet", alphabets: "alphabets", duration: "duration", indexList: "indexList", offsetDiff: "offsetDiff", sticky: "sticky", stickyTop: "stickyTop", sum: "sum" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyIndexBar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$q,
+        inputs: ['alphabet', 'alphabets', 'duration', 'indexList', 'offsetDiff', 'sticky', 'stickyTop', 'sum'],
+        methods: ['scrollToIndex']
+    })
+], CtyIndexBar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyIndexBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-index-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['alphabet', 'alphabets', 'duration', 'indexList', 'offsetDiff', 'sticky', 'stickyTop', 'sum'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyKeyboard = class CtyKeyboard {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyKeyboard, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyKeyboard, isStandalone: true, selector: "cty-keyboard", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyKeyboard = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$r
+    })
+], CtyKeyboard);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyKeyboard, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-keyboard',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyLoading = class CtyLoading {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyLoading, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyLoading, isStandalone: true, selector: "cty-loading", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", cssClass: "cssClass", enterAnimation: "enterAnimation", img: "img", leaveAnimation: "leaveAnimation", root: "root", spinner: "spinner", trigger: "trigger", vertical: "vertical" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyLoading = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$s,
+        inputs: ['animated', 'backdropDismiss', 'cssClass', 'enterAnimation', 'img', 'leaveAnimation', 'root', 'spinner', 'trigger', 'vertical'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyLoading);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyLoading, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-loading',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'cssClass', 'enterAnimation', 'img', 'leaveAnimation', 'root', 'spinner', 'trigger', 'vertical'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyMediaCapture = class CtyMediaCapture {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyComplete', 'ctyStart', 'ctyStop']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyMediaCapture, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyMediaCapture, isStandalone: true, selector: "cty-media-capture", inputs: { autoplay: "autoplay", captureTime: "captureTime", closeIcon: "closeIcon", confirmText: "confirmText", controls: "controls", loop: "loop", options: "options", poster: "poster", revocationIcon: "revocationIcon", timeLimit: "timeLimit" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyMediaCapture = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$t,
+        inputs: ['autoplay', 'captureTime', 'closeIcon', 'confirmText', 'controls', 'loop', 'options', 'poster', 'revocationIcon', 'timeLimit'],
+        methods: ['startVideoCapture', 'stopVideoCapture']
+    })
+], CtyMediaCapture);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyMediaCapture, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-media-capture',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoplay', 'captureTime', 'closeIcon', 'confirmText', 'controls', 'loop', 'options', 'poster', 'revocationIcon', 'timeLimit'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyNavBar = class CtyNavBar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyNavBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyNavBar, isStandalone: true, selector: "cty-nav-bar", inputs: { arrow: "arrow", end: "end", start: "start", title: "title", type: "type" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyNavBar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$u,
+        inputs: ['arrow', 'end', 'start', 'title', 'type']
+    })
+], CtyNavBar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyNavBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-nav-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['arrow', 'end', 'start', 'title', 'type'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyNoticeBar = class CtyNoticeBar {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyIconTap']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyNoticeBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyNoticeBar, isStandalone: true, selector: "cty-notice-bar", inputs: { endIcon: "endIcon", scrollable: "scrollable", speed: "speed", startIcon: "startIcon", text: "text" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyNoticeBar = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$v,
+        inputs: ['endIcon', 'scrollable', 'speed', 'startIcon', 'text']
+    })
+], CtyNoticeBar);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyNoticeBar, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-notice-bar',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['endIcon', 'scrollable', 'speed', 'startIcon', 'text'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyOverlay = class CtyOverlay {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyOverlay, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyOverlay, isStandalone: true, selector: "cty-overlay", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", cssClass: "cssClass", enterAnimation: "enterAnimation", html: "html", leaveAnimation: "leaveAnimation", position: "position", root: "root", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyOverlay = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$w,
+        inputs: ['animated', 'backdropDismiss', 'cssClass', 'enterAnimation', 'html', 'leaveAnimation', 'position', 'root', 'trigger'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyOverlay);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyOverlay, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-overlay',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'cssClass', 'enterAnimation', 'html', 'leaveAnimation', 'position', 'root', 'trigger'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyPdfViewer = class CtyPdfViewer {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyInit', 'ctyEnd']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyPdfViewer, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyPdfViewer, isStandalone: true, selector: "cty-pdf-viewer", inputs: { url: "url", viewerUrl: "viewerUrl" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyPdfViewer = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$x,
+        inputs: ['url', 'viewerUrl']
+    })
+], CtyPdfViewer);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyPdfViewer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-pdf-viewer',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['url', 'viewerUrl'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyPermissionPurpose = class CtyPermissionPurpose {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyPermissionPurpose, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyPermissionPurpose, isStandalone: true, selector: "cty-permission-purpose", inputs: { backdropDismiss: "backdropDismiss", description: "description" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyPermissionPurpose = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$y,
+        inputs: ['backdropDismiss', 'description']
+    })
+], CtyPermissionPurpose);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyPermissionPurpose, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-permission-purpose',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['backdropDismiss', 'description'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyProgress = class CtyProgress {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyProgress, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyProgress, isStandalone: true, selector: "cty-progress", inputs: { percentage: "percentage", pivot: "pivot", pivotText: "pivotText" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyProgress = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$z,
+        inputs: ['percentage', 'pivot', 'pivotText']
+    })
+], CtyProgress);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyProgress, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-progress',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['percentage', 'pivot', 'pivotText'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyQuickAccess = class CtyQuickAccess {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyTap', 'ctySlide', 'ctySlideEnd', 'ctyInit']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyQuickAccess, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyQuickAccess, isStandalone: true, selector: "cty-quick-access", inputs: { col: "col", options: "options", paper: "paper", props: "props", quickThreshold: "quickThreshold", row: "row", slideThreshold: "slideThreshold", transition: "transition" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyQuickAccess = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$A,
+        inputs: ['col', 'options', 'paper', 'props', 'quickThreshold', 'row', 'slideThreshold', 'transition'],
+        methods: ['getCurrentPage']
+    })
+], CtyQuickAccess);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyQuickAccess, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-quick-access',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['col', 'options', 'paper', 'props', 'quickThreshold', 'row', 'slideThreshold', 'transition'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyRecord = class CtyRecord {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyRecordStart', 'ctyRecording', 'ctyRecordEnd', 'ctyRecordComplete', 'ctyDismiss', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyRecord, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyRecord, isStandalone: true, selector: "cty-record", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", circleColor: "circleColor", circleWidth: "circleWidth", closeable: "closeable", cssClass: "cssClass", enterAnimation: "enterAnimation", leaveAnimation: "leaveAnimation", maxSeconds: "maxSeconds", minSeconds: "minSeconds", root: "root", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyRecord = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$B,
+        inputs: ['animated', 'backdropDismiss', 'circleColor', 'circleWidth', 'closeable', 'cssClass', 'enterAnimation', 'leaveAnimation', 'maxSeconds', 'minSeconds', 'root', 'trigger'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss', 'resetRecordState', 'startRecord', 'stopRecording']
+    })
+], CtyRecord);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyRecord, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-record',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'circleColor', 'circleWidth', 'closeable', 'cssClass', 'enterAnimation', 'leaveAnimation', 'maxSeconds', 'minSeconds', 'root', 'trigger'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyShareSheet = class CtyShareSheet {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyTap', 'ctyShareSuccess', 'ctyShareFail', 'ctyGuide', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyShareSheet, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyShareSheet, isStandalone: true, selector: "cty-share-sheet", inputs: { animated: "animated", backdropDismiss: "backdropDismiss", cancelText: "cancelText", cssClass: "cssClass", description: "description", enterAnimation: "enterAnimation", guide: "guide", guideImg: "guideImg", hiddenSheet: "hiddenSheet", leaveAnimation: "leaveAnimation", legacyCopy: "legacyCopy", options: "options", permissionDescription: "permissionDescription", permissionPurpose: "permissionPurpose", root: "root", shareOption: "shareOption", title: "title", trigger: "trigger" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyShareSheet = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$C,
+        inputs: ['animated', 'backdropDismiss', 'cancelText', 'cssClass', 'description', 'enterAnimation', 'guide', 'guideImg', 'hiddenSheet', 'leaveAnimation', 'legacyCopy', 'options', 'permissionDescription', 'permissionPurpose', 'root', 'shareOption', 'title', 'trigger'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyShareSheet);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyShareSheet, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-share-sheet',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'backdropDismiss', 'cancelText', 'cssClass', 'description', 'enterAnimation', 'guide', 'guideImg', 'hiddenSheet', 'leaveAnimation', 'legacyCopy', 'options', 'permissionDescription', 'permissionPurpose', 'root', 'shareOption', 'title', 'trigger'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyStep = class CtyStep {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyStep, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyStep, isStandalone: true, selector: "cty-step", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyStep = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$D
+    })
+], CtyStep);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyStep, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-step',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtySteps = class CtySteps {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyStepTap', 'ctyChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySteps, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtySteps, isStandalone: true, selector: "cty-steps", inputs: { active: "active", activeIcon: "activeIcon", direction: "direction", finishIcon: "finishIcon", inactiveIcon: "inactiveIcon" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtySteps = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$E,
+        inputs: ['active', 'activeIcon', 'direction', 'finishIcon', 'inactiveIcon'],
+        methods: ['onClickStep']
+    })
+], CtySteps);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySteps, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-steps',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['active', 'activeIcon', 'direction', 'finishIcon', 'inactiveIcon'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtySwipe = class CtySwipe {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyChange', 'ctyDragStart', 'ctyDragEnd']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySwipe, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtySwipe, isStandalone: true, selector: "cty-swipe", inputs: { autoplay: "autoplay", duration: "duration", indicator: "indicator", initialSwipe: "initialSwipe", loop: "loop", touchable: "touchable", vertical: "vertical" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtySwipe = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$F,
+        inputs: ['autoplay', 'duration', 'indicator', 'initialSwipe', 'loop', 'touchable', 'vertical'],
+        methods: ['prev', 'next', 'swipeTo']
+    })
+], CtySwipe);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySwipe, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-swipe',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['autoplay', 'duration', 'indicator', 'initialSwipe', 'loop', 'touchable', 'vertical'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtySwipeItem = class CtySwipeItem {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySwipeItem, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtySwipeItem, isStandalone: true, selector: "cty-swipe-item", ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtySwipeItem = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$G,
+        methods: ['setOffset']
+    })
+], CtySwipeItem);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtySwipeItem, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-swipe-item',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: [],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyTextEllipsis = class CtyTextEllipsis {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyExpandChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTextEllipsis, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyTextEllipsis, isStandalone: true, selector: "cty-text-ellipsis", inputs: { collapseText: "collapseText", content: "content", dots: "dots", expandText: "expandText", position: "position", rows: "rows" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyTextEllipsis = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$H,
+        inputs: ['collapseText', 'content', 'dots', 'expandText', 'position', 'rows']
+    })
+], CtyTextEllipsis);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTextEllipsis, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-text-ellipsis',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['collapseText', 'content', 'dots', 'expandText', 'position', 'rows'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyTour = class CtyTour {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyChange', 'ctyDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTour, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyTour, isStandalone: true, selector: "cty-tour", inputs: { arrow: "arrow", backdropDismiss: "backdropDismiss", closeable: "closeable", completeText: "completeText", cssClass: "cssClass", initialIndex: "initialIndex", nextText: "nextText", placement: "placement", popoverAttrs: "popoverAttrs", prevText: "prevText", showPrev: "showPrev", steps: "steps" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyTour = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$I,
+        inputs: ['arrow', 'backdropDismiss', 'closeable', 'completeText', 'cssClass', 'initialIndex', 'nextText', 'placement', 'popoverAttrs', 'prevText', 'showPrev', 'steps'],
+        methods: ['present', 'dismiss', 'prevStep', 'nextStep', 'complete']
+    })
+], CtyTour);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTour, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-tour',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['arrow', 'backdropDismiss', 'closeable', 'completeText', 'cssClass', 'initialIndex', 'nextText', 'placement', 'popoverAttrs', 'prevText', 'showPrev', 'steps'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyTutorial = class CtyTutorial {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctySlideChange', 'ctySlideTap', 'ctyDidPresent', 'ctyWillPresent', 'ctyWillDismiss', 'ctyDidDismiss']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTutorial, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyTutorial, isStandalone: true, selector: "cty-tutorial", inputs: { animated: "animated", autoplay: "autoplay", backdropDismiss: "backdropDismiss", banners: "banners", closeable: "closeable", cssClass: "cssClass", duration: "duration", enterAnimation: "enterAnimation", indicator: "indicator", initialIndex: "initialIndex", leaveAnimation: "leaveAnimation", loop: "loop", props: "props", root: "root", touchable: "touchable", trigger: "trigger", vertical: "vertical" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyTutorial = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$J,
+        inputs: ['animated', 'autoplay', 'backdropDismiss', 'banners', 'closeable', 'cssClass', 'duration', 'enterAnimation', 'indicator', 'initialIndex', 'leaveAnimation', 'loop', 'props', 'root', 'touchable', 'trigger', 'vertical'],
+        methods: ['present', 'dismiss', 'onDidDismiss', 'onWillDismiss']
+    })
+], CtyTutorial);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTutorial, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-tutorial',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['animated', 'autoplay', 'backdropDismiss', 'banners', 'closeable', 'cssClass', 'duration', 'enterAnimation', 'indicator', 'initialIndex', 'leaveAnimation', 'loop', 'props', 'root', 'touchable', 'trigger', 'vertical'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyVideo = class CtyVideo {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyDismiss', 'ctyVideoCanplay', 'ctyVideoTimeupdate', 'ctyVideoPlaying', 'ctyVideoPlay', 'ctyVideoPause', 'ctyVideoStalled', 'ctyVideoWaiting', 'ctyVideoEnded', 'ctyVideoError', 'ctyVideoChangeVolume', 'ctyVideoProgress', 'ctyVideoScreenChange', 'ctyVideoIAEnter', 'ctyVideoIAAction', 'ctyVideoCtrlChange', 'ctyVideoRateChange']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyVideo, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyVideo, isStandalone: true, selector: "cty-video", inputs: { allowBackward: "allowBackward", allowForward: "allowForward", autoplay: "autoplay", controls: "controls", defaultFullscreen: "defaultFullscreen", directRate: "directRate", direction: "direction", errorMsg: "errorMsg", exitFullscreenIcon: "exitFullscreenIcon", footerCtrl: "footerCtrl", fullscreenIcon: "fullscreenIcon", fullscreenOnly: "fullscreenOnly", headerCtrl: "headerCtrl", interactiveActions: "interactiveActions", landscapeEnterTimer: "landscapeEnterTimer", landscapeLeaveTimer: "landscapeLeaveTimer", loading: "loading", loadingImg: "loadingImg", markers: "markers", orientation: "orientation", player: "player", poster: "poster", preload: "preload", progressPosition: "progressPosition", rate: "rate", rates: "rates", startTime: "startTime", title: "title", togglePlayTimer: "togglePlayTimer", trafficAutoplay: "trafficAutoplay", trafficMsg: "trafficMsg", unAllowForwardMsg: "unAllowForwardMsg", unAllowRateMsg: "unAllowRateMsg", updateNow: "updateNow", url: "url" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyVideo = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$K,
+        inputs: ['allowBackward', 'allowForward', 'autoplay', 'controls', 'defaultFullscreen', 'directRate', 'direction', 'errorMsg', 'exitFullscreenIcon', 'footerCtrl', 'fullscreenIcon', 'fullscreenOnly', 'headerCtrl', 'interactiveActions', 'landscapeEnterTimer', 'landscapeLeaveTimer', 'loading', 'loadingImg', 'markers', 'orientation', 'player', 'poster', 'preload', 'progressPosition', 'rate', 'rates', 'startTime', 'title', 'togglePlayTimer', 'trafficAutoplay', 'trafficMsg', 'unAllowForwardMsg', 'unAllowRateMsg', 'updateNow', 'url'],
+        methods: ['play', 'setCtrlShow', 'pause', 'setVideoCurrentTime', 'toggleVideo', 'toggleVolume', 'setPlayRate', 'getVideoElement']
+    })
+], CtyVideo);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyVideo, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-video',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['allowBackward', 'allowForward', 'autoplay', 'controls', 'defaultFullscreen', 'directRate', 'direction', 'errorMsg', 'exitFullscreenIcon', 'footerCtrl', 'fullscreenIcon', 'fullscreenOnly', 'headerCtrl', 'interactiveActions', 'landscapeEnterTimer', 'landscapeLeaveTimer', 'loading', 'loadingImg', 'markers', 'orientation', 'player', 'poster', 'preload', 'progressPosition', 'rate', 'rates', 'startTime', 'title', 'togglePlayTimer', 'trafficAutoplay', 'trafficMsg', 'unAllowForwardMsg', 'unAllowRateMsg', 'updateNow', 'url'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+let CtyVirtualList = class CtyVirtualList {
+    z;
+    el;
+    constructor(c, r, z) {
+        this.z = z;
+        c.detach();
+        this.el = r.nativeElement;
+        proxyOutputs(this, this.el, ['ctyScroll']);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyVirtualList, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CtyVirtualList, isStandalone: true, selector: "cty-virtual-list", inputs: { containerHeight: "containerHeight", direction: "direction", itemKey: "itemKey", itemRender: "itemRender", items: "items", preloadItemCount: "preloadItemCount" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CtyVirtualList = __decorate([
+    ProxyCmp({
+        defineCustomElementFn: defineCustomElement$L,
+        inputs: ['containerHeight', 'direction', 'itemKey', 'itemRender', 'items', 'preloadItemCount']
+    })
+], CtyVirtualList);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyVirtualList, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cty-virtual-list',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: '<ng-content></ng-content>',
+                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
+                    inputs: ['containerHeight', 'direction', 'itemKey', 'itemRender', 'items', 'preloadItemCount'],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }]; } });
+
+const provideCtyMUIAngular = (config) => {
+    return makeEnvironmentProviders([
+        {
+            provide: ConfigToken,
+            useValue: config,
+        },
+        {
+            provide: APP_INITIALIZER,
+            useFactory: initializeCtyMUIAngular,
+            multi: true,
+            deps: [ConfigToken],
+        }
+    ]);
+};
+const initializeCtyMUIAngular = (config) => {
+    return () => {
+        initialize(config);
+    };
+};
+
+class CtyAlertController extends OverlayBaseController {
+    constructor() {
+        super(alertController);
+        defineCustomElement$7();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAlertController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAlertController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyAlertController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyActionSheetController extends OverlayBaseController {
+    constructor() {
+        super(actionSheetController);
+        defineCustomElement$M();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyActionSheetController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyActionSheetController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyActionSheetController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyCameraPhotoController extends OverlayBaseController {
+    constructor() {
+        super(cameraPhotoController);
+        defineCustomElement$N();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCameraPhotoController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCameraPhotoController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCameraPhotoController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyCascaderController extends OverlayBaseController {
+    constructor() {
+        super(cascaderController);
+        defineCustomElement$O();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCascaderController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCascaderController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyCascaderController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyLoadingController extends OverlayBaseController {
+    constructor() {
+        super(loadingController);
+        defineCustomElement$P();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyLoadingController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyLoadingController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyLoadingController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyImageViewerController extends OverlayBaseController {
+    constructor() {
+        super(imageViewerController);
+        defineCustomElement$7();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyImageViewerController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyImageViewerController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyImageViewerController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyOverlayController extends OverlayBaseController {
+    constructor() {
+        super(overlayController);
+        defineCustomElement$7();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyOverlayController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyOverlayController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyOverlayController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyRecordController extends OverlayBaseController {
+    constructor() {
+        super(recordController);
+        defineCustomElement$Q();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyRecordController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyRecordController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyRecordController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyShareSheetController extends OverlayBaseController {
+    constructor() {
+        super(shareSheetController);
+        defineCustomElement$R();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyShareSheetController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyShareSheetController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyShareSheetController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyTutorialController extends OverlayBaseController {
+    constructor() {
+        super(tutorialController);
+        defineCustomElement$S();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTutorialController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTutorialController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyTutorialController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class CtyController {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async ActionSheet(opt) {
+        const actionSheet = await actionSheetController$1.create({ ...opt });
+        await actionSheet.present();
+        return actionSheet;
+    }
+    async Alert(opt) {
+        const options = {
+            ...this.config.get('alertCfg', {})
+        };
+        if (typeof opt === 'string') {
+            options.message = opt;
+        }
+        else {
+            Object.assign(options, opt);
+        }
+        ;
+        const alert = await alertController$1.create(options);
+        await alert.present();
+        return alert;
+    }
+    async Loading(opt) {
+        const loading = await loadingController$1.create(opt);
+        await loading.present();
+        return loading;
+    }
+    async Modal(opt) {
+        const modal = await modalController.create({
+            showBackdrop: false,
+            keyboardClose: false,
+            ...opt
+        });
+        await modal.present();
+        return modal;
+    }
+    async Picker(opt) {
+        const picker = await pickerController.create(opt);
+        await picker.present();
+        return picker;
+    }
+    async Popover(e, opt) {
+        const popover = await popoverController.create({
+            event: e,
+            ...opt
+        });
+        await popover.present();
+        return popover;
+    }
+    async Toast(opt) {
+        const options = {
+            ...this.config.get('toastCfg', {})
+        };
+        if (typeof opt === 'string') {
+            options.message = opt;
+        }
+        else {
+            Object.assign(options, opt);
+        }
+        ;
+        const toast = await toastController.create(options);
+        await toast.present();
+        return toast;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyController, deps: [{ token: i1.Config }], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyController, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CtyController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Config }]; } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CtyActionSheet, CtyActionSheetController, CtyAgree, CtyAlert, CtyAlertController, CtyAnswerSheet, CtyArticleCard, CtyAudio, CtyBanner, CtyCameraPhoto, CtyCameraPhotoController, CtyCanvasBoard, CtyCanvasVideo, CtyCascader, CtyCascaderController, CtyCircle, CtyController, CtyCountDown, CtyCropImage, CtyDivider, CtyEmpty, CtyFloatingBubble, CtyFloatingPanel, CtyIcon, CtyImageUpload, CtyImageViewer, CtyImageViewerController, CtyIndexBar, CtyKeyboard, CtyLoading, CtyLoadingController, CtyMediaCapture, CtyNavBar, CtyNoticeBar, CtyOverlay, CtyOverlayController, CtyPdfViewer, CtyPermissionPurpose, CtyProgress, CtyQuickAccess, CtyRate, CtyRecord, CtyRecordController, CtySegmentSlides, CtyShareSheet, CtyShareSheetController, CtyStep, CtyStepper, CtySteps, CtySwipe, CtySwipeItem, CtySwiper, CtyTextEllipsis, CtyTour, CtyTutorial, CtyTutorialController, CtyVideo, CtyVirtualList, provideCtyMUIAngular };
+//# sourceMappingURL=cty-mui-angular-standalone.mjs.map