@opendesign-plus/components 0.0.1-rc.10 → 0.0.1-rc.101

package/dist/treeshaking/_virtual/mux.js/lib/tools/parse-sidx.js.mjs

@@ -0,0 +1,39 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+import { require_numbers } from "../utils/numbers.js.mjs";
+// ../../node_modules/.pnpm/mux.js@7.1.0/node_modules/mux.js/lib/tools/parse-sidx.js
+var require_parse_sidx = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getUint64 = require_numbers().getUint64;
+	var parseSidx = function(data) {
+		var view = new DataView(data.buffer, data.byteOffset, data.byteLength), result = {
+			version: data[0],
+			flags: new Uint8Array(data.subarray(1, 4)),
+			references: [],
+			referenceId: view.getUint32(4),
+			timescale: view.getUint32(8)
+		}, i = 12;
+		if (result.version === 0) {
+			result.earliestPresentationTime = view.getUint32(i);
+			result.firstOffset = view.getUint32(i + 4);
+			i += 8;
+		} else {
+			result.earliestPresentationTime = getUint64(data.subarray(i));
+			result.firstOffset = getUint64(data.subarray(i + 8));
+			i += 16;
+		}
+		i += 2;
+		var referenceCount = view.getUint16(i);
+		i += 2;
+		for (; referenceCount > 0; i += 12, referenceCount--) result.references.push({
+			referenceType: (data[i] & 128) >>> 7,
+			referencedSize: view.getUint32(i) & 2147483647,
+			subsegmentDuration: view.getUint32(i + 4),
+			startsWithSap: !!(data[i + 8] & 128),
+			sapType: (data[i + 8] & 112) >>> 4,
+			sapDeltaTime: view.getUint32(i + 8) & 268435455
+		});
+		return result;
+	};
+	module.exports = parseSidx;
+}));
+export default require_parse_sidx();
+export { require_parse_sidx };

package/dist/treeshaking/_virtual/mux.js/lib/utils/clock.js.mjs

@@ -0,0 +1,44 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+// ../../node_modules/.pnpm/mux.js@7.1.0/node_modules/mux.js/lib/utils/clock.js
+var require_clock = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* mux.js
+	*
+	* Copyright (c) Brightcove
+	* Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
+	*/
+	var ONE_SECOND_IN_TS = 9e4;
+	var secondsToVideoTs = function(seconds) {
+		return seconds * ONE_SECOND_IN_TS;
+	};
+	var secondsToAudioTs = function(seconds, sampleRate) {
+		return seconds * sampleRate;
+	};
+	var videoTsToSeconds = function(timestamp) {
+		return timestamp / ONE_SECOND_IN_TS;
+	};
+	var audioTsToSeconds = function(timestamp, sampleRate) {
+		return timestamp / sampleRate;
+	};
+	var audioTsToVideoTs = function(timestamp, sampleRate) {
+		return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));
+	};
+	var videoTsToAudioTs = function(timestamp, sampleRate) {
+		return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);
+	};
+	var metadataTsToSeconds = function(timestamp, timelineStartPts, keepOriginalTimestamps) {
+		return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);
+	};
+	module.exports = {
+		ONE_SECOND_IN_TS,
+		secondsToVideoTs,
+		secondsToAudioTs,
+		videoTsToSeconds,
+		audioTsToSeconds,
+		audioTsToVideoTs,
+		videoTsToAudioTs,
+		metadataTsToSeconds
+	};
+}));
+export default require_clock();
+export { require_clock };

package/dist/treeshaking/_virtual/mux.js/lib/utils/numbers.js.mjs

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+// ../../node_modules/.pnpm/mux.js@7.1.0/node_modules/mux.js/lib/utils/numbers.js
+var require_numbers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var MAX_UINT32 = Math.pow(2, 32);
+	var getUint64 = function(uint8) {
+		var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+		var value;
+		if (dv.getBigUint64) {
+			value = dv.getBigUint64(0);
+			if (value < Number.MAX_SAFE_INTEGER) return Number(value);
+			return value;
+		}
+		return dv.getUint32(0) * MAX_UINT32 + dv.getUint32(4);
+	};
+	module.exports = {
+		getUint64,
+		MAX_UINT32
+	};
+}));
+export default require_numbers();
+export { require_numbers };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/NotificationFactories.js.mjs

@@ -0,0 +1,18 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
+var COMPLETE_NOTIFICATION = (function() {
+	return createNotification("C", void 0, void 0);
+})();
+function errorNotification(error) {
+	return createNotification("E", void 0, error);
+}
+function nextNotification(value) {
+	return createNotification("N", value, void 0);
+}
+function createNotification(kind, value, error) {
+	return {
+		kind,
+		value,
+		error
+	};
+}
+export { COMPLETE_NOTIFICATION, createNotification, errorNotification, nextNotification };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/Observable.js.mjs

@@ -0,0 +1,95 @@
+import { isFunction } from "./util/isFunction.js.mjs";
+import { isSubscription } from "./Subscription.js.mjs";
+import { config } from "./config.js.mjs";
+import { errorContext } from "./util/errorContext.js.mjs";
+import { SafeSubscriber, Subscriber } from "./Subscriber.js.mjs";
+import { observable } from "./symbol/observable.js.mjs";
+import { pipeFromArray } from "./util/pipe.js.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Observable.js
+var Observable = function() {
+	function Observable(subscribe) {
+		if (subscribe) this._subscribe = subscribe;
+	}
+	Observable.prototype.lift = function(operator) {
+		var observable = new Observable();
+		observable.source = this;
+		observable.operator = operator;
+		return observable;
+	};
+	Observable.prototype.subscribe = function(observerOrNext, error, complete) {
+		var _this = this;
+		var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+		errorContext(function() {
+			var _a = _this, operator = _a.operator, source = _a.source;
+			subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+		});
+		return subscriber;
+	};
+	Observable.prototype._trySubscribe = function(sink) {
+		try {
+			return this._subscribe(sink);
+		} catch (err) {
+			sink.error(err);
+		}
+	};
+	Observable.prototype.forEach = function(next, promiseCtor) {
+		var _this = this;
+		promiseCtor = getPromiseCtor(promiseCtor);
+		return new promiseCtor(function(resolve, reject) {
+			var subscriber = new SafeSubscriber({
+				next: function(value) {
+					try {
+						next(value);
+					} catch (err) {
+						reject(err);
+						subscriber.unsubscribe();
+					}
+				},
+				error: reject,
+				complete: resolve
+			});
+			_this.subscribe(subscriber);
+		});
+	};
+	Observable.prototype._subscribe = function(subscriber) {
+		var _a;
+		return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+	};
+	Observable.prototype[observable] = function() {
+		return this;
+	};
+	Observable.prototype.pipe = function() {
+		var operations = [];
+		for (var _i = 0; _i < arguments.length; _i++) operations[_i] = arguments[_i];
+		return pipeFromArray(operations)(this);
+	};
+	Observable.prototype.toPromise = function(promiseCtor) {
+		var _this = this;
+		promiseCtor = getPromiseCtor(promiseCtor);
+		return new promiseCtor(function(resolve, reject) {
+			var value;
+			_this.subscribe(function(x) {
+				return value = x;
+			}, function(err) {
+				return reject(err);
+			}, function() {
+				return resolve(value);
+			});
+		});
+	};
+	Observable.create = function(subscribe) {
+		return new Observable(subscribe);
+	};
+	return Observable;
+}();
+function getPromiseCtor(promiseCtor) {
+	var _a;
+	return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+	return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+	return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+export { Observable };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/Subscriber.js.mjs

@@ -0,0 +1,152 @@
+import { __extends } from "../../../../tslib/tslib.es6.mjs.mjs";
+import { isFunction } from "./util/isFunction.js.mjs";
+import { Subscription, isSubscription } from "./Subscription.js.mjs";
+import { config } from "./config.js.mjs";
+import { timeoutProvider } from "./scheduler/timeoutProvider.js.mjs";
+import { reportUnhandledError } from "./util/reportUnhandledError.js.mjs";
+import { noop } from "./util/noop.js.mjs";
+import { COMPLETE_NOTIFICATION, errorNotification, nextNotification } from "./NotificationFactories.js.mjs";
+import { captureError } from "./util/errorContext.js.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Subscriber.js
+var Subscriber = function(_super) {
+	__extends(Subscriber, _super);
+	function Subscriber(destination) {
+		var _this = _super.call(this) || this;
+		_this.isStopped = false;
+		if (destination) {
+			_this.destination = destination;
+			if (isSubscription(destination)) destination.add(_this);
+		} else _this.destination = EMPTY_OBSERVER;
+		return _this;
+	}
+	Subscriber.create = function(next, error, complete) {
+		return new SafeSubscriber(next, error, complete);
+	};
+	Subscriber.prototype.next = function(value) {
+		if (this.isStopped) handleStoppedNotification(nextNotification(value), this);
+		else this._next(value);
+	};
+	Subscriber.prototype.error = function(err) {
+		if (this.isStopped) handleStoppedNotification(errorNotification(err), this);
+		else {
+			this.isStopped = true;
+			this._error(err);
+		}
+	};
+	Subscriber.prototype.complete = function() {
+		if (this.isStopped) handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+		else {
+			this.isStopped = true;
+			this._complete();
+		}
+	};
+	Subscriber.prototype.unsubscribe = function() {
+		if (!this.closed) {
+			this.isStopped = true;
+			_super.prototype.unsubscribe.call(this);
+			this.destination = null;
+		}
+	};
+	Subscriber.prototype._next = function(value) {
+		this.destination.next(value);
+	};
+	Subscriber.prototype._error = function(err) {
+		try {
+			this.destination.error(err);
+		} finally {
+			this.unsubscribe();
+		}
+	};
+	Subscriber.prototype._complete = function() {
+		try {
+			this.destination.complete();
+		} finally {
+			this.unsubscribe();
+		}
+	};
+	return Subscriber;
+}(Subscription);
+var _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+	return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = function() {
+	function ConsumerObserver(partialObserver) {
+		this.partialObserver = partialObserver;
+	}
+	ConsumerObserver.prototype.next = function(value) {
+		var partialObserver = this.partialObserver;
+		if (partialObserver.next) try {
+			partialObserver.next(value);
+		} catch (error) {
+			handleUnhandledError(error);
+		}
+	};
+	ConsumerObserver.prototype.error = function(err) {
+		var partialObserver = this.partialObserver;
+		if (partialObserver.error) try {
+			partialObserver.error(err);
+		} catch (error) {
+			handleUnhandledError(error);
+		}
+		else handleUnhandledError(err);
+	};
+	ConsumerObserver.prototype.complete = function() {
+		var partialObserver = this.partialObserver;
+		if (partialObserver.complete) try {
+			partialObserver.complete();
+		} catch (error) {
+			handleUnhandledError(error);
+		}
+	};
+	return ConsumerObserver;
+}();
+var SafeSubscriber = function(_super) {
+	__extends(SafeSubscriber, _super);
+	function SafeSubscriber(observerOrNext, error, complete) {
+		var _this = _super.call(this) || this;
+		var partialObserver;
+		if (isFunction(observerOrNext) || !observerOrNext) partialObserver = {
+			next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+			error: error !== null && error !== void 0 ? error : void 0,
+			complete: complete !== null && complete !== void 0 ? complete : void 0
+		};
+		else {
+			var context_1;
+			if (_this && config.useDeprecatedNextContext) {
+				context_1 = Object.create(observerOrNext);
+				context_1.unsubscribe = function() {
+					return _this.unsubscribe();
+				};
+				partialObserver = {
+					next: observerOrNext.next && bind(observerOrNext.next, context_1),
+					error: observerOrNext.error && bind(observerOrNext.error, context_1),
+					complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+				};
+			} else partialObserver = observerOrNext;
+		}
+		_this.destination = new ConsumerObserver(partialObserver);
+		return _this;
+	}
+	return SafeSubscriber;
+}(Subscriber);
+function handleUnhandledError(error) {
+	if (config.useDeprecatedSynchronousErrorHandling) captureError(error);
+	else reportUnhandledError(error);
+}
+function defaultErrorHandler(err) {
+	throw err;
+}
+function handleStoppedNotification(notification, subscriber) {
+	var onStoppedNotification = config.onStoppedNotification;
+	onStoppedNotification && timeoutProvider.setTimeout(function() {
+		return onStoppedNotification(notification, subscriber);
+	});
+}
+var EMPTY_OBSERVER = {
+	closed: true,
+	next: noop,
+	error: defaultErrorHandler,
+	complete: noop
+};
+export { EMPTY_OBSERVER, SafeSubscriber, Subscriber };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/Subscription.js.mjs

@@ -0,0 +1,113 @@
+import { __read, __spreadArray, __values } from "../../../../tslib/tslib.es6.mjs.mjs";
+import { isFunction } from "./util/isFunction.js.mjs";
+import { UnsubscriptionError } from "./util/UnsubscriptionError.js.mjs";
+import { arrRemove } from "./util/arrRemove.js.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Subscription.js
+var Subscription = function() {
+	function Subscription(initialTeardown) {
+		this.initialTeardown = initialTeardown;
+		this.closed = false;
+		this._parentage = null;
+		this._finalizers = null;
+	}
+	Subscription.prototype.unsubscribe = function() {
+		var e_1, _a, e_2, _b;
+		var errors;
+		if (!this.closed) {
+			this.closed = true;
+			var _parentage = this._parentage;
+			if (_parentage) {
+				this._parentage = null;
+				if (Array.isArray(_parentage)) try {
+					for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) _parentage_1_1.value.remove(this);
+				} catch (e_1_1) {
+					e_1 = { error: e_1_1 };
+				} finally {
+					try {
+						if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+					} finally {
+						if (e_1) throw e_1.error;
+					}
+				}
+				else _parentage.remove(this);
+			}
+			var initialFinalizer = this.initialTeardown;
+			if (isFunction(initialFinalizer)) try {
+				initialFinalizer();
+			} catch (e) {
+				errors = e instanceof UnsubscriptionError ? e.errors : [e];
+			}
+			var _finalizers = this._finalizers;
+			if (_finalizers) {
+				this._finalizers = null;
+				try {
+					for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+						var finalizer = _finalizers_1_1.value;
+						try {
+							execFinalizer(finalizer);
+						} catch (err) {
+							errors = errors !== null && errors !== void 0 ? errors : [];
+							if (err instanceof UnsubscriptionError) errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+							else errors.push(err);
+						}
+					}
+				} catch (e_2_1) {
+					e_2 = { error: e_2_1 };
+				} finally {
+					try {
+						if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+					} finally {
+						if (e_2) throw e_2.error;
+					}
+				}
+			}
+			if (errors) throw new UnsubscriptionError(errors);
+		}
+	};
+	Subscription.prototype.add = function(teardown) {
+		var _a;
+		if (teardown && teardown !== this) {
+			if (this.closed) execFinalizer(teardown);
+			else {
+				if (teardown instanceof Subscription) {
+					if (teardown.closed || teardown._hasParent(this)) return;
+					teardown._addParent(this);
+				}
+				(this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+			}
+		}
+	};
+	Subscription.prototype._hasParent = function(parent) {
+		var _parentage = this._parentage;
+		return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+	};
+	Subscription.prototype._addParent = function(parent) {
+		var _parentage = this._parentage;
+		this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+	};
+	Subscription.prototype._removeParent = function(parent) {
+		var _parentage = this._parentage;
+		if (_parentage === parent) this._parentage = null;
+		else if (Array.isArray(_parentage)) arrRemove(_parentage, parent);
+	};
+	Subscription.prototype.remove = function(teardown) {
+		var _finalizers = this._finalizers;
+		_finalizers && arrRemove(_finalizers, teardown);
+		if (teardown instanceof Subscription) teardown._removeParent(this);
+	};
+	Subscription.EMPTY = (function() {
+		var empty = new Subscription();
+		empty.closed = true;
+		return empty;
+	})();
+	return Subscription;
+}();
+Subscription.EMPTY;
+function isSubscription(value) {
+	return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+	if (isFunction(finalizer)) finalizer();
+	else finalizer.unsubscribe();
+}
+export { Subscription, isSubscription };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/config.js.mjs

@@ -0,0 +1,9 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/config.js
+var config = {
+	onUnhandledError: null,
+	onStoppedNotification: null,
+	Promise: void 0,
+	useDeprecatedSynchronousErrorHandling: false,
+	useDeprecatedNextContext: false
+};
+export { config };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js.mjs

@@ -0,0 +1,17 @@
+import { __read, __spreadArray } from "../../../../../tslib/tslib.es6.mjs.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
+var timeoutProvider = {
+	setTimeout: function(handler, timeout) {
+		var args = [];
+		for (var _i = 2; _i < arguments.length; _i++) args[_i - 2] = arguments[_i];
+		var delegate = timeoutProvider.delegate;
+		if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+		return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+	},
+	clearTimeout: function(handle) {
+		var delegate = timeoutProvider.delegate;
+		return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+	},
+	delegate: void 0
+};
+export { timeoutProvider };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/symbol/observable.js.mjs

@@ -0,0 +1,5 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/symbol/observable.js
+var observable = (function() {
+	return typeof Symbol === "function" && Symbol.observable || "@@observable";
+})();
+export { observable };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/UnsubscriptionError.js.mjs

@@ -0,0 +1,13 @@
+import { createErrorClass } from "./createErrorClass.js.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
+var UnsubscriptionError = createErrorClass(function(_super) {
+	return function UnsubscriptionErrorImpl(errors) {
+		_super(this);
+		this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+			return i + 1 + ") " + err.toString();
+		}).join("\n  ") : "";
+		this.name = "UnsubscriptionError";
+		this.errors = errors;
+	};
+});
+export { UnsubscriptionError };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/arrRemove.js.mjs

@@ -0,0 +1,8 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
+function arrRemove(arr, item) {
+	if (arr) {
+		var index = arr.indexOf(item);
+		0 <= index && arr.splice(index, 1);
+	}
+}
+export { arrRemove };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/createErrorClass.js.mjs

@@ -0,0 +1,12 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
+function createErrorClass(createImpl) {
+	var _super = function(instance) {
+		Error.call(instance);
+		instance.stack = (/* @__PURE__ */ new Error()).stack;
+	};
+	var ctorFunc = createImpl(_super);
+	ctorFunc.prototype = Object.create(Error.prototype);
+	ctorFunc.prototype.constructor = ctorFunc;
+	return ctorFunc;
+}
+export { createErrorClass };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/errorContext.js.mjs

@@ -0,0 +1,25 @@
+import { config } from "../config.js.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/errorContext.js
+var context = null;
+function errorContext(cb) {
+	if (config.useDeprecatedSynchronousErrorHandling) {
+		var isRoot = !context;
+		if (isRoot) context = {
+			errorThrown: false,
+			error: null
+		};
+		cb();
+		if (isRoot) {
+			var _a = context, errorThrown = _a.errorThrown, error = _a.error;
+			context = null;
+			if (errorThrown) throw error;
+		}
+	} else cb();
+}
+function captureError(err) {
+	if (config.useDeprecatedSynchronousErrorHandling && context) {
+		context.errorThrown = true;
+		context.error = err;
+	}
+}
+export { captureError, errorContext };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/identity.js.mjs

@@ -0,0 +1,5 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/identity.js
+function identity(x) {
+	return x;
+}
+export { identity };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/isFunction.js.mjs

@@ -0,0 +1,5 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isFunction.js
+function isFunction(value) {
+	return typeof value === "function";
+}
+export { isFunction };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/noop.js.mjs

@@ -0,0 +1,3 @@
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/noop.js
+function noop() {}
+export { noop };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/pipe.js.mjs

@@ -0,0 +1,12 @@
+import { identity } from "./identity.js.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/pipe.js
+function pipeFromArray(fns) {
+	if (fns.length === 0) return identity;
+	if (fns.length === 1) return fns[0];
+	return function piped(input) {
+		return fns.reduce(function(prev, fn) {
+			return fn(prev);
+		}, input);
+	};
+}
+export { pipeFromArray };

package/dist/treeshaking/_virtual/rxjs/dist/esm5/internal/util/reportUnhandledError.js.mjs

@@ -0,0 +1,11 @@
+import { config } from "../config.js.mjs";
+import { timeoutProvider } from "../scheduler/timeoutProvider.js.mjs";
+// ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
+function reportUnhandledError(err) {
+	timeoutProvider.setTimeout(function() {
+		var onUnhandledError = config.onUnhandledError;
+		if (onUnhandledError) onUnhandledError(err);
+		else throw err;
+	});
+}
+export { reportUnhandledError };