@tstdl/base 0.85.13 → 0.86.0-beta1

package/rpc/rpc.js

@@ -1,271 +1,259 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var rpc_exports = {};
-__export(rpc_exports, {
-  Rpc: () => Rpc
-});
-module.exports = __toCommonJS(rpc_exports);
-var import_not_implemented_error = require("../error/not-implemented.error.js");
-var import_serializer = require("../serializer/index.js");
-var import_object = require("../utils/object/object.js");
-var import_proxy = require("../utils/proxy.js");
-var import_random = require("../utils/random.js");
-var import_throw = require("../utils/throw.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_rxjs = require("rxjs");
-var import_message_port_rpc_endpoint = require("./endpoints/message-port.rpc-endpoint.js");
-var import_model = require("./model.js");
-var import_rpc_endpoint = require("./rpc-endpoint.js");
-var import_rpc_error = require("./rpc-error.js");
-const markedTransfers = /* @__PURE__ */ new WeakMap();
-const serializationTargets = /* @__PURE__ */ new WeakMap();
-const proxyTargets = /* @__PURE__ */ new WeakSet();
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { NotImplementedError } from '../error/not-implemented.error.js';
+import { deserialize, registerSerializer, serialize } from '../serializer/index.js';
+import { hasOwnProperty } from '../utils/object/object.js';
+import { reflectMethods } from '../utils/proxy.js';
+import { getRandomString } from '../utils/random.js';
+import { _throw } from '../utils/throw.js';
+import { assert, isDefined } from '../utils/type-guards.js';
+import { filter, Subject, takeUntil } from 'rxjs';
+import { MessagePortRpcEndpoint } from './endpoints/message-port.rpc-endpoint.js';
+import { createRpcMessage } from './model.js';
+import { RpcEndpoint } from './rpc-endpoint.js';
+import { RpcError, RpcRemoteError } from './rpc-error.js';
+const markedTransfers = new WeakMap();
+const serializationTargets = new WeakMap();
+const proxyTargets = new WeakSet();
 const proxyFinalizationRegistry = new FinalizationRegistry(async (data) => {
-  const message = (0, import_model.createRpcMessage)("release-proxy", { proxyId: data.id });
-  await data.endpoint.postMessage(message);
+    const message = createRpcMessage('release-proxy', { proxyId: data.id });
+    await data.endpoint.postMessage(message);
 });
-const Rpc = {
-  async connect(endpointOrSource, name = "default") {
-    const endpoint = endpointOrSource instanceof import_rpc_endpoint.RpcEndpoint ? endpointOrSource : new import_message_port_rpc_endpoint.MessagePortRpcEndpoint(endpointOrSource);
-    endpoint.start();
-    const connectMessage = (0, import_model.createRpcMessage)("connect", { name });
-    const response = await endpoint.request(connectMessage);
-    (0, import_type_guards.assert)(response.type == "proxy", "Rpc connect must result in proxy.");
-    return parseRpcMessageValue(response, endpoint);
-  },
-  expose(object, endpointOrSource, name = "default") {
-    const endpoint = endpointOrSource instanceof import_rpc_endpoint.RpcEndpoint ? endpointOrSource : new import_message_port_rpc_endpoint.MessagePortRpcEndpoint(endpointOrSource);
-    endpoint.start();
-    exposeConnectable(object, endpoint, name);
-  },
-  /**
-   * mark object for proxy forward
-   * @param object object to forward as proxy
-   * @param root if object is a child of the actual passed value (to function calls, returns or whatever), this must be set to to mark the parent for serialization (required for children proxies)
-   * @returns
-   */
-  proxy(object, root) {
-    proxyTargets.add(object);
-    if ((0, import_type_guards.isDefined)(root)) {
-      Rpc.serialize(root);
-    }
-    return object;
-  },
-  transfer(object, transfer) {
-    markedTransfers.set(object, transfer);
-    return object;
-  },
-  serialize(object, options) {
-    serializationTargets.set(object, options);
-    return object;
-  },
-  isProxied(object) {
-    return proxyTargets.has(object);
-  }
-};
-function createProxy(endpoint, id, path = []) {
-  class RpcProxy2 {
-  }
-  let proxy;
-  const handlers = {
-    apply(_target, _this, args) {
-      const postMessageData = getPostMessageDataFromArray(args, endpoint);
-      const message = (0, import_model.createRpcMessage)("apply", { proxyId: id, path, args: postMessageData.value });
-      return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
+export const Rpc = {
+    async connect(endpointOrSource, name = 'default') {
+        const endpoint = (endpointOrSource instanceof RpcEndpoint) ? endpointOrSource : new MessagePortRpcEndpoint(endpointOrSource);
+        endpoint.start();
+        const connectMessage = createRpcMessage('connect', { name });
+        const response = await endpoint.request(connectMessage);
+        assert(response.type == 'proxy', 'Rpc connect must result in proxy.');
+        return parseRpcMessageValue(response, endpoint);
     },
-    construct(_target, args) {
-      const postMessageData = getPostMessageDataFromArray(args, endpoint);
-      const message = (0, import_model.createRpcMessage)("construct", { proxyId: id, path, args: postMessageData.value });
-      return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+    expose(object, endpointOrSource, name = 'default') {
+        const endpoint = (endpointOrSource instanceof RpcEndpoint) ? endpointOrSource : new MessagePortRpcEndpoint(endpointOrSource);
+        endpoint.start();
+        exposeConnectable(object, endpoint, name);
     },
-    get(_target, property) {
-      if (property == "then") {
-        if (path.length == 0) {
-          return { then: () => proxy };
+    /**
+     * mark object for proxy forward
+     * @param object object to forward as proxy
+     * @param root if object is a child of the actual passed value (to function calls, returns or whatever), this must be set to to mark the parent for serialization (required for children proxies)
+     * @returns
+     */
+    proxy(object, root) {
+        proxyTargets.add(object);
+        if (isDefined(root)) {
+            Rpc.serialize(root);
         }
-        const message = (0, import_model.createRpcMessage)("get", { proxyId: id, path });
-        const resultValue = endpoint.request(message).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
-        return resultValue.then.bind(resultValue);
-      }
-      return createProxy(endpoint, id, [...path, property]);
+        return object;
+    },
+    transfer(object, transfer) {
+        markedTransfers.set(object, transfer);
+        return object;
     },
-    set(_target, property, value) {
-      const postMessageData = getPostMessageData(value, endpoint);
-      const message = (0, import_model.createRpcMessage)("set", { proxyId: id, path: [...path, property], value: postMessageData.value });
-      return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+    serialize(object, options) {
+        serializationTargets.set(object, options);
+        return object;
     },
-    getPrototypeOf() {
-      return null;
+    isProxied(object) {
+        return proxyTargets.has(object);
     }
-  };
-  for (const method of import_proxy.reflectMethods) {
-    if (!(0, import_object.hasOwnProperty)(handlers, method)) {
-      handlers[method] = () => {
-        throw new Error(`${method} not supported on rpc proxies.`);
-      };
+};
+function createProxy(endpoint, id, path = []) {
+    class RpcProxy {
     }
-  }
-  proxy = new Proxy(RpcProxy2, handlers);
-  proxyFinalizationRegistry.register(proxy, { id, endpoint });
-  return proxy;
-}
-function exposeConnectable(object, endpoint, name) {
-  endpoint.message$.pipe((0, import_rxjs.filter)((message) => message.type == "connect"), (0, import_rxjs.filter)((message) => message.name == name)).subscribe(async (message) => {
-    try {
-      const [proxy, transfer] = createProxyValue(object, endpoint);
-      await endpoint.respond(message.id, proxy, transfer);
-    } catch (error) {
-      await endpoint.respond(message.id, { type: "throw", error });
+    // eslint-disable-next-line prefer-const
+    let proxy;
+    const handlers = {
+        apply(_target, _this, args) {
+            const postMessageData = getPostMessageDataFromArray(args, endpoint);
+            const message = createRpcMessage('apply', { proxyId: id, path, args: postMessageData.value });
+            return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+        },
+        construct(_target, args) {
+            const postMessageData = getPostMessageDataFromArray(args, endpoint);
+            const message = createRpcMessage('construct', { proxyId: id, path, args: postMessageData.value });
+            return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+        },
+        get(_target, property) {
+            if (property == 'then') {
+                if (path.length == 0) {
+                    return { then: () => proxy };
+                }
+                const message = createRpcMessage('get', { proxyId: id, path });
+                const resultValue = endpoint.request(message).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+                return resultValue.then.bind(resultValue);
+            }
+            return createProxy(endpoint, id, [...path, property]);
+        },
+        set(_target, property, value) {
+            const postMessageData = getPostMessageData(value, endpoint);
+            const message = createRpcMessage('set', { proxyId: id, path: [...path, property], value: postMessageData.value });
+            return endpoint.request(message, postMessageData.transfer).then((responseValue) => parseRpcMessageValue(responseValue, endpoint));
+        },
+        getPrototypeOf() {
+            return null;
+        }
+    };
+    for (const method of reflectMethods) {
+        if (!hasOwnProperty(handlers, method)) {
+            handlers[method] = () => {
+                throw new Error(`${method} not supported on rpc proxies.`);
+            };
+        }
     }
-  });
+    proxy = new Proxy(RpcProxy, handlers);
+    proxyFinalizationRegistry.register(proxy, { id, endpoint });
+    return proxy;
 }
-function exposeObject(object, endpoint, proxyId) {
-  const abortSubject = new import_rxjs.Subject();
-  endpoint.message$.pipe((0, import_rxjs.takeUntil)(abortSubject), (0, import_rxjs.filter)((message) => message.proxyId == proxyId)).subscribe(async (message) => {
-    try {
-      switch (message.type) {
-        case "get": {
-          const { value } = deref(object, message.path);
-          const postMessageData = getPostMessageData(await value, endpoint);
-          await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
-          break;
-        }
-        case "set": {
-          const { value } = deref(object, message.path, true);
-          const result = Reflect.set(value, message.path[message.path.length - 1], parseRpcMessageValue(message.value, endpoint));
-          const postMessageData = getPostMessageData(result, endpoint);
-          await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
-          break;
+function exposeConnectable(object, endpoint, name) {
+    endpoint.message$
+        .pipe(filter((message) => message.type == 'connect'), filter((message) => message.name == name))
+        .subscribe(async (message) => {
+        try {
+            const [proxy, transfer] = createProxyValue(object, endpoint);
+            await endpoint.respond(message.id, proxy, transfer);
         }
-        case "apply": {
-          const { parent, value } = deref(object, message.path);
-          const result = await Reflect.apply(value, parent, parseRpcMessageValues(message.args, endpoint));
-          const postMessageData = getPostMessageData(result, endpoint);
-          await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
-          break;
+        catch (error) {
+            await endpoint.respond(message.id, { type: 'throw', error });
         }
-        case "construct": {
-          const { value } = deref(object, message.path);
-          const result = Reflect.construct(value, parseRpcMessageValues(message.args, endpoint));
-          const [proxy, transfer] = createProxyValue(result, endpoint);
-          await endpoint.respond(message.id, proxy, transfer);
-          break;
+    });
+}
+function exposeObject(object, endpoint, proxyId) {
+    const abortSubject = new Subject();
+    endpoint.message$
+        .pipe(takeUntil(abortSubject), filter((message) => (message.proxyId == proxyId)))
+        .subscribe(async (message) => {
+        try {
+            switch (message.type) {
+                case 'get': {
+                    const { value } = deref(object, message.path);
+                    const postMessageData = getPostMessageData(await value, endpoint);
+                    await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
+                    break;
+                }
+                case 'set': {
+                    const { value } = deref(object, message.path, true);
+                    const result = Reflect.set(value, message.path[message.path.length - 1], parseRpcMessageValue(message.value, endpoint));
+                    const postMessageData = getPostMessageData(result, endpoint);
+                    await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
+                    break;
+                }
+                case 'apply': {
+                    const { parent, value } = deref(object, message.path);
+                    const result = await Reflect.apply(value, parent, parseRpcMessageValues(message.args, endpoint));
+                    const postMessageData = getPostMessageData(result, endpoint);
+                    await endpoint.respond(message.id, postMessageData.value, postMessageData.transfer);
+                    break;
+                }
+                case 'construct': {
+                    const { value } = deref(object, message.path);
+                    const result = Reflect.construct(value, parseRpcMessageValues(message.args, endpoint));
+                    const [proxy, transfer] = createProxyValue(result, endpoint);
+                    await endpoint.respond(message.id, proxy, transfer);
+                    break;
+                }
+                case 'release-proxy': {
+                    abortSubject.next();
+                    break;
+                }
+                case 'response':
+                case 'connect':
+                    // we do not handle these here
+                    break;
+                default:
+                    throw new NotImplementedError(`Unsupported message type ${message.type}`);
+            }
         }
-        case "release-proxy": {
-          abortSubject.next();
-          break;
+        catch (error) {
+            await endpoint.respond(message.id, { type: 'throw', error });
         }
-        case "response":
-        case "connect":
-          break;
-        default:
-          throw new import_not_implemented_error.NotImplementedError(`Unsupported message type ${message.type}`);
-      }
-    } catch (error) {
-      await endpoint.respond(message.id, { type: "throw", error });
-    }
-  });
+    });
 }
 function getPostMessageDataFromArray(values, endpoint) {
-  const mappedValues = values.map((value) => getRpcMessageValue(value, endpoint));
-  const transfer = values.flatMap((value) => markedTransfers.get(value) ?? []);
-  const messageValues = mappedValues.map((mappedValue) => mappedValue[0]);
-  const additionalTransfers = mappedValues.flatMap((mappedValue) => mappedValue[1]);
-  return { value: messageValues, transfer: [...transfer, ...additionalTransfers] };
+    const mappedValues = values.map((value) => getRpcMessageValue(value, endpoint));
+    const transfer = values.flatMap((value) => markedTransfers.get(value) ?? []);
+    const messageValues = mappedValues.map((mappedValue) => mappedValue[0]);
+    const additionalTransfers = mappedValues.flatMap((mappedValue) => mappedValue[1]);
+    return { value: messageValues, transfer: [...transfer, ...additionalTransfers] };
 }
 function getPostMessageData(value, endpoint) {
-  const [messageValue, additionalTransfers] = getRpcMessageValue(value, endpoint);
-  const transfer = markedTransfers.get(value) ?? [];
-  return { value: messageValue, transfer: [...transfer, ...additionalTransfers] };
+    const [messageValue, additionalTransfers] = getRpcMessageValue(value, endpoint);
+    const transfer = markedTransfers.get(value) ?? [];
+    return { value: messageValue, transfer: [...transfer, ...additionalTransfers] };
 }
 function getRpcMessageValue(value, endpoint) {
-  if (proxyTargets.has(value)) {
-    return createProxyValue(value, endpoint);
-  }
-  if (serializationTargets.has(value)) {
-    const options = serializationTargets.get(value);
-    const transfer = [];
-    const replacer = getRpcProxySerializationReplacer(endpoint, transfer);
-    const serialized = (0, import_serializer.serialize)(value, { ...options, replacers: [replacer, ...options?.replacers ?? []] });
-    return [{ type: "serialized", value: serialized, options }, transfer];
-  }
-  return [{ type: "raw", value }, []];
+    if (proxyTargets.has(value)) {
+        return createProxyValue(value, endpoint);
+    }
+    if (serializationTargets.has(value)) {
+        const options = serializationTargets.get(value);
+        const transfer = [];
+        const replacer = getRpcProxySerializationReplacer(endpoint, transfer);
+        const serialized = serialize(value, { ...options, replacers: [replacer, ...options?.replacers ?? []] });
+        return [{ type: 'serialized', value: serialized, options }, transfer];
+    }
+    return [{ type: 'raw', value }, []];
 }
 function createProxyValue(value, endpoint) {
-  const id = (0, import_random.getRandomString)(24);
-  if (endpoint.supportsTransfers) {
-    const { port1, port2 } = new MessageChannel();
-    const newEndpoint = new import_message_port_rpc_endpoint.MessagePortRpcEndpoint(port1);
-    newEndpoint.start();
-    exposeObject(value, newEndpoint, id);
-    return [{ type: "proxy", id, port: port2 }, [port2]];
-  }
-  exposeObject(value, endpoint, id);
-  return [{ type: "proxy", id }, []];
+    const id = getRandomString(24);
+    if (endpoint.supportsTransfers) {
+        const { port1, port2 } = new MessageChannel();
+        const newEndpoint = new MessagePortRpcEndpoint(port1);
+        newEndpoint.start();
+        exposeObject(value, newEndpoint, id);
+        return [{ type: 'proxy', id, port: port2 }, [port2]];
+    }
+    exposeObject(value, endpoint, id);
+    return [{ type: 'proxy', id }, []];
 }
 function parseRpcMessageValues(values, endpoint) {
-  return values.map((value) => parseRpcMessageValue(value, endpoint));
+    return values.map((value) => parseRpcMessageValue(value, endpoint));
 }
 function parseRpcMessageValue(value, endpoint) {
-  switch (value.type) {
-    case "raw": {
-      return value.value;
-    }
-    case "serialized": {
-      return (0, import_serializer.deserialize)(value.value, { ...value.options, data: { ...value.options?.data, rpcEndpoint: endpoint } });
-    }
-    case "throw": {
-      const remoteError = new import_rpc_error.RpcRemoteError(value.error);
-      throw new import_rpc_error.RpcError("Received error from remote.", remoteError);
-    }
-    case "proxy": {
-      const proxyEndpoint = (0, import_type_guards.isDefined)(value.port) ? new import_message_port_rpc_endpoint.MessagePortRpcEndpoint(value.port) : endpoint;
-      proxyEndpoint.start();
-      return createProxy(proxyEndpoint, value.id);
+    switch (value.type) {
+        case 'raw': {
+            return value.value;
+        }
+        case 'serialized': {
+            return deserialize(value.value, { ...value.options, data: { ...value.options?.data, rpcEndpoint: endpoint } });
+        }
+        case 'throw': {
+            const remoteError = new RpcRemoteError(value.error);
+            throw new RpcError('Received error from remote.', remoteError);
+        }
+        case 'proxy': {
+            const proxyEndpoint = (isDefined(value.port)) ? new MessagePortRpcEndpoint(value.port) : endpoint;
+            proxyEndpoint.start();
+            return createProxy(proxyEndpoint, value.id);
+        }
+        default:
+            throw new Error(`Type ${value.type} not supported`);
     }
-    default:
-      throw new Error(`Type ${value.type} not supported`);
-  }
 }
 function deref(object, path, skipLast = false) {
-  let parent;
-  let value = object;
-  const end = skipLast ? path.length - 1 : path.length;
-  for (let i = 0; i < end; i++) {
-    const segment = path[i];
-    const newValue = value[segment];
-    parent = value;
-    value = newValue;
-  }
-  return { parent, value };
+    let parent;
+    let value = object;
+    const end = skipLast ? path.length - 1 : path.length;
+    for (let i = 0; i < end; i++) {
+        const segment = path[i];
+        const newValue = value[segment];
+        parent = value;
+        value = newValue;
+    }
+    return { parent, value };
 }
 class RpcProxy {
 }
-(0, import_serializer.registerSerializer)(RpcProxy, "RpcProxy", () => (0, import_throw._throw)(new Error("Not supported.")), (data, _, { rpcEndpoint }) => parseRpcMessageValue({ type: "proxy", ...data }, rpcEndpoint));
+registerSerializer(RpcProxy, 'RpcProxy', () => _throw(new Error('Not supported.')), (data, _, { rpcEndpoint }) => parseRpcMessageValue({ type: 'proxy', ...data }, rpcEndpoint));
 function getRpcProxySerializationReplacer(endpoint, transfer) {
-  function rpcProxySerializationReplacer(value) {
-    if (!proxyTargets.has(value)) {
-      return value;
+    function rpcProxySerializationReplacer(value) {
+        if (!proxyTargets.has(value)) {
+            return value;
+        }
+        const [proxy, proxyTransfer] = createProxyValue(value, endpoint);
+        transfer.push(...proxyTransfer);
+        return { '<RpcProxy>': { id: proxy.id, port: proxy.port } };
     }
-    const [proxy, proxyTransfer] = createProxyValue(value, endpoint);
-    transfer.push(...proxyTransfer);
-    return { "<RpcProxy>": { id: proxy.id, port: proxy.port } };
-  }
-  return rpcProxySerializationReplacer;
+    return rpcProxySerializationReplacer;
 }

package/rxjs/cast.js

@@ -1,30 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cast_exports = {};
-__export(cast_exports, {
-  cast: () => cast,
-  forceCast: () => forceCast
-});
-module.exports = __toCommonJS(cast_exports);
-function cast() {
-  return (source) => source;
+export function cast() {
+    return (source) => source;
 }
-function forceCast() {
-  return (source) => source;
+export function forceCast() {
+    return (source) => source;
 }

package/rxjs/index.js

@@ -1,29 +1,12 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var rxjs_exports = {};
-module.exports = __toCommonJS(rxjs_exports);
-__reExport(rxjs_exports, require("./cast.js"), module.exports);
-__reExport(rxjs_exports, require("./intersection-observer.js"), module.exports);
-__reExport(rxjs_exports, require("./media-query.js"), module.exports);
-__reExport(rxjs_exports, require("./mutation-observer.js"), module.exports);
-__reExport(rxjs_exports, require("./noop.js"), module.exports);
-__reExport(rxjs_exports, require("./performance-observer.js"), module.exports);
-__reExport(rxjs_exports, require("./resize-observer.js"), module.exports);
-__reExport(rxjs_exports, require("./retry-backoff.js"), module.exports);
-__reExport(rxjs_exports, require("./slow-array.js"), module.exports);
-__reExport(rxjs_exports, require("./teardown.js"), module.exports);
-__reExport(rxjs_exports, require("./timing.js"), module.exports);
-__reExport(rxjs_exports, require("./touch.js"), module.exports);
+export * from './cast.js';
+export * from './intersection-observer.js';
+export * from './media-query.js';
+export * from './mutation-observer.js';
+export * from './noop.js';
+export * from './performance-observer.js';
+export * from './resize-observer.js';
+export * from './retry-backoff.js';
+export * from './slow-array.js';
+export * from './teardown.js';
+export * from './timing.js';
+export * from './touch.js';