import { coerceNumberProperty, coerceCssPixelValue, coerceBooleanProperty } from '@angular/cdk/coercion';
import * as i0 from '@angular/core';
import { Directive, Input, EventEmitter, Component, ViewEncapsulation, ChangeDetectionStrategy, Output, ViewChildren, ViewChild, ContentChildren, forwardRef, inject, Inject, NgModule } from '@angular/core';
import { KBQ_WINDOW } from '@koobiq/components/core';
import { Subscription } from 'rxjs';
import { KbqIconModule } from '@koobiq/components/icon';

var Direction;
(function (Direction) {
    Direction["Horizontal"] = "horizontal";
    Direction["Vertical"] = "vertical";
})(Direction || (Direction = {}));
class KbqGutterDirective {
    get direction() {
        return this._direction;
    }
    set direction(direction) {
        this._direction = direction;
    }
    get order() {
        return this._order;
    }
    set order(order) {
        this._order = coerceNumberProperty(order);
    }
    get size() {
        return this._size;
    }
    set size(size) {
        this._size = coerceNumberProperty(size);
    }
    get isVertical() {
        return this._direction === Direction.Vertical;
    }
    constructor(elementRef, renderer) {
        this.elementRef = elementRef;
        this.renderer = renderer;
        this._direction = Direction.Vertical;
        this._order = 0;
        this._size = 6;
        this.dragged = false;
    }
    ngOnInit() {
        this.setStyle("flex-basis" /* StyleProperty.FlexBasis */, coerceCssPixelValue(this.size));
        this.setStyle(this.isVertical ? "height" /* StyleProperty.Height */ : "width" /* StyleProperty.Width */, coerceCssPixelValue(this.size));
        this.setStyle("order" /* StyleProperty.Order */, this.order);
        if (!this.isVertical) {
            this.setStyle("height" /* StyleProperty.Height */, '100%');
        }
        // fix IE issue with gutter icon. flex-direction is required for flex alignment options
        this.setStyle("flex-direction" /* StyleProperty.FlexDirection */, this.isVertical ? 'row' : 'column');
    }
    getPosition() {
        return {
            x: this.elementRef.nativeElement.offsetLeft,
            y: this.elementRef.nativeElement.offsetTop
        };
    }
    setStyle(property, value) {
        this.renderer.setStyle(this.elementRef.nativeElement, property, value);
    }
    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqGutterDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: KbqGutterDirective, selector: "kbq-gutter", inputs: { direction: "direction", order: "order", size: "size" }, host: { listeners: { "mousedown": "dragged = true" }, properties: { "class.kbq-gutter_vertical": "isVertical", "class.kbq-gutter_dragged": "dragged" }, classAttribute: "kbq-gutter" }, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqGutterDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: 'kbq-gutter',
                    host: {
                        class: 'kbq-gutter',
                        '[class.kbq-gutter_vertical]': 'isVertical',
                        '[class.kbq-gutter_dragged]': 'dragged',
                        '(mousedown)': 'dragged = true'
                    }
                }]
        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { direction: [{
                type: Input
            }], order: [{
                type: Input
            }], size: [{
                type: Input
            }] } });
class KbqGutterGhostDirective {
    get x() {
        return this._x;
    }
    set x(x) {
        this._x = x;
        this.setStyle("left" /* StyleProperty.Left */, coerceCssPixelValue(x));
    }
    get y() {
        return this._y;
    }
    set y(y) {
        this._y = y;
        this.setStyle("top" /* StyleProperty.Top */, coerceCssPixelValue(y));
    }
    get direction() {
        return this._direction;
    }
    set direction(direction) {
        this._direction = direction;
        this.updateDimensions();
    }
    get size() {
        return this._size;
    }
    set size(size) {
        this._size = coerceNumberProperty(size);
        this.updateDimensions();
    }
    get isVertical() {
        return this.direction === Direction.Vertical;
    }
    constructor(elementRef, renderer) {
        this.elementRef = elementRef;
        this.renderer = renderer;
        this._x = 0;
        this._y = 0;
        this._direction = Direction.Vertical;
        this._size = 6;
    }
    updateDimensions() {
        this.setStyle(this.isVertical ? "width" /* StyleProperty.Width */ : "height" /* StyleProperty.Height */, '100%');
        this.setStyle(this.isVertical ? "height" /* StyleProperty.Height */ : "width" /* StyleProperty.Width */, coerceCssPixelValue(this.size));
    }
    setStyle(property, value) {
        this.renderer.setStyle(this.elementRef.nativeElement, property, value);
    }
    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqGutterGhostDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: KbqGutterGhostDirective, selector: "kbq-gutter-ghost", inputs: { visible: "visible", x: "x", y: "y", direction: "direction", size: "size" }, host: { properties: { "class.kbq-gutter-ghost_vertical": "isVertical", "class.kbq-gutter-ghost_visible": "visible" }, classAttribute: "kbq-gutter-ghost" }, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqGutterGhostDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: 'kbq-gutter-ghost',
                    host: {
                        class: 'kbq-gutter-ghost',
                        '[class.kbq-gutter-ghost_vertical]': 'isVertical',
                        '[class.kbq-gutter-ghost_visible]': 'visible'
                    }
                }]
        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { visible: [{
                type: Input
            }], x: [{
                type: Input
            }], y: [{
                type: Input
            }], direction: [{
                type: Input
            }], size: [{
                type: Input
            }] } });
class KbqSplitterComponent {
    get isDragging() {
        return this._isDragging;
    }
    get hideGutters() {
        return this._hideGutters;
    }
    set hideGutters(value) {
        this._hideGutters = coerceBooleanProperty(value);
    }
    get direction() {
        return this._direction;
    }
    set direction(direction) {
        this._direction = direction;
    }
    get disabled() {
        return this._disabled;
    }
    set disabled(disabled) {
        this._disabled = coerceBooleanProperty(disabled);
    }
    get useGhost() {
        return this._useGhost;
    }
    set useGhost(useGhost) {
        this._useGhost = coerceBooleanProperty(useGhost);
    }
    get gutterSize() {
        return this._gutterSize;
    }
    set gutterSize(gutterSize) {
        const size = coerceNumberProperty(gutterSize);
        this._gutterSize = size > 0 ? size : this.gutterSize;
    }
    get resizing() {
        return this._resizing;
    }
    constructor(elementRef, changeDetectorRef, ngZone, renderer) {
        this.elementRef = elementRef;
        this.changeDetectorRef = changeDetectorRef;
        this.ngZone = ngZone;
        this.renderer = renderer;
        this.gutterPositionChange = new EventEmitter();
        this.areas = [];
        this._isDragging = false;
        this.areaPositionDivider = 2;
        this.listeners = [];
        this.areasChangeSubscription = Subscription.EMPTY;
        this._hideGutters = false;
        this._disabled = false;
        this._useGhost = false;
        this._gutterSize = 6;
        this._resizing = false;
        this.mapAndOrderArea = (area, index) => {
            const order = index * this.areaPositionDivider;
            area.setOrder(order);
            return {
                area,
                index,
                order,
                initialSize: area.getSize()
            };
        };
    }
    addArea(area) {
        this.areas.push(this.mapAndOrderArea(area, this.areas.length));
        this.changeDetectorRef.detectChanges();
    }
    ngOnInit() {
        if (!this.direction) {
            this.direction = Direction.Horizontal;
        }
        this.setStyle("flex-direction" /* StyleProperty.FlexDirection */, this.isVertical() ? 'column' : 'row');
    }
    ngAfterContentInit() {
        this.areasChangeSubscription = this.areaRefs.changes.subscribe((data) => {
            this.areas = data.map(this.mapAndOrderArea);
            this.changeDetectorRef.markForCheck();
        });
    }
    ngOnDestroy() {
        this.areasChangeSubscription.unsubscribe();
    }
    onMouseDown(event, leftAreaIndex, rightAreaIndex) {
        if (this.disabled) {
            return;
        }
        event.preventDefault();
        const startPoint = {
            x: event.screenX,
            y: event.screenY
        };
        const leftArea = this.areas[leftAreaIndex];
        const rightArea = this.areas[rightAreaIndex];
        leftArea.initialSize = leftArea.area.getSize();
        rightArea.initialSize = rightArea.area.getSize();
        let currentGutter;
        if (this.useGhost) {
            const gutterOrder = leftAreaIndex * 2 + 1;
            currentGutter = this.gutters.find((gutter) => gutter.order === gutterOrder);
            if (currentGutter) {
                const gutterPosition = currentGutter.getPosition();
                this.ghost.direction = currentGutter.direction;
                this.ghost.size = currentGutter.size;
                this.ghost.x = gutterPosition.x;
                this.ghost.y = gutterPosition.y;
                this.ghost.visible = true;
                this.setStyle("cursor" /* StyleProperty.Cursor */, currentGutter.direction === Direction.Vertical ? 'row-resize' : 'col-resize');
            }
        }
        else {
            this.areas.forEach((item) => {
                const size = item.area.getSize();
                item.area.disableFlex();
                item.area.setSize(size);
            });
        }
        this.listeners.push(this.renderer.listen('document', 'mouseup', () => this.onMouseUp(leftArea, rightArea, currentGutter)));
        this.ngZone.runOutsideAngular(() => {
            this.listeners.push(this.renderer.listen('document', 'mousemove', (e) => this.onMouseMove(e, startPoint, leftArea, rightArea, currentGutter)));
        });
        this._isDragging = true;
    }
    removeArea(area) {
        let indexToRemove = -1;
        this.areas.some((item, index) => {
            if (item.area === area) {
                indexToRemove = index;
                return true;
            }
            return false;
        });
        if (indexToRemove === -1) {
            return;
        }
        this.areas.splice(indexToRemove, 1);
    }
    isVertical() {
        return this.direction === Direction.Vertical;
    }
    updateGutter() {
        this.gutters.forEach((gutter) => {
            if (gutter.dragged) {
                gutter.dragged = false;
                this.changeDetectorRef.detectChanges();
            }
        });
    }
    onMouseMove(event, startPoint, leftArea, rightArea, currentGutter) {
        if (!this.isDragging || this.disabled) {
            return;
        }
        const endPoint = {
            x: event.screenX,
            y: event.screenY
        };
        const offset = this.isVertical() ? startPoint.y - endPoint.y : startPoint.x - endPoint.x;
        if (this.useGhost && currentGutter) {
            const gutterPosition = currentGutter.getPosition();
            const leftPos = leftArea.area.getPosition();
            const rightPos = rightArea.area.getPosition();
            const rightMin = rightArea.area.getMinSize() || 0;
            const leftMin = leftArea.area.getMinSize() || 0;
            const key = this.isVertical() ? 'y' : 'x';
            const minPos = leftPos[key] - leftMin;
            const maxPos = rightPos[key] + (rightArea.area.getSize() || 0) - rightMin - currentGutter.size;
            const newPos = gutterPosition[key] - offset;
            this.ghost[key] = newPos < minPos ? minPos : Math.min(newPos, maxPos);
        }
        else {
            this.resizeAreas(leftArea, rightArea, offset);
        }
    }
    resizeAreas(leftArea, rightArea, sizeOffset) {
        const newLeftAreaSize = leftArea.initialSize - sizeOffset;
        const newRightAreaSize = rightArea.initialSize + sizeOffset;
        const minLeftAreaSize = leftArea.area.getMinSize();
        const minRightAreaSize = rightArea.area.getMinSize();
        if (newLeftAreaSize < minLeftAreaSize || newRightAreaSize < minRightAreaSize) {
            return;
        }
        else if (newLeftAreaSize <= 0) {
            leftArea.area.setSize(0);
            rightArea.area.setSize(rightArea.initialSize + leftArea.initialSize);
        }
        else if (newRightAreaSize <= 0) {
            leftArea.area.setSize(rightArea.initialSize + leftArea.initialSize);
            rightArea.area.setSize(0);
        }
        else {
            leftArea.area.setSize(newLeftAreaSize);
            rightArea.area.setSize(newRightAreaSize);
        }
    }
    onMouseUp(leftArea, rightArea, currentGutter) {
        while (this.listeners.length > 0) {
            const unsubscribe = this.listeners.pop();
            if (unsubscribe) {
                unsubscribe();
            }
        }
        if (this.useGhost && currentGutter) {
            const gutterPosition = currentGutter.getPosition();
            const offset = this.ghost.direction === Direction.Vertical
                ? gutterPosition.y - this.ghost.y
                : gutterPosition.x - this.ghost.x;
            this.resizeAreas(leftArea, rightArea, offset);
            this.ghost.visible = false;
            this.setStyle("cursor" /* StyleProperty.Cursor */, 'unset');
        }
        this._isDragging = false;
        this.updateGutter();
        this.gutterPositionChange.emit();
        this.changeDetectorRef.markForCheck();
    }
    setStyle(property, value) {
        this.renderer.setStyle(this.elementRef.nativeElement, property, value);
    }
    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: KbqSplitterComponent, selector: "kbq-splitter", inputs: { hideGutters: "hideGutters", direction: "direction", disabled: "disabled", useGhost: "useGhost", gutterSize: "gutterSize" }, outputs: { gutterPositionChange: "gutterPositionChange" }, host: { classAttribute: "kbq-splitter" }, queries: [{ propertyName: "areaRefs", predicate: i0.forwardRef(() => KbqSplitterAreaDirective) }], viewQueries: [{ propertyName: "ghost", first: true, predicate: KbqGutterGhostDirective, descendants: true }, { propertyName: "gutters", predicate: KbqGutterDirective, descendants: true }], exportAs: ["kbqSplitter"], ngImport: i0, template: "<ng-content />\n\n@for (area of areas; track area; let index = $index; let last = $last) {\n    @if (last === false) {\n        <kbq-gutter\n            [attr.disabled]=\"disabled || null\"\n            [direction]=\"direction\"\n            [order]=\"index * 2 + 1\"\n            [size]=\"gutterSize\"\n            [style.display]=\"hideGutters ? 'none' : 'flex'\"\n            (mousedown)=\"onMouseDown($event, index, index + 1)\"\n        />\n    }\n}\n\n@if (useGhost) {\n    <kbq-gutter-ghost />\n}\n", styles: [".kbq-splitter{display:flex;position:relative;flex-wrap:nowrap;align-items:stretch;overflow:hidden}.kbq-splitter .kbq-splitter-area{overflow:hidden}.kbq-splitter .kbq-splitter-area_resizing{pointer-events:none}.kbq-gutter{display:flex;flex-grow:0;flex-shrink:0;justify-content:center;align-items:center;overflow:hidden}.kbq-gutter.kbq-gutter_vertical>.kbq-icon{transform:rotate(90deg)}.kbq-gutter-ghost{position:absolute;z-index:999;display:none;overflow:hidden}.kbq-gutter-ghost.kbq-gutter-ghost_vertical>.kbq-icon{transform:rotate(90deg)}.kbq-gutter-ghost.kbq-gutter-ghost_visible{display:block}.kbq-gutter{cursor:col-resize}.kbq-gutter:hover,.kbq-gutter.kbq-gutter_dragged{background-color:#6a739614}.kbq-gutter.kbq-gutter_vertical{cursor:row-resize}.kbq-gutter[disabled]{background-color:var(--kbq-states-background-disabled);cursor:default}.kbq-gutter-ghost{background:#6a739629}\n"], dependencies: [{ kind: "directive", type: KbqGutterDirective, selector: "kbq-gutter", inputs: ["direction", "order", "size"] }, { kind: "directive", type: KbqGutterGhostDirective, selector: "kbq-gutter-ghost", inputs: ["visible", "x", "y", "direction", "size"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterComponent, decorators: [{
            type: Component,
            args: [{ selector: 'kbq-splitter', exportAs: 'kbqSplitter', host: {
                        class: 'kbq-splitter'
                    }, preserveWhitespaces: false, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content />\n\n@for (area of areas; track area; let index = $index; let last = $last) {\n    @if (last === false) {\n        <kbq-gutter\n            [attr.disabled]=\"disabled || null\"\n            [direction]=\"direction\"\n            [order]=\"index * 2 + 1\"\n            [size]=\"gutterSize\"\n            [style.display]=\"hideGutters ? 'none' : 'flex'\"\n            (mousedown)=\"onMouseDown($event, index, index + 1)\"\n        />\n    }\n}\n\n@if (useGhost) {\n    <kbq-gutter-ghost />\n}\n", styles: [".kbq-splitter{display:flex;position:relative;flex-wrap:nowrap;align-items:stretch;overflow:hidden}.kbq-splitter .kbq-splitter-area{overflow:hidden}.kbq-splitter .kbq-splitter-area_resizing{pointer-events:none}.kbq-gutter{display:flex;flex-grow:0;flex-shrink:0;justify-content:center;align-items:center;overflow:hidden}.kbq-gutter.kbq-gutter_vertical>.kbq-icon{transform:rotate(90deg)}.kbq-gutter-ghost{position:absolute;z-index:999;display:none;overflow:hidden}.kbq-gutter-ghost.kbq-gutter-ghost_vertical>.kbq-icon{transform:rotate(90deg)}.kbq-gutter-ghost.kbq-gutter-ghost_visible{display:block}.kbq-gutter{cursor:col-resize}.kbq-gutter:hover,.kbq-gutter.kbq-gutter_dragged{background-color:#6a739614}.kbq-gutter.kbq-gutter_vertical{cursor:row-resize}.kbq-gutter[disabled]{background-color:var(--kbq-states-background-disabled);cursor:default}.kbq-gutter-ghost{background:#6a739629}\n"] }]
        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i0.Renderer2 }], propDecorators: { gutterPositionChange: [{
                type: Output
            }], gutters: [{
                type: ViewChildren,
                args: [KbqGutterDirective]
            }], ghost: [{
                type: ViewChild,
                args: [KbqGutterGhostDirective]
            }], areaRefs: [{
                type: ContentChildren,
                args: [forwardRef(() => KbqSplitterAreaDirective)]
            }], hideGutters: [{
                type: Input
            }], direction: [{
                type: Input
            }], disabled: [{
                type: Input
            }], useGhost: [{
                type: Input
            }], gutterSize: [{
                type: Input
            }] } });
class KbqSplitterAreaDirective {
    constructor(elementRef, renderer, splitter) {
        this.elementRef = elementRef;
        this.renderer = renderer;
        this.splitter = splitter;
        this.sizeChange = new EventEmitter();
        this.window = inject(KBQ_WINDOW);
        this.emitSizeChange = () => {
            this.sizeChange.emit(this.getSize());
        };
    }
    isResizing() {
        return this.splitter.isDragging;
    }
    disableFlex() {
        this.renderer.removeStyle(this.elementRef.nativeElement, 'flex');
    }
    ngAfterViewInit() {
        this.splitter.addArea(this);
        this.removeStyle("max-width" /* StyleProperty.MaxWidth */);
        if (this.splitter.direction === Direction.Vertical) {
            this.setStyle("width" /* StyleProperty.Width */, '100%');
            this.removeStyle("height" /* StyleProperty.Height */);
        }
        else {
            this.setStyle("height" /* StyleProperty.Height */, '100%');
            this.removeStyle("width" /* StyleProperty.Width */);
        }
        this.splitter.gutterPositionChange.subscribe(this.emitSizeChange);
    }
    ngOnDestroy() {
        this.splitter.removeArea(this);
    }
    setOrder(order) {
        this.setStyle("order" /* StyleProperty.Order */, order);
    }
    setSize(size) {
        if (isNaN(size)) {
            return;
        }
        this.setStyle(this.getSizeProperty(), coerceCssPixelValue(coerceNumberProperty(size)));
    }
    getSize() {
        return this.elementRef.nativeElement[this.getOffsetSizeProperty()];
    }
    getPosition() {
        return {
            x: this.elementRef.nativeElement.offsetLeft,
            y: this.elementRef.nativeElement.offsetTop
        };
    }
    getMinSize() {
        const styles = this.window.getComputedStyle(this.elementRef.nativeElement);
        return parseFloat(styles[this.getMinSizeProperty()]);
    }
    isVertical() {
        return this.splitter.direction === Direction.Vertical;
    }
    getMinSizeProperty() {
        return this.isVertical() ? "min-height" /* StyleProperty.MinHeight */ : "minWidth" /* StyleProperty.MinWidth */;
    }
    getOffsetSizeProperty() {
        return this.isVertical() ? "offsetHeight" /* StyleProperty.OffsetHeight */ : "offsetWidth" /* StyleProperty.OffsetWidth */;
    }
    getSizeProperty() {
        return this.isVertical() ? "height" /* StyleProperty.Height */ : "width" /* StyleProperty.Width */;
    }
    setStyle(style, value) {
        this.renderer.setStyle(this.elementRef.nativeElement, style, value);
    }
    removeStyle(style) {
        this.renderer.removeStyle(this.elementRef.nativeElement, style);
    }
    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterAreaDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: forwardRef(() => KbqSplitterComponent) }], target: i0.ɵɵFactoryTarget.Directive }); }
    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: KbqSplitterAreaDirective, selector: "[kbq-splitter-area]", outputs: { sizeChange: "sizeChange" }, host: { properties: { "class.kbq-splitter-area_resizing": "isResizing()" }, classAttribute: "kbq-splitter-area" }, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterAreaDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[kbq-splitter-area]',
                    host: {
                        class: 'kbq-splitter-area',
                        '[class.kbq-splitter-area_resizing]': 'isResizing()'
                    }
                }]
        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: KbqSplitterComponent, decorators: [{
                    type: Inject,
                    args: [forwardRef(() => KbqSplitterComponent)]
                }] }], propDecorators: { sizeChange: [{
                type: Output
            }] } });

class KbqSplitterModule {
    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterModule, declarations: [KbqGutterDirective,
            KbqGutterGhostDirective,
            KbqSplitterAreaDirective,
            KbqSplitterComponent], imports: [KbqIconModule], exports: [KbqGutterDirective,
            KbqSplitterAreaDirective,
            KbqSplitterComponent] }); }
    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterModule, imports: [KbqIconModule] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqSplitterModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [
                        KbqIconModule
                    ],
                    exports: [
                        KbqGutterDirective,
                        KbqSplitterAreaDirective,
                        KbqSplitterComponent
                    ],
                    declarations: [
                        KbqGutterDirective,
                        KbqGutterGhostDirective,
                        KbqSplitterAreaDirective,
                        KbqSplitterComponent
                    ]
                }]
        }] });

/**
 * Generated bundle index. Do not edit.
 */

export { Direction, KbqGutterDirective, KbqGutterGhostDirective, KbqSplitterAreaDirective, KbqSplitterComponent, KbqSplitterModule };
//# sourceMappingURL=koobiq-components-splitter.mjs.map
