@runopencode/rx-stencil 0.4.2 → 0.4.4

package/dist/esm/index.js

@@ -1,406 +1,29 @@
-import { g as getElement, f as forceUpdate } from './index-9102de09.js';
-import { S as Subject, o as operate, c as createOperatorSubscriber, p as popScheduler, a as popResultSelector, f as from, O as Observable, i as identity, e as executeSchedule, b as innerFrom, d as isFunction, g as SafeSubscriber, n as noop, h as propertyObservable, j as distinctUntilChanged, k as getPropertyDescriptor } from './set-property-9befeb72.js';
-export { h as propertyObservable, s as setProperty } from './set-property-9befeb72.js';
-
-const dateTimestampProvider = {
-    now() {
-        return (dateTimestampProvider.delegate || Date).now();
-    },
-    delegate: undefined,
-};
-
-class ReplaySubject extends Subject {
-    constructor(_bufferSize = Infinity, _windowTime = Infinity, _timestampProvider = dateTimestampProvider) {
-        super();
-        this._bufferSize = _bufferSize;
-        this._windowTime = _windowTime;
-        this._timestampProvider = _timestampProvider;
-        this._buffer = [];
-        this._infiniteTimeWindow = true;
-        this._infiniteTimeWindow = _windowTime === Infinity;
-        this._bufferSize = Math.max(1, _bufferSize);
-        this._windowTime = Math.max(1, _windowTime);
-    }
-    next(value) {
-        const { isStopped, _buffer, _infiniteTimeWindow, _timestampProvider, _windowTime } = this;
-        if (!isStopped) {
-            _buffer.push(value);
-            !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
-        }
-        this._trimBuffer();
-        super.next(value);
-    }
-    _subscribe(subscriber) {
-        this._throwIfClosed();
-        this._trimBuffer();
-        const subscription = this._innerSubscribe(subscriber);
-        const { _infiniteTimeWindow, _buffer } = this;
-        const copy = _buffer.slice();
-        for (let i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
-            subscriber.next(copy[i]);
-        }
-        this._checkFinalizedStatuses(subscriber);
-        return subscription;
-    }
-    _trimBuffer() {
-        const { _bufferSize, _timestampProvider, _buffer, _infiniteTimeWindow } = this;
-        const adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
-        _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
-        if (!_infiniteTimeWindow) {
-            const now = _timestampProvider.now();
-            let last = 0;
-            for (let i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
-                last = i;
-            }
-            last && _buffer.splice(0, last + 1);
-        }
-    }
-}
-
-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: isArray$1 } = Array;
-function callOrApply(fn, args) {
-    return isArray$1(args) ? fn(...args) : fn(args);
-}
-function mapOneOrManyArgs(fn) {
-    return map(args => callOrApply(fn, args));
-}
-
-const { isArray } = Array;
-const { getPrototypeOf, prototype: objectProto, keys: getKeys } = Object;
-function argsArgArrayOrObject(args) {
-    if (args.length === 1) {
-        const first = args[0];
-        if (isArray(first)) {
-            return { args: first, keys: null };
-        }
-        if (isPOJO(first)) {
-            const keys = getKeys(first);
-            return {
-                args: keys.map((key) => first[key]),
-                keys,
-            };
-        }
-    }
-    return { args: args, keys: null };
-}
-function isPOJO(obj) {
-    return obj && typeof obj === 'object' && getPrototypeOf(obj) === objectProto;
-}
-
-function createObject(keys, values) {
-    return keys.reduce((result, key, i) => ((result[key] = values[i]), result), {});
-}
-
-function combineLatest(...args) {
-    const scheduler = popScheduler(args);
-    const resultSelector = popResultSelector(args);
-    const { args: observables, keys } = argsArgArrayOrObject(args);
-    if (observables.length === 0) {
-        return from([], scheduler);
-    }
-    const result = new Observable(combineLatestInit(observables, scheduler, keys
-        ?
-            (values) => createObject(keys, values)
-        :
-            identity));
-    return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
-}
-function combineLatestInit(observables, scheduler, valueTransform = identity) {
-    return (subscriber) => {
-        maybeSchedule(scheduler, () => {
-            const { length } = observables;
-            const values = new Array(length);
-            let active = length;
-            let remainingFirstValues = length;
-            for (let i = 0; i < length; i++) {
-                maybeSchedule(scheduler, () => {
-                    const source = from(observables[i], scheduler);
-                    let hasFirstValue = false;
-                    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
-                        values[i] = value;
-                        if (!hasFirstValue) {
-                            hasFirstValue = true;
-                            remainingFirstValues--;
-                        }
-                        if (!remainingFirstValues) {
-                            subscriber.next(valueTransform(values.slice()));
-                        }
-                    }, () => {
-                        if (!--active) {
-                            subscriber.complete();
-                        }
-                    }));
-                }, subscriber);
-            }
-        }, subscriber);
-    };
-}
-function maybeSchedule(scheduler, execute, subscription) {
-    if (scheduler) {
-        executeSchedule(subscription, scheduler, execute);
-    }
-    else {
-        execute();
-    }
-}
-
-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();
-    };
-}
-
-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);
-}
-
-function concatAll() {
-    return mergeAll(1);
-}
-
-function concat(...args) {
-    return concatAll()(from(args, popScheduler(args)));
-}
-
-function filter(predicate, thisArg) {
-    return operate((source, subscriber) => {
-        let index = 0;
-        source.subscribe(createOperatorSubscriber(subscriber, (value) => predicate.call(thisArg, value, index++) && subscriber.next(value)));
-    });
-}
-
-function share(options = {}) {
-    const { connector = () => new Subject(), resetOnError = true, resetOnComplete = true, resetOnRefCountZero = true } = options;
-    return (wrapperSource) => {
-        let connection;
-        let resetConnection;
-        let subject;
-        let refCount = 0;
-        let hasCompleted = false;
-        let hasErrored = false;
-        const cancelReset = () => {
-            resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
-            resetConnection = undefined;
-        };
-        const reset = () => {
-            cancelReset();
-            connection = subject = undefined;
-            hasCompleted = hasErrored = false;
-        };
-        const resetAndUnsubscribe = () => {
-            const conn = connection;
-            reset();
-            conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
-        };
-        return operate((source, subscriber) => {
-            refCount++;
-            if (!hasErrored && !hasCompleted) {
-                cancelReset();
-            }
-            const dest = (subject = subject !== null && subject !== void 0 ? subject : connector());
-            subscriber.add(() => {
-                refCount--;
-                if (refCount === 0 && !hasErrored && !hasCompleted) {
-                    resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
-                }
-            });
-            dest.subscribe(subscriber);
-            if (!connection &&
-                refCount > 0) {
-                connection = new SafeSubscriber({
-                    next: (value) => dest.next(value),
-                    error: (err) => {
-                        hasErrored = true;
-                        cancelReset();
-                        resetConnection = handleReset(reset, resetOnError, err);
-                        dest.error(err);
-                    },
-                    complete: () => {
-                        hasCompleted = true;
-                        cancelReset();
-                        resetConnection = handleReset(reset, resetOnComplete);
-                        dest.complete();
-                    },
-                });
-                innerFrom(source).subscribe(connection);
-            }
-        })(wrapperSource);
-    };
-}
-function handleReset(reset, on, ...args) {
-    if (on === true) {
-        reset();
-        return;
-    }
-    if (on === false) {
-        return;
-    }
-    const onSubscriber = new SafeSubscriber({
-        next: () => {
-            onSubscriber.unsubscribe();
-            reset();
-        },
-    });
-    return innerFrom(on(...args)).subscribe(onSubscriber);
-}
-
-function shareReplay(configOrBufferSize, windowTime, scheduler) {
-    let bufferSize;
-    let refCount = false;
-    if (configOrBufferSize && typeof configOrBufferSize === 'object') {
-        ({ bufferSize = Infinity, windowTime = Infinity, refCount = false, scheduler } = configOrBufferSize);
-    }
-    else {
-        bufferSize = (configOrBufferSize !== null && configOrBufferSize !== void 0 ? configOrBufferSize : Infinity);
-    }
-    return share({
-        connector: () => new ReplaySubject(bufferSize, windowTime, scheduler),
-        resetOnError: true,
-        resetOnComplete: false,
-        resetOnRefCountZero: refCount,
-    });
-}
-
-function startWith(...values) {
-    const scheduler = popScheduler(values);
-    return operate((source, subscriber) => {
-        (scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber);
-    });
-}
-
-function takeUntil(notifier) {
-    return operate((source, subscriber) => {
-        innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop));
-        !subscriber.closed && source.subscribe(subscriber);
-    });
-}
-
-function tap(observerOrNext, error, complete) {
-    const tapObserver = isFunction(observerOrNext) || error || complete
-        ?
-            { next: observerOrNext, error, complete }
-        : observerOrNext;
-    return tapObserver
-        ? operate((source, subscriber) => {
-            var _a;
-            (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
-            let isUnsub = true;
-            source.subscribe(createOperatorSubscriber(subscriber, (value) => {
-                var _a;
-                (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
-                subscriber.next(value);
-            }, () => {
-                var _a;
-                isUnsub = false;
-                (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
-                subscriber.complete();
-            }, (err) => {
-                var _a;
-                isUnsub = false;
-                (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
-                subscriber.error(err);
-            }, () => {
-                var _a, _b;
-                if (isUnsub) {
-                    (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
-                }
-                (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
-            }));
-        })
-        :
-            identity;
-}
+import { g as getElement, f as forceUpdate } from './index-BIBww8qU.js';
+import { c as cjsExports, p as propertyObservable, g as getPropertyDescriptor } from './set-property-CpZKE-Xu.js';
+export { s as setProperty } from './set-property-CpZKE-Xu.js';
 
 function mutationObservable(target, options) {
-  return new Observable((observer) => {
-    let mutation = new MutationObserver((mutations) => {
-      observer.next(mutations);
+    return new cjsExports.Observable((observer) => {
+        let mutation = new MutationObserver((mutations) => {
+            observer.next(mutations);
+        });
+        mutation.observe(target, options);
+        return () => {
+            mutation.disconnect();
+        };
     });
-    mutation.observe(target, options);
-    return () => {
-      mutation.disconnect();
-    };
-  });
 }
 
 /**
  * Returns an observable that emits an array of values from the given properties.
  */
 function propertiesObservable(cmp, ...properties) {
-  if (0 === properties.length) {
-    throw new Error('At least one property must be specified.');
-  }
-  return combineLatest(properties.map((property) => {
-    return propertyObservable(cmp, property);
-  }));
+    if (0 === properties.length) {
+        throw new Error('At least one property must be specified.');
+    }
+    return cjsExports.combineLatest(properties.map((property) => {
+        return propertyObservable(cmp, property);
+    }));
 }
 
 /**
@@ -409,21 +32,21 @@ function propertiesObservable(cmp, ...properties) {
  * microtask (next tick).
  */
 function renderObservable(cmp) {
-  if ('function' !== typeof cmp.render) {
-    throw new Error('Component does not have a render function.');
-  }
-  return new Observable((subscriber) => {
-    let previousRender = cmp.render;
-    cmp.render = function () {
-      Promise.resolve().then(() => {
-        subscriber.next();
-      });
-      return previousRender.call(this);
-    };
-    return () => {
-      cmp.render = previousRender;
-    };
-  });
+    if ('function' !== typeof cmp.render) {
+        throw new Error('Component does not have a render function.');
+    }
+    return new cjsExports.Observable((subscriber) => {
+        let previousRender = cmp.render;
+        cmp.render = function () {
+            Promise.resolve().then(() => {
+                subscriber.next();
+            });
+            return previousRender.call(this);
+        };
+        return () => {
+            cmp.render = previousRender;
+        };
+    });
 }
 
 /**
@@ -433,22 +56,22 @@ function renderObservable(cmp) {
  * {@internal}
  */
 function observeSubNodes(target) {
-  return mutationObservable(target, {
-    subtree: true,
-    childList: true,
-  }).pipe(filter((records) => {
-    for (let i = 0; i < records.length; i++) {
-      if ('childList' !== records[i].type) {
-        continue;
-      }
-      if (records[i].addedNodes.length || records[i].removedNodes.length) {
-        return true;
-      }
-    }
-    return false;
-  }), map(() => {
-    /* noop */
-  }));
+    return mutationObservable(target, {
+        subtree: true,
+        childList: true,
+    }).pipe(cjsExports.filter((records) => {
+        for (let i = 0; i < records.length; i++) {
+            if ('childList' !== records[i].type) {
+                continue;
+            }
+            if (records[i].addedNodes.length || records[i].removedNodes.length) {
+                return true;
+            }
+        }
+        return false;
+    }), cjsExports.map(() => {
+        /* noop */
+    }));
 }
 /**
  * Property decorator inspired by Angular's @ViewChild/@ContentChild.
@@ -458,23 +81,23 @@ function observeSubNodes(target) {
  * set to null.
  */
 function QuerySelector(selector, options) {
-  return (target, property) => {
-    let descriptor = {
-      set: function () {
-        throw new Error(`Property "${property}" is read-only.`);
-      },
-      get: function () {
-        let observableProperty = `__rx__query_selector__observable__shadow_root__${(options === null || options === void 0 ? void 0 : options.shadowRoot) ? 'yes' : 'no'}__mutation_observer__${(options === null || options === void 0 ? void 0 : options.mutationObserver) ? 'yes' : 'no'}__selector__${selector}__`;
-        if (!this[observableProperty]) {
-          let root = (options === null || options === void 0 ? void 0 : options.shadowRoot) ? getElement(this).shadowRoot : getElement(this);
-          let observable = (options === null || options === void 0 ? void 0 : options.mutationObserver) ? observeSubNodes(root) : renderObservable(this);
-          this[observableProperty] = observable.pipe(startWith(), map(() => root.querySelector(selector)), distinctUntilChanged(), shareReplay(1));
-        }
-        return this[observableProperty];
-      },
+    return (target, property) => {
+        let descriptor = {
+            set: function () {
+                throw new Error(`Property "${property}" is read-only.`);
+            },
+            get: function () {
+                let observableProperty = `__rx__query_selector__observable__shadow_root__${(options === null || options === void 0 ? void 0 : options.shadowRoot) ? 'yes' : 'no'}__mutation_observer__${(options === null || options === void 0 ? void 0 : options.mutationObserver) ? 'yes' : 'no'}__selector__${selector}__`;
+                if (!this[observableProperty]) {
+                    let root = (options === null || options === void 0 ? void 0 : options.shadowRoot) ? getElement(this).shadowRoot : getElement(this);
+                    let observable = (options === null || options === void 0 ? void 0 : options.mutationObserver) ? observeSubNodes(root) : renderObservable(this);
+                    this[observableProperty] = observable.pipe(cjsExports.startWith(), cjsExports.map(() => root.querySelector(selector)), cjsExports.distinctUntilChanged(), cjsExports.shareReplay(1));
+                }
+                return this[observableProperty];
+            },
+        };
+        Object.defineProperty(target, property, descriptor);
     };
-    Object.defineProperty(target, property, descriptor);
-  };
 }
 
 /**
@@ -485,33 +108,33 @@ function QuerySelector(selector, options) {
  * set to null.
  */
 function QuerySelectorAll(selector, options) {
-  return (target, property) => {
-    let descriptor = {
-      set: function () {
-        throw new Error(`Property "${property}" is read-only.`);
-      },
-      get: function () {
-        let observableProperty = `__rx__query_selector_all__observable__shadow_root__${(options === null || options === void 0 ? void 0 : options.shadowRoot) ? 'yes' : 'no'}__mutation_observer__${(options === null || options === void 0 ? void 0 : options.mutationObserver) ? 'yes' : 'no'}__selector__${selector}__`;
-        if (!this[observableProperty]) {
-          let root = (options === null || options === void 0 ? void 0 : options.shadowRoot) ? getElement(this).shadowRoot : getElement(this);
-          let observable = (options === null || options === void 0 ? void 0 : options.mutationObserver) ? observeSubNodes(root) : renderObservable(this);
-          this[observableProperty] = observable.pipe(startWith(), map(() => Array.from(root.querySelectorAll(selector))), distinctUntilChanged((previous, current) => {
-            if (previous.length !== current.length) {
-              return false;
-            }
-            for (let i = 0; i < previous.length; i++) {
-              if (previous[i] !== current[i]) {
-                return false;
-              }
-            }
-            return true;
-          }), shareReplay(1));
-        }
-        return this[observableProperty];
-      },
+    return (target, property) => {
+        let descriptor = {
+            set: function () {
+                throw new Error(`Property "${property}" is read-only.`);
+            },
+            get: function () {
+                let observableProperty = `__rx__query_selector_all__observable__shadow_root__${(options === null || options === void 0 ? void 0 : options.shadowRoot) ? 'yes' : 'no'}__mutation_observer__${(options === null || options === void 0 ? void 0 : options.mutationObserver) ? 'yes' : 'no'}__selector__${selector}__`;
+                if (!this[observableProperty]) {
+                    let root = (options === null || options === void 0 ? void 0 : options.shadowRoot) ? getElement(this).shadowRoot : getElement(this);
+                    let observable = (options === null || options === void 0 ? void 0 : options.mutationObserver) ? observeSubNodes(root) : renderObservable(this);
+                    this[observableProperty] = observable.pipe(cjsExports.startWith(), cjsExports.map(() => Array.from(root.querySelectorAll(selector))), cjsExports.distinctUntilChanged((previous, current) => {
+                        if (previous.length !== current.length) {
+                            return false;
+                        }
+                        for (let i = 0; i < previous.length; i++) {
+                            if (previous[i] !== current[i]) {
+                                return false;
+                            }
+                        }
+                        return true;
+                    }), cjsExports.shareReplay(1));
+                }
+                return this[observableProperty];
+            },
+        };
+        Object.defineProperty(target, property, descriptor);
     };
-    Object.defineProperty(target, property, descriptor);
-  };
 }
 
 /**
@@ -524,15 +147,15 @@ function QuerySelectorAll(selector, options) {
  * can disable this behavior by passing `false` as second argument.
  */
 function scheduleRender(cmp, nextTick = true) {
-  return (source) => {
-    return source.pipe(tap(() => {
-      if (!nextTick) {
-        forceUpdate(cmp);
-        return;
-      }
-      Promise.resolve().then(() => forceUpdate(cmp));
-    }));
-  };
+    return (source) => {
+        return source.pipe(cjsExports.tap(() => {
+            if (!nextTick) {
+                forceUpdate(cmp);
+                return;
+            }
+            Promise.resolve().then(() => forceUpdate(cmp));
+        }));
+    };
 }
 
 /**
@@ -542,14 +165,14 @@ function scheduleRender(cmp, nextTick = true) {
  * observable).
  */
 function toProperty(cmp, property) {
-  // ensure that the property is defined on the component.
-  getPropertyDescriptor(cmp, property);
-  // @ts-ignore
-  return (source) => {
-    return source.pipe(tap((value) => {
-      cmp[property] = value;
-    }));
-  };
+    // ensure that the property is defined on the component.
+    getPropertyDescriptor(cmp, property);
+    // @ts-ignore
+    return (source) => {
+        return source.pipe(cjsExports.tap((value) => {
+            cmp[property] = value;
+        }));
+    };
 }
 
 /**
@@ -569,18 +192,18 @@ let disconnectObservables = new WeakMap();
  * {@internal}
  */
 let createUsingDisconnectedCallback = function (cmp) {
-  let previousDisconnected = cmp.disconnectedCallback;
-  if (!previousDisconnected) {
-    throw new Error(`Component "${cmp.constructor.name}" does not have a "disconnectedCallback()" method defined.`);
-  }
-  let disconnectedSubject$ = new Subject();
-  cmp.disconnectedCallback = function () {
-    if (previousDisconnected) {
-      previousDisconnected.call(cmp);
+    let previousDisconnected = cmp.disconnectedCallback;
+    if (!previousDisconnected) {
+        throw new Error(`Component "${cmp.constructor.name}" does not have a "disconnectedCallback()" method defined.`);
     }
-    disconnectedSubject$.next();
-  };
-  return disconnectedSubject$.asObservable();
+    let disconnectedSubject$ = new cjsExports.Subject();
+    cmp.disconnectedCallback = function () {
+        if (previousDisconnected) {
+            previousDisconnected.call(cmp);
+        }
+        disconnectedSubject$.next();
+    };
+    return disconnectedSubject$.asObservable();
 };
 /**
  * Mutation observer is our next heuristic. We will monitor parent
@@ -592,32 +215,32 @@ let createUsingDisconnectedCallback = function (cmp) {
  * {@internal}
  */
 let createUsingMutationObserver = function (cmp) {
-  let element = getElement(cmp);
-  if (null === element.parentNode) {
-    throw new Error(`Component "${cmp.constructor.name}" is not within DOM.`);
-  }
-  return new Observable((observer) => {
-    let mutationObserver = new MutationObserver((mutations) => {
-      mutations.forEach((record) => {
-        for (let node of Array.from(record.removedNodes)) {
-          if (node !== element) {
-            continue;
-          }
-          observer.next();
-          observer.complete();
-        }
-      });
-    });
-    mutationObserver.observe(element.parentNode, {
-      childList: true,
-      subtree: true,
+    let element = getElement(cmp);
+    if (null === element.parentNode) {
+        throw new Error(`Component "${cmp.constructor.name}" is not within DOM.`);
+    }
+    return new cjsExports.Observable((observer) => {
+        let mutationObserver = new MutationObserver((mutations) => {
+            mutations.forEach((record) => {
+                for (let node of Array.from(record.removedNodes)) {
+                    if (node !== element) {
+                        continue;
+                    }
+                    observer.next();
+                    observer.complete();
+                }
+            });
+        });
+        mutationObserver.observe(element.parentNode, {
+            childList: true,
+            subtree: true,
+        });
+        return () => {
+            mutationObserver.disconnect();
+            // we can not re-use this observable, so we have to delete it
+            disconnectObservables.delete(cmp);
+        };
     });
-    return () => {
-      mutationObserver.disconnect();
-      // we can not re-use this observable, so we have to delete it
-      disconnectObservables.delete(cmp);
-    };
-  });
 };
 /**
  * Creates an observable that emits a value when the component
@@ -626,35 +249,33 @@ let createUsingMutationObserver = function (cmp) {
  * {@internal}
  */
 function createDisconnectObservable(cmp) {
-  let functions = [
-    createUsingDisconnectedCallback,
-    createUsingMutationObserver,
-  ];
-  for (let fn of functions) {
-    try {
-      disconnectObservables.set(cmp, fn(cmp));
-      return;
-    }
-    catch (e) {
-      // noop
+    let functions = [
+        createUsingDisconnectedCallback,
+        createUsingMutationObserver,
+    ];
+    for (let fn of functions) {
+        try {
+            disconnectObservables.set(cmp, fn(cmp));
+            return;
+        }
+        catch (e) {
+            // noop
+        }
     }
-  }
-  throw new Error(`Could not create disconnect observable for component "${cmp.constructor.name}".`);
+    throw new Error(`Could not create disconnect observable for component "${cmp.constructor.name}".`);
 }
 /**
  * Operator that unsubscribes from the source observable when
  * the component is disconnected from DOM.
  */
 function untilDisconnected(cmp) {
-  return (source) => {
-    if (!disconnectObservables.has(cmp)) {
-      createDisconnectObservable(cmp);
-    }
-    let disconnectObservable$ = disconnectObservables.get(cmp);
-    return source.pipe(takeUntil(disconnectObservable$));
-  };
+    return (source) => {
+        if (!disconnectObservables.has(cmp)) {
+            createDisconnectObservable(cmp);
+        }
+        let disconnectObservable$ = disconnectObservables.get(cmp);
+        return source.pipe(cjsExports.takeUntil(disconnectObservable$));
+    };
 }
 
-export { QuerySelector, QuerySelectorAll, mutationObservable, propertiesObservable, renderObservable, scheduleRender, toProperty, untilDisconnected };
-
-//# sourceMappingURL=index.js.map
+export { QuerySelector, QuerySelectorAll, mutationObservable, propertiesObservable, propertyObservable, renderObservable, scheduleRender, toProperty, untilDisconnected };