survey-core 1.12.21 → 1.12.23

package/typings/src/trigger.d.ts

@@ -0,0 +1,155 @@
+import { HashTable } from "./helpers";
+import { Base } from "./base";
+import { ISurvey } from "./base-interfaces";
+/**
+ * A base class for all triggers.
+ * A trigger calls a method when the expression change the result: from false to true or from true to false.
+ * Please note, it runs only one changing the expression result.
+ */
+export declare class Trigger extends Base {
+    static idCounter: number;
+    static operatorsValue: HashTable<Function>;
+    static get operators(): HashTable<Function>;
+    private conditionRunner;
+    private idValue;
+    constructor();
+    get id(): number;
+    getType(): string;
+    toString(): string;
+    isGhost: boolean;
+    protected get isInternal(): boolean;
+    get operator(): string;
+    set operator(value: string);
+    get value(): any;
+    set value(val: any);
+    get name(): string;
+    set name(val: string);
+    get expression(): string;
+    set expression(val: string);
+    protected canBeExecuted(isOnNextPage: boolean): boolean;
+    protected canBeExecutedOnComplete(): boolean;
+    protected isExecutingOnNextPage: boolean;
+    checkExpression(isOnNextPage: boolean, isOnComplete: boolean, keys: any, values: HashTable<any>, properties?: HashTable<any>): void;
+    protected canSuccessOnEmptyExpression(): boolean;
+    check(value: any): void;
+    get requireValidQuestion(): boolean;
+    private perform;
+    private triggerResult;
+    protected onSuccess(values: HashTable<any>, properties: HashTable<any>): void;
+    protected onFailure(): void;
+    protected onSuccessExecuted(): void;
+    endLoadingFromJson(): void;
+    private oldPropertiesChanged;
+    private onExpressionChanged;
+    buildExpression(): string;
+    private isCheckRequired;
+    protected getUsedVariables(): string[];
+    private createConditionRunner;
+    private get isRequireValue();
+}
+export interface ISurveyTriggerOwner {
+    getObjects(pages: string[], questions: string[]): any[];
+    setCompleted(trigger: Trigger): void;
+    canBeCompleted(trigger: Trigger, isCompleted: boolean): void;
+    triggerExecuted(trigger: Trigger): void;
+    setTriggerValue(name: string, value: any, isVariable: boolean): any;
+    copyTriggerValue(name: string, fromName: string, copyDisplayValue: boolean): void;
+    focusQuestion(name: string): boolean;
+}
+/**
+ * It extends the Trigger base class and add properties required for SurveyJS classes.
+ */
+export declare class SurveyTrigger extends Trigger {
+    protected ownerValue: ISurveyTriggerOwner;
+    constructor();
+    get owner(): ISurveyTriggerOwner;
+    setOwner(owner: ISurveyTriggerOwner): void;
+    getSurvey(live?: boolean): ISurvey;
+    protected isRealExecution(): boolean;
+    protected onSuccessExecuted(): void;
+}
+/**
+ * If expression returns true, it makes questions/pages visible.
+ * Ohterwise it makes them invisible.
+ */
+export declare class SurveyTriggerVisible extends SurveyTrigger {
+    pages: string[];
+    questions: string[];
+    constructor();
+    getType(): string;
+    protected onSuccess(values: HashTable<any>, properties: HashTable<any>): void;
+    protected onFailure(): void;
+    private onTrigger;
+    protected onItemSuccess(item: any): void;
+    protected onItemFailure(item: any): void;
+}
+/**
+ * If expression returns true, it completes the survey.
+ */
+export declare class SurveyTriggerComplete extends SurveyTrigger {
+    constructor();
+    getType(): string;
+    get requireValidQuestion(): boolean;
+    protected isRealExecution(): boolean;
+    protected onSuccess(values: HashTable<any>, properties: HashTable<any>): void;
+    protected onFailure(): void;
+}
+/**
+ * If expression returns true, the value from property **setValue** will be set to **setToName**
+ */
+export declare class SurveyTriggerSetValue extends SurveyTrigger {
+    constructor();
+    getType(): string;
+    protected canBeExecuted(isOnNextPage: boolean): boolean;
+    protected onPropertyValueChanged(name: string, oldValue: any, newValue: any): void;
+    get setToName(): string;
+    set setToName(val: string);
+    get setValue(): any;
+    set setValue(val: any);
+    get isVariable(): boolean;
+    set isVariable(val: boolean);
+    protected onSuccess(values: HashTable<any>, properties: HashTable<any>): void;
+}
+/**
+ * If expression returns true, the survey go to question **gotoName** and focus it.
+ */
+export declare class SurveyTriggerSkip extends SurveyTrigger {
+    constructor();
+    getType(): string;
+    get requireValidQuestion(): boolean;
+    get gotoName(): string;
+    set gotoName(val: string);
+    protected canBeExecuted(isOnNextPage: boolean): boolean;
+    protected onSuccess(values: HashTable<any>, properties: HashTable<any>): void;
+}
+/**
+ * If expression returns true, the **runExpression** will be run. If **setToName** property is not empty then the result of **runExpression** will be set to it.
+ */
+export declare class SurveyTriggerRunExpression extends SurveyTrigger {
+    constructor();
+    getType(): string;
+    get setToName(): string;
+    set setToName(val: string);
+    get runExpression(): string;
+    set runExpression(val: string);
+    protected canBeExecuted(isOnNextPage: boolean): boolean;
+    protected onSuccess(values: HashTable<any>, properties: HashTable<any>): boolean;
+    private onCompleteRunExpression;
+}
+/**
+ * If expression returns true, the value from question **fromName** will be set into **setToName**.
+ */
+export declare class SurveyTriggerCopyValue extends SurveyTrigger {
+    constructor();
+    protected canBeExecuted(isOnNextPage: boolean): boolean;
+    get setToName(): string;
+    set setToName(val: string);
+    get fromName(): string;
+    set fromName(val: string);
+    get copyDisplayValue(): boolean;
+    set copyDisplayValue(val: boolean);
+    getType(): string;
+    protected onSuccess(values: HashTable<any>, properties: HashTable<any>): void;
+    protected canSuccessOnEmptyExpression(): boolean;
+    protected getUsedVariables(): string[];
+}

package/typings/src/utils/animation.d.ts

@@ -0,0 +1,91 @@
+import { EventBase, Base } from "../base";
+export interface AnimationOptions {
+    cssClass: string;
+    onBeforeRunAnimation?: (element: HTMLElement) => void;
+    onAfterRunAnimation?: (element: HTMLElement) => void;
+}
+export interface IAnimationConsumer<T extends Array<any> = []> {
+    getLeaveOptions?(...args: T): AnimationOptions;
+    getEnterOptions?(...args: T): AnimationOptions;
+    getAnimatedElement(...args: T): HTMLElement;
+    isAnimationEnabled(): boolean;
+    getRerenderEvent(): EventBase<Base>;
+}
+interface IGroupAnimationInfo {
+    isReorderingRunning: boolean;
+    isDeletingRunning: boolean;
+    isAddingRunning: boolean;
+}
+interface IGroupAnimationCompareInfo<T> {
+    addedItems: Array<T>;
+    deletedItems: Array<T>;
+    reorderedItems: Array<{
+        item: T;
+        movedForward: boolean;
+    }>;
+    mergedItems: Array<T>;
+}
+export interface IAnimationGroupConsumer<T> extends IAnimationConsumer<[T]> {
+    getLeaveOptions?(item: T, info?: IGroupAnimationInfo): AnimationOptions;
+    getEnterOptions?(item: T, info?: IGroupAnimationInfo): AnimationOptions;
+    getReorderOptions?(item: T, movedForward: boolean, info?: IGroupAnimationInfo): AnimationOptions;
+    getKey?: (item: T) => any;
+    onCompareArrays?(options: IGroupAnimationCompareInfo<T>): void;
+    allowSyncRemovalAddition?: boolean;
+}
+export declare class AnimationUtils {
+    private getMsFromRule;
+    private reflow;
+    private getAnimationsCount;
+    private getAnimationDuration;
+    private cancelQueue;
+    private addCancelCallback;
+    private removeCancelCallback;
+    protected onAnimationEnd(element: HTMLElement, callback: (isCancel?: boolean) => void, options: AnimationOptions): void;
+    protected afterAnimationRun(element: HTMLElement, options: AnimationOptions | AnimationOptions): void;
+    protected beforeAnimationRun(element: HTMLElement, options: AnimationOptions | AnimationOptions): void;
+    private getCssClasses;
+    protected runAnimation(element: HTMLElement, options: AnimationOptions, callback: (isCancel?: boolean) => void): void;
+    protected clearHtmlElement(element: HTMLElement, options: AnimationOptions): void;
+    protected onNextRender(callback: (isCancel?: boolean) => void, isCancel?: boolean): void;
+    cancel(): void;
+}
+export declare class AnimationPropertyUtils extends AnimationUtils {
+    onEnter(options: IAnimationConsumer): void;
+    onLeave(options: IAnimationConsumer, callback: () => void): void;
+}
+export declare class AnimationGroupUtils<T> extends AnimationUtils {
+    runGroupAnimation(options: IAnimationGroupConsumer<T>, addedItems: Array<T>, removedItems: Array<T>, reorderedItems: Array<{
+        item: T;
+        movedForward: boolean;
+    }>, callback?: () => void): void;
+}
+export declare abstract class AnimationProperty<T, S extends IAnimationConsumer<any> = IAnimationConsumer> {
+    protected animationOptions: S;
+    protected update: (val: T, isTempUpdate?: boolean) => void;
+    protected getCurrentValue: () => T;
+    constructor(animationOptions: S, update: (val: T, isTempUpdate?: boolean) => void, getCurrentValue: () => T);
+    protected animation: AnimationUtils;
+    protected onNextRender(callback: () => void, onCancel?: () => void): void;
+    protected abstract _sync(newValue: T): void;
+    private _debouncedSync;
+    sync(newValue: T): void;
+    private cancelCallback;
+    cancel(): void;
+    cancelAnimations(): void;
+}
+export declare class AnimationBoolean extends AnimationProperty<boolean> {
+    protected animation: AnimationPropertyUtils;
+    protected _sync(newValue: boolean): void;
+}
+export declare class AnimationGroup<T> extends AnimationProperty<Array<T>, IAnimationGroupConsumer<T>> {
+    protected animation: AnimationGroupUtils<T>;
+    protected _sync(newValue: Array<T>): void;
+}
+export declare class AnimationTab<T> extends AnimationProperty<Array<T>, IAnimationGroupConsumer<T>> {
+    protected mergeValues?: (newValue: Array<T>, oldValue: Array<T>) => Array<T>;
+    protected animation: AnimationGroupUtils<T>;
+    constructor(animationOptions: IAnimationGroupConsumer<T>, update: (val: Array<T>, isTempUpdate?: boolean) => void, getCurrentValue: () => Array<T>, mergeValues?: (newValue: Array<T>, oldValue: Array<T>) => Array<T>);
+    protected _sync(newValue: [T]): void;
+}
+export {};

package/typings/src/utils/camera.d.ts

@@ -0,0 +1,27 @@
+export declare class Camera {
+    static mediaDevicesCallback: ((callback: (devices: Array<MediaDeviceInfo>) => void) => void) | undefined;
+    static clear(): void;
+    static setCameraList(list: Array<MediaDeviceInfo>): void;
+    private static cameraList;
+    private static cameraIndex;
+    private static cameraFacingMode;
+    private static canSwitchFacingMode;
+    hasCamera(callback: (res: boolean) => void): void;
+    getMediaConstraints(videoSize?: {
+        width?: number;
+        height?: number;
+    }): MediaStreamConstraints;
+    startVideo(videoElement: HTMLVideoElement, callback: (stream: MediaStream) => void, imageWidth?: number, imageHeight?: number): void;
+    getImageSize(videoEl: HTMLVideoElement): {
+        width: number;
+        height: number;
+    };
+    snap(videoElement: HTMLVideoElement, callback: BlobCallback): boolean;
+    private canFlipValue;
+    private updateCanFlipValue;
+    private onCanFlipChangedCallback?;
+    canFlip(onCanFlipChangedCallback?: (res: boolean) => void): boolean;
+    flip(): void;
+    private hasCameraCallback;
+    private setVideoInputs;
+}

package/typings/src/utils/cssClassBuilder.d.ts

@@ -0,0 +1,6 @@
+export declare class CssClassBuilder {
+    private classes;
+    isEmpty(): boolean;
+    append(value: string, condition?: boolean): CssClassBuilder;
+    toString(): string;
+}

package/typings/src/utils/devices.d.ts

@@ -0,0 +1,12 @@
+export declare const IsMobile: boolean;
+export declare var mouseInfo: {
+    readonly isTouch: boolean;
+    readonly hasTouchEvent: boolean;
+    hasMouse: boolean;
+};
+export declare let IsTouch: boolean;
+export declare function _setIsTouch(val: boolean): void;
+export type MatchMediaMethod = ((query: string) => {
+    matches: boolean;
+} | null) | null;
+export declare function detectMouseSupport(matchMedia: MatchMediaMethod): boolean;

package/typings/src/utils/dragOrClickHelper.d.ts

@@ -0,0 +1,16 @@
+export declare class DragOrClickHelper {
+    private dragHandler;
+    private pointerDownEvent;
+    private currentTarget;
+    private startX;
+    private startY;
+    private currentX;
+    private currentY;
+    private itemModel;
+    constructor(dragHandler: any);
+    onPointerDown(pointerDownEvent: any, itemModel?: any): void;
+    private onPointerUp;
+    private tryToStartDrag;
+    private get isMicroMovement();
+    private clearListeners;
+}

package/typings/src/utils/popup.d.ts

@@ -0,0 +1,45 @@
+export type VerticalPosition = "top" | "bottom" | "middle";
+export type HorizontalPosition = "left" | "right" | "center";
+export type PositionMode = "flex" | "fixed";
+export interface IPosition {
+    left?: number | string;
+    top?: number | string;
+}
+export interface INumberPosition extends IPosition {
+    left?: number;
+    top?: number;
+}
+export interface ISize {
+    width: number;
+    height: number;
+}
+export declare class Rect implements ISize, INumberPosition {
+    private x;
+    private y;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+}
+export declare class PopupUtils {
+    static bottomIndent: number;
+    static calculatePosition(targetRect: Rect, height: number, width: number, verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition, positionMode?: PositionMode): INumberPosition;
+    static getCorrectedVerticalDimensions(top: number, height: number, windowHeight: number, verticalPosition: VerticalPosition, canShrink?: boolean, margins?: {
+        top: number;
+        bottom: number;
+    }): any;
+    static updateHorizontalDimensions(left: number, width: number, windowWidth: number, horizontalPosition: HorizontalPosition, positionMode?: PositionMode, margins?: {
+        left: number;
+        right: number;
+    }): {
+        width: number;
+        left: number;
+    };
+    static updateVerticalPosition(targetRect: Rect, height: number, horizontalPosition: HorizontalPosition, verticalPosition: VerticalPosition, windowHeight: number): VerticalPosition;
+    static updateHorizontalPosition(targetRect: Rect, width: number, horizontalPosition: HorizontalPosition, windowWidth: number): HorizontalPosition;
+    static calculatePopupDirection(verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition): string;
+    static calculatePointerTarget(targetRect: Rect, top: number, left: number, verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition, marginLeft?: number, marginRight?: number): INumberPosition;
+}

package/typings/src/utils/responsivity-manager.d.ts

@@ -0,0 +1,31 @@
+import { AdaptiveActionContainer } from "../actions/adaptive-container";
+interface IDimensions {
+    scroll: number;
+    offset: number;
+}
+export declare class ResponsivityManager {
+    container: HTMLDivElement;
+    private model;
+    private resizeObserver;
+    private isInitialized;
+    getComputedStyle: (elt: Element) => CSSStyleDeclaration;
+    private debouncedProcess;
+    constructor(container: HTMLDivElement, model: AdaptiveActionContainer);
+    protected getDimensions(element: HTMLElement): IDimensions;
+    protected getAvailableSpace(): number;
+    protected getGap(): number;
+    protected calcItemSize(item: HTMLElement): number;
+    private updateItemsDimensions;
+    private get isContainerVisible();
+    private shouldProcessResponsiveness;
+    private process;
+    private isDisposed;
+    dispose(): void;
+}
+export declare class VerticalResponsivityManager extends ResponsivityManager {
+    constructor(container: HTMLDivElement, model: AdaptiveActionContainer);
+    protected getDimensions(): IDimensions;
+    protected getAvailableSpace(): number;
+    protected calcItemSize(item: HTMLDivElement): number;
+}
+export {};

package/typings/src/utils/taskmanager.d.ts

@@ -0,0 +1,28 @@
+export interface IExecutable {
+    id?: string;
+    execute: () => void;
+    isCompleted: boolean;
+    dispose?: () => void;
+}
+export declare class Task implements IExecutable {
+    private func;
+    private isMultiple;
+    private _isCompleted;
+    constructor(func: () => void, isMultiple?: boolean);
+    execute: () => void;
+    discard(): void;
+    get isCompleted(): boolean;
+}
+export declare class TaskManger {
+    private interval;
+    private static instance;
+    private static tasks;
+    private constructor();
+    static Instance(): TaskManger;
+    private tick;
+    static schedule(task: IExecutable): void;
+}
+export declare function debounce<T extends (...args: any) => void>(func: T): {
+    run: T;
+    cancel: () => void;
+};

package/typings/src/utils/text-area.d.ts

@@ -0,0 +1,58 @@
+import { Question } from "../question";
+export interface ITextArea {
+    question: any;
+    id: () => string;
+    propertyName: string;
+    className: () => string;
+    isDisabledAttr: () => boolean;
+    isReadOnlyAttr?: () => boolean;
+    placeholder: () => string;
+    autoGrow: () => boolean;
+    maxLength: () => number;
+    rows: () => number;
+    cols?: () => number;
+    getTextValue?: () => any;
+    onTextAreaChange?: (event: any) => void;
+    onTextAreaInput?: (event: any) => void;
+    onTextAreaKeyDown?: (event: any) => void;
+    onTextAreaBlur?: (event: any) => void;
+    onTextAreaFocus?: (event: any) => void;
+    ariaRequired: () => "true" | "false";
+    ariaLabel: () => string;
+    ariaInvalid?: () => "true" | "false";
+    ariaLabelledBy?: () => string;
+    ariaDescribedBy?: () => string;
+    ariaErrormessage?: () => string;
+}
+export declare class TextAreaModel {
+    private options;
+    private element;
+    updateElement(): void;
+    private onPropertyChangedCallback;
+    constructor(options: ITextArea);
+    setElement(element: HTMLTextAreaElement | null): void;
+    resetElement(): void;
+    getTextValue(): string;
+    onTextAreaChange(event: any): void;
+    onTextAreaInput(event: any): void;
+    onTextAreaKeyDown(event: any): void;
+    onTextAreaBlur(event: any): void;
+    onTextAreaFocus(event: any): void;
+    get question(): Question;
+    get id(): string;
+    get placeholder(): string;
+    get className(): string;
+    get maxLength(): number;
+    get autoGrow(): boolean;
+    get rows(): number;
+    get cols(): number | undefined;
+    get isDisabledAttr(): boolean;
+    get isReadOnlyAttr(): boolean | undefined;
+    get ariaRequired(): "true" | "false";
+    get ariaLabel(): string;
+    get ariaInvalid(): "true" | "false";
+    get ariaLabelledBy(): string;
+    get ariaDescribedBy(): string;
+    get ariaErrormessage(): string;
+    dispose(): void;
+}

package/typings/src/utils/utils.d.ts

@@ -0,0 +1,86 @@
+import { PopupBaseViewModel } from "../popup-view-model";
+declare function compareVersions(a: any, b: any): number;
+declare function confirmAction(message: string): boolean;
+declare function confirmActionAsync(options: IConfirmDialogOptions): void;
+declare function detectIEBrowser(): boolean;
+declare function detectIEOrEdge(): boolean;
+declare function loadFileFromBase64(b64Data: string, fileName: string): void;
+declare function isMobile(): boolean;
+declare const isShadowDOM: (rootElement: Document | ShadowRoot | HTMLElement) => rootElement is ShadowRoot;
+declare const getElement: (element: HTMLElement | string) => HTMLElement;
+declare function isElementVisible(element: HTMLElement, threshold?: number): boolean;
+declare function findScrollableParent(element: HTMLElement): HTMLElement;
+declare function activateLazyRenderingChecks(id: string): void;
+declare function navigateToUrl(url: string): void;
+declare function wrapUrlForBackgroundImage(url: string): string;
+declare function isBase64URL(url: string): boolean;
+declare const renamedIcons: any;
+declare function getIconNameFromProxy(iconName: string): string;
+export declare function getNewIconName(iconName: string): string;
+export declare function getCustomNewIconNameIfExists(iconName: string): string;
+declare function createSvg(size: number | string, width: number, height: number, iconName: string, svgElem: any, title: string): void;
+export declare function getSafeUrl(url: string): string;
+export declare function unwrap<T>(value: T | (() => T)): T;
+export declare function getRenderedSize(val: string | number): number;
+export declare function getRenderedStyleSize(val: string | number): string;
+export interface IAttachKey2clickOptions {
+    processEsc?: boolean;
+    disableTabStop?: boolean;
+    __keyDownReceived?: boolean;
+}
+export declare function doKey2ClickBlur(evt: KeyboardEvent): void;
+export declare function doKey2ClickUp(evt: KeyboardEvent, options?: IAttachKey2clickOptions): void;
+export declare function doKey2ClickDown(evt: KeyboardEvent, options?: IAttachKey2clickOptions): void;
+declare function increaseHeightByContent(element: HTMLElement, getComputedStyle?: (elt: Element) => any): void;
+declare function getOriginalEvent(event: any): any;
+declare function preventDefaults(event: any): void;
+declare function classesToSelector(str: string): string;
+declare function getElementWidth(el: HTMLElement): number;
+declare function isContainerVisible(el: HTMLElement): boolean;
+declare function getFirstVisibleChild(el: HTMLElement): any;
+declare function findParentByClassNames(element: HTMLElement, classNames: Array<string>): Element;
+export declare function sanitizeEditableContent(element: any, cleanLineBreaks?: boolean): void;
+declare function mergeValues(src: any, dest: any): void;
+declare function updateListCssValues(res: any, css: any): void;
+export declare class Logger {
+    private _result;
+    log(action: string): void;
+    get result(): string;
+}
+export interface IConfirmDialogOptions {
+    message?: string;
+    funcOnYes?: () => void;
+    funcOnNo?: () => void;
+    applyTitle?: string;
+    locale?: string;
+    rootElement?: HTMLElement;
+    cssClass?: string;
+}
+export declare function showConfirmDialog(message: string, callback: (res: boolean) => void, options: IConfirmDialogOptions): boolean;
+export declare function configConfirmDialog(popupViewModel: PopupBaseViewModel): void;
+declare function chooseFiles(input: HTMLInputElement, callback: (files: File[]) => void): void;
+export declare function compareArrays<T>(oldValue: Array<T>, newValue: Array<T>, getKey: (item: T) => any): {
+    addedItems: Array<T>;
+    deletedItems: Array<T>;
+    reorderedItems: Array<{
+        item: T;
+        movedForward: boolean;
+    }>;
+    mergedItems: Array<T>;
+};
+interface IVerticalDimensions {
+    paddingTop: string;
+    paddingBottom: string;
+    marginTop: string;
+    marginBottom: string;
+    heightTo: string;
+    borderTopWidth: string;
+    borderBottomWidth: string;
+    heightFrom: string;
+}
+export declare function getVerticalDimensions(el: HTMLElement): IVerticalDimensions;
+export declare function setPropertiesOnElementForAnimation(el: HTMLElement, styles: any, prefix?: string): void;
+export declare function prepareElementForVerticalAnimation(el: HTMLElement): void;
+export declare function cleanHtmlElementAfterAnimation(el: HTMLElement): void;
+export declare function floorTo2Decimals(number: number): number;
+export { mergeValues, updateListCssValues, getElementWidth, isContainerVisible, classesToSelector, compareVersions, confirmAction, confirmActionAsync, detectIEOrEdge, detectIEBrowser, loadFileFromBase64, isMobile, isShadowDOM, getElement, isElementVisible, findScrollableParent, activateLazyRenderingChecks, navigateToUrl, wrapUrlForBackgroundImage, createSvg, getIconNameFromProxy, increaseHeightByContent, getOriginalEvent, preventDefaults, findParentByClassNames, getFirstVisibleChild, chooseFiles, isBase64URL, renamedIcons };