@progress/kendo-angular-grid 21.4.1-develop.1 → 22.0.0-develop.1

package/esm2022/navigation/default-focusable-element.mjs

@@ -1,50 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { closest, findFocusable, isVisible, matchesNodeName } from '../rendering/common/dom-queries';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-const isButton = matchesNodeName('button');
-const isInputTag = matchesNodeName('input');
-const isKendoInputTag = matchesNodeName('kendo-checkbox') || matchesNodeName('kendo-textbox');
-const isAnchorTag = matchesNodeName('a');
-const navigableRegex = /(button|checkbox|color|file|radio|reset|submit)/i;
-const isNavigableInput = element => isInputTag(element) && navigableRegex.test(element.type);
-const isAnchor = element => isAnchorTag(element) && element.hasAttribute('href');
-const isNavigable = element => !element.disabled && (isButton(element) || isNavigableInput(element) || isKendoInputTag(element) || isAnchor(element));
-/**
- * @hidden
- */
-export class DefaultFocusableElement {
-    renderer;
-    get enabled() {
-        return this.focusable && !this.focusable.disabled;
-    }
-    get visible() {
-        return this.focusable && isVisible(this.focusable);
-    }
-    element;
-    focusable;
-    constructor(host, renderer) {
-        this.renderer = renderer;
-        this.element = host.nativeElement;
-        this.focusable = findFocusable(this.element, false) || this.element;
-    }
-    isNavigable() {
-        return this.canFocus() && isNavigable(this.element);
-    }
-    toggle(active) {
-        this.renderer.setAttribute(this.focusable, 'tabIndex', active ? '0' : '-1');
-    }
-    focus() {
-        if (this.focusable) {
-            this.focusable.focus();
-        }
-    }
-    canFocus() {
-        return this.visible && this.enabled;
-    }
-    hasFocus() {
-        return isDocumentAvailable() && document.activeElement !== this.element && closest(document.activeElement, e => e === this.element);
-    }
-}

package/esm2022/navigation/focus-group.mjs

@@ -1,73 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import { FocusRoot } from './focus-root';
-import * as i0 from "@angular/core";
-import * as i1 from "./focus-root";
-/**
- * @hidden
- */
-export class FocusGroup {
-    root;
-    active = true;
-    children = [];
-    get focusableChildren() {
-        return this.children.filter(el => el.canFocus());
-    }
-    get isActive() {
-        return this.active;
-    }
-    constructor(root) {
-        this.root = root;
-        this.root.registerGroup(this);
-    }
-    ngOnDestroy() {
-        this.root.unregisterGroup(this);
-        this.active = true;
-    }
-    registerElement(element) {
-        this.unregisterElement(element);
-        this.children.push(element);
-    }
-    unregisterElement(element) {
-        this.children = this.children.filter(f => f !== element);
-    }
-    /**
-     * Returns `true` if the group receives focus when the cell is focused.
-     * The group must have a single simple focusable element, like a button or checkbox.
-     */
-    isNavigable() {
-        const focusable = this.focusableChildren;
-        return focusable.length === 1 && focusable[0].isNavigable();
-    }
-    canFocus() {
-        return this.focusableChildren.length > 0;
-    }
-    focus() {
-        if (this.canFocus() && !this.hasFocus()) {
-            this.focusableChildren[0].focus();
-        }
-    }
-    activate() {
-        this.toggleState(true);
-    }
-    deactivate() {
-        this.toggleState(false);
-    }
-    hasFocus() {
-        return this.children.reduce((focused, element) => focused || element.hasFocus(), false);
-    }
-    toggleState(active) {
-        if (this.active !== active) {
-            this.active = active;
-            this.children.forEach(f => f.toggle(active));
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusGroup, deps: [{ token: i1.FocusRoot }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusGroup });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusGroup, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.FocusRoot }] });

package/esm2022/navigation/focus-root.mjs

@@ -1,50 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export const FOCUS_ROOT_ACTIVE = new InjectionToken('focus-root-initial-active-state');
-/**
- * @hidden
- */
-export class FocusRoot {
-    active;
-    groups = new Set();
-    constructor(active = false) {
-        this.active = active;
-    }
-    registerGroup(group) {
-        if (this.active) {
-            this.groups.add(group);
-        }
-    }
-    unregisterGroup(group) {
-        if (this.active) {
-            this.groups.delete(group);
-        }
-    }
-    activate() {
-        if (this.active) {
-            this.groups.forEach(f => f.activate());
-        }
-    }
-    deactivate() {
-        if (this.active) {
-            this.groups.forEach(f => f.deactivate());
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusRoot, deps: [{ token: FOCUS_ROOT_ACTIVE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusRoot });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusRoot, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [FOCUS_ROOT_ACTIVE]
-                }] }] });

package/esm2022/navigation/focusable-element.interface.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/navigation/focusable.directive.mjs

@@ -1,150 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Directive, ElementRef, Inject, Input, Optional, Renderer2, SkipSelf } from '@angular/core';
-import { DefaultFocusableElement } from './default-focusable-element';
-import { CELL_CONTEXT } from '../rendering/common/cell-context';
-import { ContextService } from '../common/provider.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../common/provider.service";
-/**
- * A directive that controls how focusable elements receive
- * focus in a navigable Grid. [See example]({% slug keyboard_navigation_grid %}).
- *
- * @example
- * ```html
- * <kendo-grid [data]="data" [navigable]="true">
- *    <kendo-grid-column>
- *       <ng-template kendoGridCellTemplate let-dataItem>
- *          <!-- The first focusable element is focused when you press Enter on the cell. -->
- *          <input type="text" kendoGridFocusable [value]="dataItem.ProductName" style="margin-right: 8px;" />
- *          <button kendoGridFocusable>Update</button>
- *       </ng-template>
- *    </kendo-grid-column>
- * </kendo-grid>
- * ```
- * @remarks
- * Applied to: {@link ButtonComponent}, {@link TextBoxComponent}, {@link NumericTextBoxComponent}, {@link DateInputComponent}, {@link DatePickerComponent}, {@link DateTimePicker}, {@link TextAreaComponent}, {@link ColorPickerComponent}, {@link DropDownListComponent}, {@link ComboBoxComponent}, {@link AutoCompleteComponent}.
- */
-export class FocusableDirective {
-    cellContext;
-    hostElement;
-    renderer;
-    ctx;
-    active = true;
-    group;
-    element;
-    _enabled = true;
-    /**
-     * @hidden
-     */
-    set enabled(value) {
-        if (value === '') {
-            value = true;
-        }
-        else {
-            value = Boolean(value);
-        }
-        if (value !== this.enabled) {
-            this._enabled = value;
-            if (this.element) {
-                this.element.toggle(this.active && value);
-            }
-        }
-    }
-    get enabled() {
-        return this._enabled;
-    }
-    constructor(cellContext, hostElement, renderer, ctx) {
-        this.cellContext = cellContext;
-        this.hostElement = hostElement;
-        this.renderer = renderer;
-        this.ctx = ctx;
-        if (this.cellContext) {
-            this.group = this.cellContext.focusGroup;
-        }
-        if (this.group) {
-            this.group.registerElement(this);
-        }
-    }
-    ngAfterViewInit() {
-        if (!this.element && this.ctx.navigable) {
-            this.element = new DefaultFocusableElement(this.hostElement, this.renderer);
-        }
-        if (this.group && this.element) {
-            this.toggle(this.group.isActive);
-        }
-    }
-    ngOnDestroy() {
-        if (this.group) {
-            this.group.unregisterElement(this);
-        }
-    }
-    /**
-     * @hidden
-     */
-    toggle(active) {
-        if (this.element && active !== this.active) {
-            this.element.toggle(this.enabled && active);
-            this.active = active;
-        }
-    }
-    /**
-     * @hidden
-     */
-    canFocus() {
-        return this.enabled && this.element && this.element.canFocus();
-    }
-    /**
-     * @hidden
-     */
-    isNavigable() {
-        return this.enabled && this.element && this.element.isNavigable();
-    }
-    /**
-     * @hidden
-     */
-    focus() {
-        if (this.enabled && this.element) {
-            this.element.focus();
-        }
-    }
-    /**
-     * @hidden
-     */
-    hasFocus() {
-        return this.enabled && this.element && this.element.hasFocus();
-    }
-    /**
-     * @hidden
-     */
-    registerElement(element) {
-        this.element = element;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusableDirective, deps: [{ token: CELL_CONTEXT, optional: true, skipSelf: true }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ContextService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: FocusableDirective, isStandalone: true, selector: "[kendoGridFocusable],\n        [kendoGridEditCommand],\n        [kendoGridRemoveCommand],\n        [kendoGridSaveCommand],\n        [kendoGridCancelCommand],\n        [kendoGridSelectionCheckbox]\n    ", inputs: { enabled: ["kendoGridFocusable", "enabled"] }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridFocusable]' + `,
-        [kendoGridEditCommand],
-        [kendoGridRemoveCommand],
-        [kendoGridSaveCommand],
-        [kendoGridCancelCommand],
-        [kendoGridSelectionCheckbox]
-    `,
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [CELL_CONTEXT]
-                }, {
-                    type: SkipSelf
-                }] }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ContextService }], propDecorators: { enabled: [{
-                type: Input,
-                args: ['kendoGridFocusable']
-            }] } });

package/esm2022/navigation/grid-focusable-element.mjs

@@ -1,28 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export class GridFocusableElement {
-    navigationService;
-    constructor(navigationService) {
-        this.navigationService = navigationService;
-    }
-    focus() {
-        this.navigationService.focusCell();
-    }
-    toggle(active) {
-        this.navigationService.toggle(active);
-    }
-    canFocus() {
-        return true;
-    }
-    hasFocus() {
-        return this.navigationService.hasFocus();
-    }
-    isNavigable() {
-        return false;
-    }
-}

package/esm2022/navigation/item-map.mjs

@@ -1,59 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export class ItemMap {
-    count = 0;
-    items = {};
-    get first() {
-        if (this.count > 0) {
-            let result;
-            this.forEach(item => {
-                result = item;
-                return true;
-            });
-            return result;
-        }
-    }
-    get last() {
-        if (this.count > 0) {
-            const keys = Object.keys(this.items);
-            return this.items[keys[keys.length - 1]];
-        }
-    }
-    removeItem(key) {
-        if (this.items[key]) {
-            delete this.items[key];
-            this.count--;
-        }
-    }
-    setItem(key, item) {
-        if (!this.items[key]) {
-            this.count++;
-        }
-        this.items[key] = item;
-    }
-    getItem(key) {
-        return this.items[key];
-    }
-    toArray() {
-        const result = [];
-        this.forEach(item => {
-            result.push(item);
-        });
-        return result;
-    }
-    forEach(callback) {
-        for (const key in this.items) {
-            if (this.items.hasOwnProperty(key) && callback(this.items[key])) {
-                return this.items[key];
-            }
-        }
-    }
-    find(callback) {
-        return this.forEach(callback);
-    }
-}

package/esm2022/navigation/logical-cell.directive.mjs

@@ -1,224 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Directive, ElementRef, HostBinding, Inject, Input, NgZone, Optional, Renderer2 } from '@angular/core';
-import { FocusGroup } from './focus-group';
-import { FocusRoot } from './focus-root';
-import { NavigationService } from './navigation.service';
-import { ColumnInfoService } from '../common/column-info.service';
-import { IdService } from '../common/id.service';
-import { CELL_CONTEXT } from '../rendering/common/cell-context';
-import * as i0 from "@angular/core";
-import * as i1 from "./focus-group";
-import * as i2 from "../common/column-info.service";
-import * as i3 from "../common/id.service";
-import * as i4 from "./navigation.service";
-let id = 0;
-function nextId() {
-    return id++;
-}
-/**
- * @hidden
- */
-export class LogicalCellDirective {
-    focusGroup;
-    element;
-    columnInfoService;
-    idService;
-    navigationService;
-    renderer;
-    zone;
-    cellContext;
-    logicalColIndex;
-    logicalRowIndex;
-    logicalSlaveCell = false;
-    colIndex;
-    colSpan = 1;
-    rowSpan = 1;
-    groupItem;
-    dataRowIndex = -1;
-    dataItem;
-    detailExpandCell = false;
-    headerLabelText;
-    uid = nextId();
-    get id() {
-        if (!this.logicalSlaveCell && this.columnInfoService.isLocked) {
-            return this.idService.cellId(this.logicalRowIndex, this.logicalColIndex);
-        }
-    }
-    get cellRowspan() {
-        return String(this.rowSpan);
-    }
-    get rowspanClass() {
-        return this.dataRowIndex > -1 && this.rowSpan > 1;
-    }
-    get ariaColIndex() {
-        if (this.logicalSlaveCell || this.logicalColIndex === -1) {
-            return undefined;
-        }
-        return this.logicalColIndex + 1;
-    }
-    navigationChange;
-    constructor(focusGroup, element, columnInfoService, idService, navigationService, renderer, zone, cellContext) {
-        this.focusGroup = focusGroup;
-        this.element = element;
-        this.columnInfoService = columnInfoService;
-        this.idService = idService;
-        this.navigationService = navigationService;
-        this.renderer = renderer;
-        this.zone = zone;
-        this.cellContext = cellContext;
-    }
-    ngOnInit() {
-        if (!this.navigationService.tableEnabled) {
-            return;
-        }
-        this.navigationChange = this.navigationService.changes.subscribe((e) => this.onNavigationChange(e));
-    }
-    ngDoCheck() {
-        if (!this.navigationService.tableEnabled || this.logicalColIndex === -1) {
-            return;
-        }
-        if (this.cellContext) {
-            this.cellContext.focusGroup = this.focusGroup;
-        }
-        this.registerNoChanges();
-    }
-    ngOnChanges(changes) {
-        if (!this.navigationService.tableEnabled) {
-            return;
-        }
-        const keys = Object.keys(changes);
-        if ((keys.length === 1 && keys[0] === 'groupItem') || this.logicalColIndex === -1) {
-            // Ignore groupItem changes as the reference is not stable
-            return;
-        }
-        const indexChange = changes['logicalColIndex'];
-        const rowIndexChange = changes['logicalRowIndex'];
-        const index = indexChange && !indexChange.isFirstChange() ? indexChange.previousValue : this.logicalColIndex;
-        const rowIndex = rowIndexChange && !rowIndexChange.isFirstChange() ? rowIndexChange.previousValue : this.logicalRowIndex;
-        this.navigationService.unregisterCell(index, rowIndex, this);
-        this.registerChanges();
-        this.updateElement();
-    }
-    ngOnDestroy() {
-        if (this.navigationChange) {
-            this.navigationChange.unsubscribe();
-        }
-        this.navigationService.unregisterCell(this.logicalColIndex, this.logicalRowIndex, this);
-    }
-    onNavigationChange(e) {
-        const active = this.logicalColIndex === e.colIndex && this.logicalRowIndex === e.rowIndex;
-        const wasActive = this.logicalColIndex === e.prevColIndex && this.logicalRowIndex === e.prevRowIndex;
-        if (active || wasActive) {
-            this.updateElement();
-        }
-    }
-    updateElement() {
-        const el = this.element.nativeElement;
-        this.renderer.setAttribute(el, 'tabIndex', this.isFocusable() && !this.logicalSlaveCell ? '0' : '-1');
-        if (this.isFocused()) {
-            if (this.focusGroup.isNavigable()) {
-                this.focusGroup.focus();
-            }
-            else {
-                if (!this.logicalSlaveCell &&
-                    this.navigationService.autoFocusCell(this.logicalColIndex, this.logicalColIndex + this.colSpan - 1)) {
-                    this.microtask(() => {
-                        if (this.isFocused()) {
-                            el.focus({ preventScroll: this.navigationService.preventScroll });
-                            this.navigationService.preventScroll = false;
-                        }
-                    });
-                }
-                this.renderer.addClass(el, 'k-focus');
-            }
-            if (this.headerLabelText) {
-                el.removeAttribute('aria-label');
-            }
-        }
-        else {
-            this.renderer.removeClass(el, 'k-focus');
-            if (this.headerLabelText) {
-                el.setAttribute('aria-label', this.headerLabelText);
-            }
-        }
-    }
-    microtask(callback) {
-        this.zone.runOutsideAngular(() => Promise.resolve(null).then(callback));
-    }
-    registerChanges() {
-        if (!this.logicalSlaveCell) {
-            this.navigationService.registerCell(this);
-        }
-    }
-    registerNoChanges() {
-        if (!this.logicalSlaveCell) {
-            this.navigationService.registerCellOnCurrentRow(this);
-        }
-    }
-    isFocusable() {
-        return this.navigationService.isCellFocusable(this);
-    }
-    isFocused() {
-        return this.navigationService.isCellFocused(this);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LogicalCellDirective, deps: [{ token: i1.FocusGroup }, { token: i0.ElementRef }, { token: i2.ColumnInfoService }, { token: i3.IdService }, { token: i4.NavigationService }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: CELL_CONTEXT, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: LogicalCellDirective, isStandalone: true, selector: "[kendoGridLogicalCell]", inputs: { logicalColIndex: "logicalColIndex", logicalRowIndex: "logicalRowIndex", logicalSlaveCell: "logicalSlaveCell", colIndex: "colIndex", colSpan: "colSpan", rowSpan: "rowSpan", groupItem: "groupItem", dataRowIndex: "dataRowIndex", dataItem: "dataItem", detailExpandCell: "detailExpandCell", headerLabelText: "headerLabelText" }, host: { properties: { "attr.id": "this.id", "attr.rowspan": "this.cellRowspan", "class.k-table-td-row-span": "this.rowspanClass", "attr.aria-colindex": "this.ariaColIndex" } }, providers: [{
-                provide: FocusGroup,
-                deps: [FocusRoot],
-                useClass: FocusGroup
-            }], usesOnChanges: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LogicalCellDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    providers: [{
-                            provide: FocusGroup,
-                            deps: [FocusRoot],
-                            useClass: FocusGroup
-                        }],
-                    selector: '[kendoGridLogicalCell]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.FocusGroup }, { type: i0.ElementRef }, { type: i2.ColumnInfoService }, { type: i3.IdService }, { type: i4.NavigationService }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [CELL_CONTEXT]
-                }] }], propDecorators: { logicalColIndex: [{
-                type: Input
-            }], logicalRowIndex: [{
-                type: Input
-            }], logicalSlaveCell: [{
-                type: Input
-            }], colIndex: [{
-                type: Input
-            }], colSpan: [{
-                type: Input
-            }], rowSpan: [{
-                type: Input
-            }], groupItem: [{
-                type: Input
-            }], dataRowIndex: [{
-                type: Input
-            }], dataItem: [{
-                type: Input
-            }], detailExpandCell: [{
-                type: Input
-            }], headerLabelText: [{
-                type: Input
-            }], id: [{
-                type: HostBinding,
-                args: ['attr.id']
-            }], cellRowspan: [{
-                type: HostBinding,
-                args: ['attr.rowspan']
-            }], rowspanClass: [{
-                type: HostBinding,
-                args: ['class.k-table-td-row-span']
-            }], ariaColIndex: [{
-                type: HostBinding,
-                args: ['attr.aria-colindex']
-            }] } });

package/esm2022/navigation/logical-cell.interface.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};