@runopencode/rx-stencil 0.4.1 → 0.4.3

package/dist/esm/index.js

@@ -1,307 +1,29 @@
-import { g as getElement, f as forceUpdate } from './index-9102de09.js';
-import { S as Subject, o as operate, c as createOperatorSubscriber, i as innerFrom, e as executeSchedule, a as isFunction, b as identity, f as from, p as popScheduler, d as SafeSubscriber, n as noop, O as Observable, g as distinctUntilChanged, h as getPropertyDescriptor } from './set-property-7fa82bef.js';
-export { j as propertyObservable, s as setProperty } from './set-property-7fa82bef.js';
+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';
 
-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++));
-        }));
-    });
-}
-
-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();
+function mutationObservable(target, options) {
+    return new cjsExports.Observable((observer) => {
+        let mutation = new MutationObserver((mutations) => {
+            observer.next(mutations);
+        });
+        mutation.observe(target, options);
+        return () => {
+            mutation.disconnect();
         };
-        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);
+/**
+ * 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 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;
-}
-
-function mutationObservable(target, options) {
-  return new Observable((observer) => {
-    let mutation = new MutationObserver((mutations) => {
-      observer.next(mutations);
-    });
-    mutation.observe(target, options);
-    return () => {
-      mutation.disconnect();
-    };
-  });
+    return cjsExports.combineLatest(properties.map((property) => {
+        return propertyObservable(cmp, property);
+    }));
 }
 
 /**
@@ -310,21 +32,21 @@ function mutationObservable(target, options) {
  * 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;
+        };
+    });
 }
 
 /**
@@ -334,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.
@@ -359,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);
-  };
 }
 
 /**
@@ -386,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);
-  };
 }
 
 /**
@@ -425,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));
+        }));
+    };
 }
 
 /**
@@ -443,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;
+        }));
+    };
 }
 
 /**
@@ -470,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
@@ -493,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
@@ -527,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, renderObservable, scheduleRender, toProperty, untilDisconnected };
-
-//# sourceMappingURL=index.js.map
+export { QuerySelector, QuerySelectorAll, mutationObservable, propertiesObservable, propertyObservable, renderObservable, scheduleRender, toProperty, untilDisconnected };