@haiilo/catalyst 11.0.0 → 12.0.0

package/dist/components/cat-scrollable2.js

@@ -1,549 +1,317 @@
 import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
-import { c as createErrorClass, O as Observable, e as errorContext, E as EMPTY_SUBSCRIPTION, S as Subscription, a as arrRemove, o as operate, b as createOperatorSubscriber, i as innerFrom, d as executeSchedule, g as isFunction, h as identity, j as isArrayLike, k as isScheduler, f as from, p as popScheduler, l as popNumber, n as noop } from './from.js';
+import { r as requireNot, a as requireFilter, b as requireArgsOrArgArray, d as requireRaceWith, e as requireAudit, f as requireAuditTime, g as requireBuffer, h as requireBufferCount, i as requireBufferTime, j as requireBufferToggle, k as requireBufferWhen, l as requireCatchError, m as requireCombineAll, n as requireCombineLatestAll, o as requireCombineLatest, p as requireCombineLatestWith, q as requireConcat, s as requireConcatAll, t as requireConcatMap, u as requireConcatMapTo, v as requireConcatWith, w as requireConnect, x as requireCount, y as requireDebounce, z as requireDebounceTime, A as requireDefaultIfEmpty, B as requireDelay, C as requireDelayWhen, D as requireDematerialize, E as requireDistinct, F as requireDistinctUntilChanged, G as requireDistinctUntilKeyChanged, H as requireElementAt, I as requireEndWith, J as requireEvery, K as requireExhaust, L as requireExhaustAll, M as requireExhaustMap, N as requireExpand, O as requireFinalize, P as requireFind, Q as requireFindIndex, R as requireFirst, S as requireGroupBy, T as requireIgnoreElements, U as requireIsEmpty, V as requireLast, W as requireMap, X as requireMapTo, Y as requireMaterialize, Z as requireMax, _ as requireMerge, $ as requireMergeAll, a0 as requireFlatMap, a1 as requireMergeMap, a2 as requireMergeMapTo, a3 as requireMergeScan, a4 as requireMergeWith, a5 as requireMin, a6 as requireMulticast, a7 as requireObserveOn, a8 as requireOnErrorResumeNextWith, a9 as requirePairwise, aa as requirePluck, ab as requirePublish, ac as requirePublishBehavior, ad as requirePublishLast, ae as requirePublishReplay, af as requireReduce, ag as requireRepeat, ah as requireRepeatWhen, ai as requireRetry, aj as requireRetryWhen, ak as requireRefCount, al as requireSample, am as requireSampleTime, an as requireScan, ao as requireSequenceEqual, ap as requireShare, aq as requireShareReplay, ar as requireSingle, as as requireSkip, at as requireSkipLast, au as requireSkipUntil, av as requireSkipWhile, aw as requireStartWith, ax as requireSubscribeOn, ay as requireSwitchAll, az as requireSwitchMap, aA as requireSwitchMapTo, aB as requireSwitchScan, aC as requireTake, aD as requireTakeLast, aE as requireTakeUntil, aF as requireTakeWhile, aG as requireTap, aH as requireThrottle, aI as requireThrottleTime, aJ as requireThrowIfEmpty, aK as requireTimeInterval, aL as requireTimeout, aM as requireTimeoutWith, aN as requireTimestamp, aO as requireToArray, aP as requireWindow, aQ as requireWindowCount, aR as requireWindowTime, aS as requireWindowToggle, aT as requireWindowWhen, aU as requireWithLatestFrom, aV as requireZip, aW as requireZipAll, aX as requireZipWith, c as cjsExports } from './index2.js';
 
-const ObjectUnsubscribedError = createErrorClass((_super) => function ObjectUnsubscribedErrorImpl() {
-    _super(this);
-    this.name = 'ObjectUnsubscribedError';
-    this.message = 'object unsubscribed';
-});
+var operators = {};
 
-class Subject extends Observable {
-    constructor() {
-        super();
-        this.closed = false;
-        this.currentObservers = null;
-        this.observers = [];
-        this.isStopped = false;
-        this.hasError = false;
-        this.thrownError = null;
-    }
-    lift(operator) {
-        const subject = new AnonymousSubject(this, this);
-        subject.operator = operator;
-        return subject;
-    }
-    _throwIfClosed() {
-        if (this.closed) {
-            throw new ObjectUnsubscribedError();
-        }
-    }
-    next(value) {
-        errorContext(() => {
-            this._throwIfClosed();
-            if (!this.isStopped) {
-                if (!this.currentObservers) {
-                    this.currentObservers = Array.from(this.observers);
-                }
-                for (const observer of this.currentObservers) {
-                    observer.next(value);
-                }
-            }
-        });
-    }
-    error(err) {
-        errorContext(() => {
-            this._throwIfClosed();
-            if (!this.isStopped) {
-                this.hasError = this.isStopped = true;
-                this.thrownError = err;
-                const { observers } = this;
-                while (observers.length) {
-                    observers.shift().error(err);
-                }
-            }
-        });
-    }
-    complete() {
-        errorContext(() => {
-            this._throwIfClosed();
-            if (!this.isStopped) {
-                this.isStopped = true;
-                const { observers } = this;
-                while (observers.length) {
-                    observers.shift().complete();
-                }
-            }
-        });
-    }
-    unsubscribe() {
-        this.isStopped = this.closed = true;
-        this.observers = this.currentObservers = null;
-    }
-    get observed() {
-        var _a;
-        return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
-    }
-    _trySubscribe(subscriber) {
-        this._throwIfClosed();
-        return super._trySubscribe(subscriber);
-    }
-    _subscribe(subscriber) {
-        this._throwIfClosed();
-        this._checkFinalizedStatuses(subscriber);
-        return this._innerSubscribe(subscriber);
-    }
-    _innerSubscribe(subscriber) {
-        const { hasError, isStopped, observers } = this;
-        if (hasError || isStopped) {
-            return EMPTY_SUBSCRIPTION;
-        }
-        this.currentObservers = null;
-        observers.push(subscriber);
-        return new Subscription(() => {
-            this.currentObservers = null;
-            arrRemove(observers, subscriber);
-        });
-    }
-    _checkFinalizedStatuses(subscriber) {
-        const { hasError, thrownError, isStopped } = this;
-        if (hasError) {
-            subscriber.error(thrownError);
-        }
-        else if (isStopped) {
-            subscriber.complete();
-        }
-    }
-    asObservable() {
-        const observable = new Observable();
-        observable.source = this;
-        return observable;
-    }
-}
-Subject.create = (destination, source) => {
-    return new AnonymousSubject(destination, source);
-};
-class AnonymousSubject extends Subject {
-    constructor(destination, source) {
-        super();
-        this.destination = destination;
-        this.source = source;
-    }
-    next(value) {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
-    }
-    error(err) {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
-    }
-    complete() {
-        var _a, _b;
-        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
-    }
-    _subscribe(subscriber) {
-        var _a, _b;
-        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
-    }
-}
-
-const dateTimestampProvider = {
-    now() {
-        return (dateTimestampProvider.delegate || Date).now();
-    },
-    delegate: undefined,
-};
-
-class Action extends Subscription {
-    constructor(scheduler, work) {
-        super();
-    }
-    schedule(state, delay = 0) {
-        return this;
-    }
-}
-
-const intervalProvider = {
-    setInterval(handler, timeout, ...args) {
-        const { delegate } = intervalProvider;
-        if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
-            return delegate.setInterval(handler, timeout, ...args);
-        }
-        return setInterval(handler, timeout, ...args);
-    },
-    clearInterval(handle) {
-        const { delegate } = intervalProvider;
-        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
-    },
-    delegate: undefined,
-};
-
-class AsyncAction extends Action {
-    constructor(scheduler, work) {
-        super(scheduler, work);
-        this.scheduler = scheduler;
-        this.work = work;
-        this.pending = false;
-    }
-    schedule(state, delay = 0) {
-        var _a;
-        if (this.closed) {
-            return this;
-        }
-        this.state = state;
-        const id = this.id;
-        const scheduler = this.scheduler;
-        if (id != null) {
-            this.id = this.recycleAsyncId(scheduler, id, delay);
-        }
-        this.pending = true;
-        this.delay = delay;
-        this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
-        return this;
-    }
-    requestAsyncId(scheduler, _id, delay = 0) {
-        return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
-    }
-    recycleAsyncId(_scheduler, id, delay = 0) {
-        if (delay != null && this.delay === delay && this.pending === false) {
-            return id;
-        }
-        if (id != null) {
-            intervalProvider.clearInterval(id);
-        }
-        return undefined;
-    }
-    execute(state, delay) {
-        if (this.closed) {
-            return new Error('executing a cancelled action');
-        }
-        this.pending = false;
-        const error = this._execute(state, delay);
-        if (error) {
-            return error;
-        }
-        else if (this.pending === false && this.id != null) {
-            this.id = this.recycleAsyncId(this.scheduler, this.id, null);
-        }
-    }
-    _execute(state, _delay) {
-        let errored = false;
-        let errorValue;
-        try {
-            this.work(state);
-        }
-        catch (e) {
-            errored = true;
-            errorValue = e ? e : new Error('Scheduled action threw falsy error');
-        }
-        if (errored) {
-            this.unsubscribe();
-            return errorValue;
-        }
-    }
-    unsubscribe() {
-        if (!this.closed) {
-            const { id, scheduler } = this;
-            const { actions } = scheduler;
-            this.work = this.state = this.scheduler = null;
-            this.pending = false;
-            arrRemove(actions, this);
-            if (id != null) {
-                this.id = this.recycleAsyncId(scheduler, id, null);
-            }
-            this.delay = null;
-            super.unsubscribe();
-        }
-    }
-}
-
-class Scheduler {
-    constructor(schedulerActionCtor, now = Scheduler.now) {
-        this.schedulerActionCtor = schedulerActionCtor;
-        this.now = now;
-    }
-    schedule(work, delay = 0, state) {
-        return new this.schedulerActionCtor(this, work).schedule(state, delay);
-    }
-}
-Scheduler.now = dateTimestampProvider.now;
-
-class AsyncScheduler extends Scheduler {
-    constructor(SchedulerAction, now = Scheduler.now) {
-        super(SchedulerAction, now);
-        this.actions = [];
-        this._active = false;
-    }
-    flush(action) {
-        const { actions } = this;
-        if (this._active) {
-            actions.push(action);
-            return;
-        }
-        let error;
-        this._active = true;
-        do {
-            if ((error = action.execute(action.state, action.delay))) {
-                break;
-            }
-        } while ((action = actions.shift()));
-        this._active = false;
-        if (error) {
-            while ((action = actions.shift())) {
-                action.unsubscribe();
-            }
-            throw error;
-        }
-    }
-}
-
-const asyncScheduler = new AsyncScheduler(AsyncAction);
-const async = asyncScheduler;
-
-const EMPTY = new Observable((subscriber) => subscriber.complete());
-
-function isValidDate(value) {
-    return value instanceof Date && !isNaN(value);
-}
-
-function map(project, thisArg) {
-    return operate((source, subscriber) => {
-        let index = 0;
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
-            subscriber.next(project.call(thisArg, value, index++));
-        }));
-    });
-}
-
-const { isArray } = Array;
-function callOrApply(fn, args) {
-    return isArray(args) ? fn(...args) : fn(args);
-}
-function mapOneOrManyArgs(fn) {
-    return map(args => callOrApply(fn, args));
-}
-
-function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
-    const buffer = [];
-    let active = 0;
-    let index = 0;
-    let isComplete = false;
-    const checkComplete = () => {
-        if (isComplete && !buffer.length && !active) {
-            subscriber.complete();
-        }
-    };
-    const outerNext = (value) => (active < concurrent ? doInnerSub(value) : buffer.push(value));
-    const doInnerSub = (value) => {
-        expand && subscriber.next(value);
-        active++;
-        let innerComplete = false;
-        innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, (innerValue) => {
-            onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
-            if (expand) {
-                outerNext(innerValue);
-            }
-            else {
-                subscriber.next(innerValue);
-            }
-        }, () => {
-            innerComplete = true;
-        }, undefined, () => {
-            if (innerComplete) {
-                try {
-                    active--;
-                    while (buffer.length && active < concurrent) {
-                        const bufferedValue = buffer.shift();
-                        if (innerSubScheduler) {
-                            executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue));
-                        }
-                        else {
-                            doInnerSub(bufferedValue);
-                        }
-                    }
-                    checkComplete();
-                }
-                catch (err) {
-                    subscriber.error(err);
-                }
-            }
-        }));
-    };
-    source.subscribe(createOperatorSubscriber(subscriber, outerNext, () => {
-        isComplete = true;
-        checkComplete();
-    }));
-    return () => {
-        additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
-    };
-}
+var partition = {};
 
-function mergeMap(project, resultSelector, concurrent = Infinity) {
-    if (isFunction(resultSelector)) {
-        return mergeMap((a, i) => map((b, ii) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent);
-    }
-    else if (typeof resultSelector === 'number') {
-        concurrent = resultSelector;
-    }
-    return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent));
-}
-
-function mergeAll(concurrent = Infinity) {
-    return mergeMap(identity, concurrent);
-}
-
-const nodeEventEmitterMethods = ['addListener', 'removeListener'];
-const eventTargetMethods = ['addEventListener', 'removeEventListener'];
-const jqueryMethods = ['on', 'off'];
-function fromEvent(target, eventName, options, resultSelector) {
-    if (isFunction(options)) {
-        resultSelector = options;
-        options = undefined;
-    }
-    if (resultSelector) {
-        return fromEvent(target, eventName, options).pipe(mapOneOrManyArgs(resultSelector));
-    }
-    const [add, remove] = isEventTarget(target)
-        ? eventTargetMethods.map((methodName) => (handler) => target[methodName](eventName, handler, options))
-        :
-            isNodeStyleEventEmitter(target)
-                ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName))
-                : isJQueryStyleEventEmitter(target)
-                    ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName))
-                    : [];
-    if (!add) {
-        if (isArrayLike(target)) {
-            return mergeMap((subTarget) => fromEvent(subTarget, eventName, options))(innerFrom(target));
-        }
-    }
-    if (!add) {
-        throw new TypeError('Invalid event target');
-    }
-    return new Observable((subscriber) => {
-        const handler = (...args) => subscriber.next(1 < args.length ? args : args[0]);
-        add(handler);
-        return () => remove(handler);
-    });
-}
-function toCommonHandlerRegistry(target, eventName) {
-    return (methodName) => (handler) => target[methodName](eventName, handler);
-}
-function isNodeStyleEventEmitter(target) {
-    return isFunction(target.addListener) && isFunction(target.removeListener);
-}
-function isJQueryStyleEventEmitter(target) {
-    return isFunction(target.on) && isFunction(target.off);
-}
-function isEventTarget(target) {
-    return isFunction(target.addEventListener) && isFunction(target.removeEventListener);
-}
+var hasRequiredPartition;
 
-function timer(dueTime = 0, intervalOrScheduler, scheduler = async) {
-    let intervalDuration = -1;
-    if (intervalOrScheduler != null) {
-        if (isScheduler(intervalOrScheduler)) {
-            scheduler = intervalOrScheduler;
-        }
-        else {
-            intervalDuration = intervalOrScheduler;
-        }
-    }
-    return new Observable((subscriber) => {
-        let due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
-        if (due < 0) {
-            due = 0;
-        }
-        let n = 0;
-        return scheduler.schedule(function () {
-            if (!subscriber.closed) {
-                subscriber.next(n++);
-                if (0 <= intervalDuration) {
-                    this.schedule(undefined, intervalDuration);
-                }
-                else {
-                    subscriber.complete();
-                }
-            }
-        }, due);
-    });
+function requirePartition () {
+	if (hasRequiredPartition) return partition;
+	hasRequiredPartition = 1;
+	Object.defineProperty(partition, "__esModule", { value: true });
+	partition.partition = void 0;
+	var not_1 = requireNot();
+	var filter_1 = requireFilter();
+	function partition$1(predicate, thisArg) {
+	    return function (source) {
+	        return [filter_1.filter(predicate, thisArg)(source), filter_1.filter(not_1.not(predicate, thisArg))(source)];
+	    };
+	}
+	partition.partition = partition$1;
+	
+	return partition;
 }
 
-function merge(...args) {
-    const scheduler = popScheduler(args);
-    const concurrent = popNumber(args, Infinity);
-    const sources = args;
-    return !sources.length
-        ?
-            EMPTY
-        : sources.length === 1
-            ?
-                innerFrom(sources[0])
-            :
-                mergeAll(concurrent)(from(sources, scheduler));
-}
+var race = {};
 
-function filter(predicate, thisArg) {
-    return operate((source, subscriber) => {
-        let index = 0;
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => predicate.call(thisArg, value, index++) && subscriber.next(value)));
-    });
-}
+var hasRequiredRace;
 
-function audit(durationSelector) {
-    return operate((source, subscriber) => {
-        let hasValue = false;
-        let lastValue = null;
-        let durationSubscriber = null;
-        let isComplete = false;
-        const endDuration = () => {
-            durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
-            durationSubscriber = null;
-            if (hasValue) {
-                hasValue = false;
-                const value = lastValue;
-                lastValue = null;
-                subscriber.next(value);
-            }
-            isComplete && subscriber.complete();
-        };
-        const cleanupDuration = () => {
-            durationSubscriber = null;
-            isComplete && subscriber.complete();
-        };
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
-            hasValue = true;
-            lastValue = value;
-            if (!durationSubscriber) {
-                innerFrom(durationSelector(value)).subscribe((durationSubscriber = createOperatorSubscriber(subscriber, endDuration, cleanupDuration)));
-            }
-        }, () => {
-            isComplete = true;
-            (!hasValue || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
-        }));
-    });
+function requireRace () {
+	if (hasRequiredRace) return race;
+	hasRequiredRace = 1;
+	var __read = (race && race.__read) || function (o, n) {
+	    var m = typeof Symbol === "function" && o[Symbol.iterator];
+	    if (!m) return o;
+	    var i = m.call(o), r, ar = [], e;
+	    try {
+	        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+	    }
+	    catch (error) { e = { error: error }; }
+	    finally {
+	        try {
+	            if (r && !r.done && (m = i["return"])) m.call(i);
+	        }
+	        finally { if (e) throw e.error; }
+	    }
+	    return ar;
+	};
+	var __spreadArray = (race && race.__spreadArray) || function (to, from) {
+	    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+	        to[j] = from[i];
+	    return to;
+	};
+	Object.defineProperty(race, "__esModule", { value: true });
+	race.race = void 0;
+	var argsOrArgArray_1 = requireArgsOrArgArray();
+	var raceWith_1 = requireRaceWith();
+	function race$1() {
+	    var args = [];
+	    for (var _i = 0; _i < arguments.length; _i++) {
+	        args[_i] = arguments[_i];
+	    }
+	    return raceWith_1.raceWith.apply(void 0, __spreadArray([], __read(argsOrArgArray_1.argsOrArgArray(args))));
+	}
+	race.race = race$1;
+	
+	return race;
 }
 
-function auditTime(duration, scheduler = asyncScheduler) {
-    return audit(() => timer(duration, scheduler));
-}
+var hasRequiredOperators;
 
-function distinctUntilChanged(comparator, keySelector = identity) {
-    comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
-    return operate((source, subscriber) => {
-        let previousKey;
-        let first = true;
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
-            const currentKey = keySelector(value);
-            if (first || !comparator(previousKey, currentKey)) {
-                first = false;
-                previousKey = currentKey;
-                subscriber.next(value);
-            }
-        }));
-    });
-}
-function defaultCompare(a, b) {
-    return a === b;
+function requireOperators () {
+	if (hasRequiredOperators) return operators;
+	hasRequiredOperators = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.mergeAll = exports.merge = exports.max = exports.materialize = exports.mapTo = exports.map = exports.last = exports.isEmpty = exports.ignoreElements = exports.groupBy = exports.first = exports.findIndex = exports.find = exports.finalize = exports.filter = exports.expand = exports.exhaustMap = exports.exhaustAll = exports.exhaust = exports.every = exports.endWith = exports.elementAt = exports.distinctUntilKeyChanged = exports.distinctUntilChanged = exports.distinct = exports.dematerialize = exports.delayWhen = exports.delay = exports.defaultIfEmpty = exports.debounceTime = exports.debounce = exports.count = exports.connect = exports.concatWith = exports.concatMapTo = exports.concatMap = exports.concatAll = exports.concat = exports.combineLatestWith = exports.combineLatest = exports.combineLatestAll = exports.combineAll = exports.catchError = exports.bufferWhen = exports.bufferToggle = exports.bufferTime = exports.bufferCount = exports.buffer = exports.auditTime = exports.audit = void 0;
+		exports.timeInterval = exports.throwIfEmpty = exports.throttleTime = exports.throttle = exports.tap = exports.takeWhile = exports.takeUntil = exports.takeLast = exports.take = exports.switchScan = exports.switchMapTo = exports.switchMap = exports.switchAll = exports.subscribeOn = exports.startWith = exports.skipWhile = exports.skipUntil = exports.skipLast = exports.skip = exports.single = exports.shareReplay = exports.share = exports.sequenceEqual = exports.scan = exports.sampleTime = exports.sample = exports.refCount = exports.retryWhen = exports.retry = exports.repeatWhen = exports.repeat = exports.reduce = exports.raceWith = exports.race = exports.publishReplay = exports.publishLast = exports.publishBehavior = exports.publish = exports.pluck = exports.partition = exports.pairwise = exports.onErrorResumeNext = exports.observeOn = exports.multicast = exports.min = exports.mergeWith = exports.mergeScan = exports.mergeMapTo = exports.mergeMap = exports.flatMap = void 0;
+		exports.zipWith = exports.zipAll = exports.zip = exports.withLatestFrom = exports.windowWhen = exports.windowToggle = exports.windowTime = exports.windowCount = exports.window = exports.toArray = exports.timestamp = exports.timeoutWith = exports.timeout = void 0;
+		var audit_1 = requireAudit();
+		Object.defineProperty(exports, "audit", { enumerable: true, get: function () { return audit_1.audit; } });
+		var auditTime_1 = requireAuditTime();
+		Object.defineProperty(exports, "auditTime", { enumerable: true, get: function () { return auditTime_1.auditTime; } });
+		var buffer_1 = requireBuffer();
+		Object.defineProperty(exports, "buffer", { enumerable: true, get: function () { return buffer_1.buffer; } });
+		var bufferCount_1 = requireBufferCount();
+		Object.defineProperty(exports, "bufferCount", { enumerable: true, get: function () { return bufferCount_1.bufferCount; } });
+		var bufferTime_1 = requireBufferTime();
+		Object.defineProperty(exports, "bufferTime", { enumerable: true, get: function () { return bufferTime_1.bufferTime; } });
+		var bufferToggle_1 = requireBufferToggle();
+		Object.defineProperty(exports, "bufferToggle", { enumerable: true, get: function () { return bufferToggle_1.bufferToggle; } });
+		var bufferWhen_1 = requireBufferWhen();
+		Object.defineProperty(exports, "bufferWhen", { enumerable: true, get: function () { return bufferWhen_1.bufferWhen; } });
+		var catchError_1 = requireCatchError();
+		Object.defineProperty(exports, "catchError", { enumerable: true, get: function () { return catchError_1.catchError; } });
+		var combineAll_1 = requireCombineAll();
+		Object.defineProperty(exports, "combineAll", { enumerable: true, get: function () { return combineAll_1.combineAll; } });
+		var combineLatestAll_1 = requireCombineLatestAll();
+		Object.defineProperty(exports, "combineLatestAll", { enumerable: true, get: function () { return combineLatestAll_1.combineLatestAll; } });
+		var combineLatest_1 = requireCombineLatest();
+		Object.defineProperty(exports, "combineLatest", { enumerable: true, get: function () { return combineLatest_1.combineLatest; } });
+		var combineLatestWith_1 = requireCombineLatestWith();
+		Object.defineProperty(exports, "combineLatestWith", { enumerable: true, get: function () { return combineLatestWith_1.combineLatestWith; } });
+		var concat_1 = requireConcat();
+		Object.defineProperty(exports, "concat", { enumerable: true, get: function () { return concat_1.concat; } });
+		var concatAll_1 = requireConcatAll();
+		Object.defineProperty(exports, "concatAll", { enumerable: true, get: function () { return concatAll_1.concatAll; } });
+		var concatMap_1 = requireConcatMap();
+		Object.defineProperty(exports, "concatMap", { enumerable: true, get: function () { return concatMap_1.concatMap; } });
+		var concatMapTo_1 = requireConcatMapTo();
+		Object.defineProperty(exports, "concatMapTo", { enumerable: true, get: function () { return concatMapTo_1.concatMapTo; } });
+		var concatWith_1 = requireConcatWith();
+		Object.defineProperty(exports, "concatWith", { enumerable: true, get: function () { return concatWith_1.concatWith; } });
+		var connect_1 = requireConnect();
+		Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connect_1.connect; } });
+		var count_1 = requireCount();
+		Object.defineProperty(exports, "count", { enumerable: true, get: function () { return count_1.count; } });
+		var debounce_1 = requireDebounce();
+		Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return debounce_1.debounce; } });
+		var debounceTime_1 = requireDebounceTime();
+		Object.defineProperty(exports, "debounceTime", { enumerable: true, get: function () { return debounceTime_1.debounceTime; } });
+		var defaultIfEmpty_1 = requireDefaultIfEmpty();
+		Object.defineProperty(exports, "defaultIfEmpty", { enumerable: true, get: function () { return defaultIfEmpty_1.defaultIfEmpty; } });
+		var delay_1 = requireDelay();
+		Object.defineProperty(exports, "delay", { enumerable: true, get: function () { return delay_1.delay; } });
+		var delayWhen_1 = requireDelayWhen();
+		Object.defineProperty(exports, "delayWhen", { enumerable: true, get: function () { return delayWhen_1.delayWhen; } });
+		var dematerialize_1 = requireDematerialize();
+		Object.defineProperty(exports, "dematerialize", { enumerable: true, get: function () { return dematerialize_1.dematerialize; } });
+		var distinct_1 = requireDistinct();
+		Object.defineProperty(exports, "distinct", { enumerable: true, get: function () { return distinct_1.distinct; } });
+		var distinctUntilChanged_1 = requireDistinctUntilChanged();
+		Object.defineProperty(exports, "distinctUntilChanged", { enumerable: true, get: function () { return distinctUntilChanged_1.distinctUntilChanged; } });
+		var distinctUntilKeyChanged_1 = requireDistinctUntilKeyChanged();
+		Object.defineProperty(exports, "distinctUntilKeyChanged", { enumerable: true, get: function () { return distinctUntilKeyChanged_1.distinctUntilKeyChanged; } });
+		var elementAt_1 = requireElementAt();
+		Object.defineProperty(exports, "elementAt", { enumerable: true, get: function () { return elementAt_1.elementAt; } });
+		var endWith_1 = requireEndWith();
+		Object.defineProperty(exports, "endWith", { enumerable: true, get: function () { return endWith_1.endWith; } });
+		var every_1 = requireEvery();
+		Object.defineProperty(exports, "every", { enumerable: true, get: function () { return every_1.every; } });
+		var exhaust_1 = requireExhaust();
+		Object.defineProperty(exports, "exhaust", { enumerable: true, get: function () { return exhaust_1.exhaust; } });
+		var exhaustAll_1 = requireExhaustAll();
+		Object.defineProperty(exports, "exhaustAll", { enumerable: true, get: function () { return exhaustAll_1.exhaustAll; } });
+		var exhaustMap_1 = requireExhaustMap();
+		Object.defineProperty(exports, "exhaustMap", { enumerable: true, get: function () { return exhaustMap_1.exhaustMap; } });
+		var expand_1 = requireExpand();
+		Object.defineProperty(exports, "expand", { enumerable: true, get: function () { return expand_1.expand; } });
+		var filter_1 = requireFilter();
+		Object.defineProperty(exports, "filter", { enumerable: true, get: function () { return filter_1.filter; } });
+		var finalize_1 = requireFinalize();
+		Object.defineProperty(exports, "finalize", { enumerable: true, get: function () { return finalize_1.finalize; } });
+		var find_1 = requireFind();
+		Object.defineProperty(exports, "find", { enumerable: true, get: function () { return find_1.find; } });
+		var findIndex_1 = requireFindIndex();
+		Object.defineProperty(exports, "findIndex", { enumerable: true, get: function () { return findIndex_1.findIndex; } });
+		var first_1 = requireFirst();
+		Object.defineProperty(exports, "first", { enumerable: true, get: function () { return first_1.first; } });
+		var groupBy_1 = requireGroupBy();
+		Object.defineProperty(exports, "groupBy", { enumerable: true, get: function () { return groupBy_1.groupBy; } });
+		var ignoreElements_1 = requireIgnoreElements();
+		Object.defineProperty(exports, "ignoreElements", { enumerable: true, get: function () { return ignoreElements_1.ignoreElements; } });
+		var isEmpty_1 = requireIsEmpty();
+		Object.defineProperty(exports, "isEmpty", { enumerable: true, get: function () { return isEmpty_1.isEmpty; } });
+		var last_1 = requireLast();
+		Object.defineProperty(exports, "last", { enumerable: true, get: function () { return last_1.last; } });
+		var map_1 = requireMap();
+		Object.defineProperty(exports, "map", { enumerable: true, get: function () { return map_1.map; } });
+		var mapTo_1 = requireMapTo();
+		Object.defineProperty(exports, "mapTo", { enumerable: true, get: function () { return mapTo_1.mapTo; } });
+		var materialize_1 = requireMaterialize();
+		Object.defineProperty(exports, "materialize", { enumerable: true, get: function () { return materialize_1.materialize; } });
+		var max_1 = requireMax();
+		Object.defineProperty(exports, "max", { enumerable: true, get: function () { return max_1.max; } });
+		var merge_1 = requireMerge();
+		Object.defineProperty(exports, "merge", { enumerable: true, get: function () { return merge_1.merge; } });
+		var mergeAll_1 = requireMergeAll();
+		Object.defineProperty(exports, "mergeAll", { enumerable: true, get: function () { return mergeAll_1.mergeAll; } });
+		var flatMap_1 = requireFlatMap();
+		Object.defineProperty(exports, "flatMap", { enumerable: true, get: function () { return flatMap_1.flatMap; } });
+		var mergeMap_1 = requireMergeMap();
+		Object.defineProperty(exports, "mergeMap", { enumerable: true, get: function () { return mergeMap_1.mergeMap; } });
+		var mergeMapTo_1 = requireMergeMapTo();
+		Object.defineProperty(exports, "mergeMapTo", { enumerable: true, get: function () { return mergeMapTo_1.mergeMapTo; } });
+		var mergeScan_1 = requireMergeScan();
+		Object.defineProperty(exports, "mergeScan", { enumerable: true, get: function () { return mergeScan_1.mergeScan; } });
+		var mergeWith_1 = requireMergeWith();
+		Object.defineProperty(exports, "mergeWith", { enumerable: true, get: function () { return mergeWith_1.mergeWith; } });
+		var min_1 = requireMin();
+		Object.defineProperty(exports, "min", { enumerable: true, get: function () { return min_1.min; } });
+		var multicast_1 = requireMulticast();
+		Object.defineProperty(exports, "multicast", { enumerable: true, get: function () { return multicast_1.multicast; } });
+		var observeOn_1 = requireObserveOn();
+		Object.defineProperty(exports, "observeOn", { enumerable: true, get: function () { return observeOn_1.observeOn; } });
+		var onErrorResumeNextWith_1 = requireOnErrorResumeNextWith();
+		Object.defineProperty(exports, "onErrorResumeNext", { enumerable: true, get: function () { return onErrorResumeNextWith_1.onErrorResumeNext; } });
+		var pairwise_1 = requirePairwise();
+		Object.defineProperty(exports, "pairwise", { enumerable: true, get: function () { return pairwise_1.pairwise; } });
+		var partition_1 = requirePartition();
+		Object.defineProperty(exports, "partition", { enumerable: true, get: function () { return partition_1.partition; } });
+		var pluck_1 = requirePluck();
+		Object.defineProperty(exports, "pluck", { enumerable: true, get: function () { return pluck_1.pluck; } });
+		var publish_1 = requirePublish();
+		Object.defineProperty(exports, "publish", { enumerable: true, get: function () { return publish_1.publish; } });
+		var publishBehavior_1 = requirePublishBehavior();
+		Object.defineProperty(exports, "publishBehavior", { enumerable: true, get: function () { return publishBehavior_1.publishBehavior; } });
+		var publishLast_1 = requirePublishLast();
+		Object.defineProperty(exports, "publishLast", { enumerable: true, get: function () { return publishLast_1.publishLast; } });
+		var publishReplay_1 = requirePublishReplay();
+		Object.defineProperty(exports, "publishReplay", { enumerable: true, get: function () { return publishReplay_1.publishReplay; } });
+		var race_1 = requireRace();
+		Object.defineProperty(exports, "race", { enumerable: true, get: function () { return race_1.race; } });
+		var raceWith_1 = requireRaceWith();
+		Object.defineProperty(exports, "raceWith", { enumerable: true, get: function () { return raceWith_1.raceWith; } });
+		var reduce_1 = requireReduce();
+		Object.defineProperty(exports, "reduce", { enumerable: true, get: function () { return reduce_1.reduce; } });
+		var repeat_1 = requireRepeat();
+		Object.defineProperty(exports, "repeat", { enumerable: true, get: function () { return repeat_1.repeat; } });
+		var repeatWhen_1 = requireRepeatWhen();
+		Object.defineProperty(exports, "repeatWhen", { enumerable: true, get: function () { return repeatWhen_1.repeatWhen; } });
+		var retry_1 = requireRetry();
+		Object.defineProperty(exports, "retry", { enumerable: true, get: function () { return retry_1.retry; } });
+		var retryWhen_1 = requireRetryWhen();
+		Object.defineProperty(exports, "retryWhen", { enumerable: true, get: function () { return retryWhen_1.retryWhen; } });
+		var refCount_1 = requireRefCount();
+		Object.defineProperty(exports, "refCount", { enumerable: true, get: function () { return refCount_1.refCount; } });
+		var sample_1 = requireSample();
+		Object.defineProperty(exports, "sample", { enumerable: true, get: function () { return sample_1.sample; } });
+		var sampleTime_1 = requireSampleTime();
+		Object.defineProperty(exports, "sampleTime", { enumerable: true, get: function () { return sampleTime_1.sampleTime; } });
+		var scan_1 = requireScan();
+		Object.defineProperty(exports, "scan", { enumerable: true, get: function () { return scan_1.scan; } });
+		var sequenceEqual_1 = requireSequenceEqual();
+		Object.defineProperty(exports, "sequenceEqual", { enumerable: true, get: function () { return sequenceEqual_1.sequenceEqual; } });
+		var share_1 = requireShare();
+		Object.defineProperty(exports, "share", { enumerable: true, get: function () { return share_1.share; } });
+		var shareReplay_1 = requireShareReplay();
+		Object.defineProperty(exports, "shareReplay", { enumerable: true, get: function () { return shareReplay_1.shareReplay; } });
+		var single_1 = requireSingle();
+		Object.defineProperty(exports, "single", { enumerable: true, get: function () { return single_1.single; } });
+		var skip_1 = requireSkip();
+		Object.defineProperty(exports, "skip", { enumerable: true, get: function () { return skip_1.skip; } });
+		var skipLast_1 = requireSkipLast();
+		Object.defineProperty(exports, "skipLast", { enumerable: true, get: function () { return skipLast_1.skipLast; } });
+		var skipUntil_1 = requireSkipUntil();
+		Object.defineProperty(exports, "skipUntil", { enumerable: true, get: function () { return skipUntil_1.skipUntil; } });
+		var skipWhile_1 = requireSkipWhile();
+		Object.defineProperty(exports, "skipWhile", { enumerable: true, get: function () { return skipWhile_1.skipWhile; } });
+		var startWith_1 = requireStartWith();
+		Object.defineProperty(exports, "startWith", { enumerable: true, get: function () { return startWith_1.startWith; } });
+		var subscribeOn_1 = requireSubscribeOn();
+		Object.defineProperty(exports, "subscribeOn", { enumerable: true, get: function () { return subscribeOn_1.subscribeOn; } });
+		var switchAll_1 = requireSwitchAll();
+		Object.defineProperty(exports, "switchAll", { enumerable: true, get: function () { return switchAll_1.switchAll; } });
+		var switchMap_1 = requireSwitchMap();
+		Object.defineProperty(exports, "switchMap", { enumerable: true, get: function () { return switchMap_1.switchMap; } });
+		var switchMapTo_1 = requireSwitchMapTo();
+		Object.defineProperty(exports, "switchMapTo", { enumerable: true, get: function () { return switchMapTo_1.switchMapTo; } });
+		var switchScan_1 = requireSwitchScan();
+		Object.defineProperty(exports, "switchScan", { enumerable: true, get: function () { return switchScan_1.switchScan; } });
+		var take_1 = requireTake();
+		Object.defineProperty(exports, "take", { enumerable: true, get: function () { return take_1.take; } });
+		var takeLast_1 = requireTakeLast();
+		Object.defineProperty(exports, "takeLast", { enumerable: true, get: function () { return takeLast_1.takeLast; } });
+		var takeUntil_1 = requireTakeUntil();
+		Object.defineProperty(exports, "takeUntil", { enumerable: true, get: function () { return takeUntil_1.takeUntil; } });
+		var takeWhile_1 = requireTakeWhile();
+		Object.defineProperty(exports, "takeWhile", { enumerable: true, get: function () { return takeWhile_1.takeWhile; } });
+		var tap_1 = requireTap();
+		Object.defineProperty(exports, "tap", { enumerable: true, get: function () { return tap_1.tap; } });
+		var throttle_1 = requireThrottle();
+		Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return throttle_1.throttle; } });
+		var throttleTime_1 = requireThrottleTime();
+		Object.defineProperty(exports, "throttleTime", { enumerable: true, get: function () { return throttleTime_1.throttleTime; } });
+		var throwIfEmpty_1 = requireThrowIfEmpty();
+		Object.defineProperty(exports, "throwIfEmpty", { enumerable: true, get: function () { return throwIfEmpty_1.throwIfEmpty; } });
+		var timeInterval_1 = requireTimeInterval();
+		Object.defineProperty(exports, "timeInterval", { enumerable: true, get: function () { return timeInterval_1.timeInterval; } });
+		var timeout_1 = requireTimeout();
+		Object.defineProperty(exports, "timeout", { enumerable: true, get: function () { return timeout_1.timeout; } });
+		var timeoutWith_1 = requireTimeoutWith();
+		Object.defineProperty(exports, "timeoutWith", { enumerable: true, get: function () { return timeoutWith_1.timeoutWith; } });
+		var timestamp_1 = requireTimestamp();
+		Object.defineProperty(exports, "timestamp", { enumerable: true, get: function () { return timestamp_1.timestamp; } });
+		var toArray_1 = requireToArray();
+		Object.defineProperty(exports, "toArray", { enumerable: true, get: function () { return toArray_1.toArray; } });
+		var window_1 = requireWindow();
+		Object.defineProperty(exports, "window", { enumerable: true, get: function () { return window_1.window; } });
+		var windowCount_1 = requireWindowCount();
+		Object.defineProperty(exports, "windowCount", { enumerable: true, get: function () { return windowCount_1.windowCount; } });
+		var windowTime_1 = requireWindowTime();
+		Object.defineProperty(exports, "windowTime", { enumerable: true, get: function () { return windowTime_1.windowTime; } });
+		var windowToggle_1 = requireWindowToggle();
+		Object.defineProperty(exports, "windowToggle", { enumerable: true, get: function () { return windowToggle_1.windowToggle; } });
+		var windowWhen_1 = requireWindowWhen();
+		Object.defineProperty(exports, "windowWhen", { enumerable: true, get: function () { return windowWhen_1.windowWhen; } });
+		var withLatestFrom_1 = requireWithLatestFrom();
+		Object.defineProperty(exports, "withLatestFrom", { enumerable: true, get: function () { return withLatestFrom_1.withLatestFrom; } });
+		var zip_1 = requireZip();
+		Object.defineProperty(exports, "zip", { enumerable: true, get: function () { return zip_1.zip; } });
+		var zipAll_1 = requireZipAll();
+		Object.defineProperty(exports, "zipAll", { enumerable: true, get: function () { return zipAll_1.zipAll; } });
+		var zipWith_1 = requireZipWith();
+		Object.defineProperty(exports, "zipWith", { enumerable: true, get: function () { return zipWith_1.zipWith; } });
+		
+	} (operators));
+	return operators;
 }
 
-function takeUntil(notifier) {
-    return operate((source, subscriber) => {
-        innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop));
-        !subscriber.closed && source.subscribe(subscriber);
-    });
-}
+var operatorsExports = /*@__PURE__*/ requireOperators();
 
 const catScrollableCss = ":host{overflow:hidden;position:relative;display:flex}:host([hidden]){display:none}.shadow-bottom,.shadow-right,.shadow-left,.shadow-top{position:absolute;transition:box-shadow 0.3s cubic-bezier(0.25, 0.8, 0.25, 1)}.shadow-top{z-index:2;width:100%;top:0}.shadow-left{z-index:4;height:100%;left:0}.shadow-right{z-index:4;height:100%;right:0}.shadow-bottom{z-index:2;width:100%;bottom:0}.scrollable-wrapper{position:absolute;inset:0;pointer-events:none}.scrollable-wrapper.cat-scrollable-top .shadow-top,.scrollable-wrapper.cat-scrollable-bottom .shadow-bottom,.scrollable-wrapper.cat-scrollable-left .shadow-left,.scrollable-wrapper.cat-scrollable-right .shadow-right{box-shadow:0 0 4px 1px rgba(16, 29, 48, 0.2)}.scrollable-content{width:100%;overflow:hidden}.scrollable-content.scroll-x{overflow-x:auto}.scrollable-content.scroll-y{overflow-y:auto}.scrollable-content.no-overscroll{overscroll-behavior:contain}";
-const CatScrollableStyle0 = catScrollableCss;
 
 const CatScrollable = /*@__PURE__*/ proxyCustomElement(class CatScrollable extends HTMLElement {
     constructor() {
@@ -554,21 +322,32 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class CatScrollable exten
         this.scrolledLeft = createEvent(this, "scrolledLeft", 7);
         this.scrolledRight = createEvent(this, "scrolledRight", 7);
         this.scrolledBottom = createEvent(this, "scrolledBottom", 7);
-        this.init = new Subject();
-        this.destroyed = new Subject();
-        this.resizedEntries = new Subject();
+        this.init = new cjsExports.Subject();
+        this.destroyed = new cjsExports.Subject();
+        this.resizedEntries = new cjsExports.Subject();
         this.resizedObserver = new ResizeObserver(entries => this.resizedEntries.next(entries));
+        /** Flags to disable/enable scroll shadowX. */
         this.noShadowX = false;
+        /** Flags to disable/enable scroll shadowY. */
         this.noShadowY = false;
+        /** Flags to disable/enable overflowX. */
         this.noOverflowX = false;
+        /** Flags to disable/enable overflowY. */
         this.noOverflowY = false;
+        /** Flag to disable/enable overscroll behavior. */
         this.noOverscroll = false;
+        /**
+         * Flag to not fire an initial event after content initialization.
+         */
         this.noScrolledInit = false;
+        /**
+         * Buffer to be used to calculate the scroll distance.
+         */
         this.scrolledBuffer = 0;
     }
     componentDidRender() {
         if (this.scrollElement) {
-            this.scrolled = fromEvent(this.scrollElement, 'scroll').pipe(takeUntil(this.destroyed));
+            this.scrolled = cjsExports.fromEvent(this.scrollElement, 'scroll').pipe(operatorsExports.takeUntil(this.destroyed));
             this.resizedObserver.observe(this.scrollElement);
         }
         if (this.scrollWrapperElement) {
@@ -578,14 +357,14 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class CatScrollable exten
         this.attachEmitter('right', this.scrolledRight);
         this.attachEmitter('bottom', this.scrolledBottom);
         this.attachEmitter('top', this.scrolledTop);
-        merge(this.init, this.scrolled, this.resizedEntries)
-            .pipe(auditTime(CatScrollable.THROTTLE), map(() => ({
+        cjsExports.merge(this.init, this.scrolled, this.resizedEntries)
+            .pipe(operatorsExports.auditTime(CatScrollable.THROTTLE), operatorsExports.map(() => ({
             // 5px used to avoid shadow bug on Windows
             top: this.getScrollOffset('top') > 5,
             left: this.getScrollOffset('left') > 5,
             right: this.getScrollOffset('right') > 5,
             bottom: this.getScrollOffset('bottom') > 5
-        })), takeUntil(this.destroyed))
+        })), operatorsExports.takeUntil(this.destroyed))
             .subscribe(({ top, left, right, bottom }) => {
             this.toggleClass('cat-scrollable-top', top);
             this.toggleClass('cat-scrollable-left', left);
@@ -616,8 +395,8 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class CatScrollable exten
         ];
     }
     attachEmitter(from, emitter) {
-        merge(this.init, this.scrolled, this.resizedEntries)
-            .pipe(auditTime(CatScrollable.THROTTLE), map(() => this.getScrollOffset(from)), map(offset => offset <= this.scrolledBuffer), filter(isLower => isLower), map(() => {
+        cjsExports.merge(this.init, this.scrolled, this.resizedEntries)
+            .pipe(operatorsExports.auditTime(CatScrollable.THROTTLE), operatorsExports.map(() => this.getScrollOffset(from)), operatorsExports.map(offset => offset <= this.scrolledBuffer), operatorsExports.filter(isLower => isLower), operatorsExports.map(() => {
             switch (from) {
                 case 'top':
                     return this.getScrollOffset('bottom');
@@ -628,7 +407,7 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class CatScrollable exten
                 case 'bottom':
                     return this.getScrollOffset('top');
             }
-        }), distinctUntilChanged(), takeUntil(this.destroyed))
+        }), operatorsExports.distinctUntilChanged(), operatorsExports.takeUntil(this.destroyed))
             .subscribe(() => emitter.emit());
     }
     getScrollOffset(from) {
@@ -656,7 +435,7 @@ const CatScrollable = /*@__PURE__*/ proxyCustomElement(class CatScrollable exten
             this.scrollWrapperElement?.classList.remove(name);
         }
     }
-    static get style() { return CatScrollableStyle0; }
+    static get style() { return catScrollableCss; }
 }, [1, "cat-scrollable", {
         "noShadowX": [4, "no-shadow-x"],
         "noShadowY": [4, "no-shadow-y"],
@@ -681,6 +460,7 @@ function defineCustomElement() {
     } });
 }
 
-export { CatScrollable as C, EMPTY as E, Subject as S, distinctUntilChanged as a, map as b, mergeMap as c, defineCustomElement as d, asyncScheduler as e, filter as f, mergeAll as m, timer as t };
+export { CatScrollable as C, defineCustomElement as d };
+//# sourceMappingURL=cat-scrollable2.js.map
 
 //# sourceMappingURL=cat-scrollable2.js.map