@tstdl/base 0.86.0-beta1 → 0.86.0-beta11

package/reflection/registry.js

@@ -1,118 +1,137 @@
-import { FactoryMap } from '../utils/factory-map.js';
-import { lazyObject, lazyObjectValue } from '../utils/object/lazy-property.js';
-import { getDesignType, getParameterTypes, getReturnType } from '../utils/reflection.js';
-import { isDefined, isUndefined } from '../utils/type-guards.js';
-import { getDecoratorData } from './decorator-data.js';
-import { ReflectionDataMap } from './reflection-data-map.js';
-export class ReflectionRegistry {
-    metadataMap;
-    finalizedTypesSet;
-    constructor() {
-        this.metadataMap = new WeakMap();
-        this.finalizedTypesSet = new WeakSet();
+"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 registry_exports = {};
+__export(registry_exports, {
+  ReflectionRegistry: () => ReflectionRegistry,
+  reflectionRegistry: () => reflectionRegistry
+});
+module.exports = __toCommonJS(registry_exports);
+var import_factory_map = require("../utils/factory-map.js");
+var import_lazy_property = require("../utils/object/lazy-property.js");
+var import_reflection = require("../utils/reflection.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_decorator_data = require("./decorator-data.js");
+var import_reflection_data_map = require("./reflection-data-map.js");
+class ReflectionRegistry {
+  metadataMap;
+  finalizedTypesSet;
+  constructor() {
+    this.metadataMap = /* @__PURE__ */ new WeakMap();
+    this.finalizedTypesSet = /* @__PURE__ */ new WeakSet();
+  }
+  hasType(type) {
+    return this.metadataMap.has(type);
+  }
+  getMetadata(type) {
+    const metadata = this.metadataMap.get(type);
+    if ((0, import_type_guards.isDefined)(metadata) && !this.finalizedTypesSet.has(type)) {
+      metadata.properties = new Map(metadata.properties);
+      metadata.staticProperties = new Map(metadata.staticProperties);
+      metadata.methods = new Map(metadata.methods);
+      metadata.staticMethods = new Map(metadata.staticMethods);
+      this.finalizedTypesSet.add(type);
     }
-    hasType(type) {
-        return this.metadataMap.has(type);
+    return metadata;
+  }
+  register(target, propertyKey, descriptorOrParameterIndex) {
+    const data = (0, import_decorator_data.getDecoratorData)(target, propertyKey, descriptorOrParameterIndex);
+    this.registerDecoratorData(data);
+    return data;
+  }
+  registerDecoratorData(data) {
+    const metadata = this.getOrInitializeMetadata(data.constructor);
+    if (data.type == "class") {
+      return metadata;
+    } else if (data.type == "property" || data.type == "accessor") {
+      const propertyMetadata = (data.static ? metadata.staticProperties : metadata.properties).get(data.propertyKey);
+      propertyMetadata.isAccessor = data.type == "accessor";
+      return propertyMetadata;
+    } else if (data.type == "method") {
+      return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
+    } else if (data.type == "method-parameter") {
+      return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
+    } else if (data.type == "constructor-parameter") {
+      if ((0, import_type_guards.isUndefined)(metadata.parameters)) {
+        throw new Error("Constructor parameters are not available. (missing decoration?)");
+      }
+      return metadata.parameters[data.index];
     }
-    getMetadata(type) {
-        const metadata = this.metadataMap.get(type);
-        if (isDefined(metadata) && !this.finalizedTypesSet.has(type)) {
-            metadata.properties = new Map(metadata.properties);
-            metadata.staticProperties = new Map(metadata.staticProperties);
-            metadata.methods = new Map(metadata.methods);
-            metadata.staticMethods = new Map(metadata.staticMethods);
-            this.finalizedTypesSet.add(type);
-        }
-        return metadata;
+    throw new Error(`Unknown DecoratorData type ${data.type}`);
+  }
+  /**
+   * Unregister a type. Can be useful if you replace a class with an decorator.
+   * However, this should not be necessary since WeakRefs are used.
+   * @param type Type to unregister
+   */
+  unregister(type) {
+    this.metadataMap.delete(type);
+  }
+  getOrInitializeMetadata(type) {
+    if (this.finalizedTypesSet.has(type)) {
+      throw new Error("Reflection data was accessed before registration was done.");
     }
-    register(target, propertyKey, descriptorOrParameterIndex) {
-        const data = getDecoratorData(target, propertyKey, descriptorOrParameterIndex);
-        this.registerDecoratorData(data);
-        return data;
+    if (!this.metadataMap.has(type)) {
+      const metadata = initializeType(type);
+      this.metadataMap.set(type, metadata);
+      return metadata;
     }
-    registerDecoratorData(data) {
-        const metadata = this.getOrInitializeMetadata(data.constructor);
-        if (data.type == 'class') {
-            return metadata;
-        }
-        else if ((data.type == 'property') || (data.type == 'accessor')) {
-            const propertyMetadata = (data.static ? metadata.staticProperties : metadata.properties).get(data.propertyKey);
-            propertyMetadata.isAccessor = data.type == 'accessor';
-            return propertyMetadata;
-        }
-        else if (data.type == 'method') {
-            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
-        }
-        else if (data.type == 'method-parameter') {
-            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
-        }
-        else if (data.type == 'constructor-parameter') { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-            if (isUndefined(metadata.parameters)) {
-                throw new Error('Constructor parameters are not available. (missing decoration?)');
-            }
-            return metadata.parameters[data.index];
-        }
-        throw new Error(`Unknown DecoratorData type ${data.type}`);
-    }
-    /**
-     * Unregister a type. Can be useful if you replace a class with an decorator.
-     * However, this should not be necessary since WeakRefs are used.
-     * @param type Type to unregister
-     */
-    unregister(type) {
-        this.metadataMap.delete(type);
-    }
-    getOrInitializeMetadata(type) {
-        if (this.finalizedTypesSet.has(type)) {
-            throw new Error('Reflection data was accessed before registration was done.');
+    return this.metadataMap.get(type);
+  }
+}
+function initializeType(type) {
+  return (0, import_lazy_property.lazyObject)({
+    metadataType: "type",
+    constructor: (0, import_lazy_property.lazyObjectValue)(type),
+    parent: (0, import_lazy_property.lazyObjectValue)(Reflect.getPrototypeOf(type)),
+    parameters: {
+      initializer() {
+        const parametersTypes = (0, import_reflection.getParameterTypes)(type);
+        return parametersTypes?.map((parameterType, index) => ({ metadataType: "constructor-parameter", index, type: parameterType, data: new import_reflection_data_map.ReflectionDataMap() }));
+      }
+    },
+    properties: {
+      initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type.prototype, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
+    },
+    staticProperties: {
+      initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
+    },
+    methods: {
+      initializer: () => new import_factory_map.FactoryMap((key) => {
+        const parameters = (0, import_reflection.getParameterTypes)(type.prototype, key);
+        const returnType = (0, import_reflection.getReturnType)(type.prototype, key);
+        if ((0, import_type_guards.isUndefined)(parameters)) {
+          throw new Error(`Could not get parameters for method ${key.toString()} of type ${type.name}`);
         }
-        if (!this.metadataMap.has(type)) {
-            const metadata = this.initializeType(type);
-            this.metadataMap.set(type, metadata);
-            return metadata;
+        return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
+      })
+    },
+    staticMethods: {
+      initializer: () => new import_factory_map.FactoryMap((key) => {
+        const parameters = (0, import_reflection.getParameterTypes)(type, key);
+        const returnType = (0, import_reflection.getReturnType)(type, key);
+        if ((0, import_type_guards.isUndefined)(parameters)) {
+          throw new Error(`Could not get parameters for static method ${key.toString()} of type ${type.name}`);
         }
-        return this.metadataMap.get(type);
-    }
-    // eslint-disable-next-line max-lines-per-function
-    initializeType(type) {
-        return lazyObject({
-            metadataType: 'type',
-            constructor: lazyObjectValue(type),
-            parent: lazyObjectValue(Reflect.getPrototypeOf(type)),
-            parameters: {
-                initializer() {
-                    const parametersTypes = getParameterTypes(type);
-                    return parametersTypes?.map((parameterType, index) => ({ metadataType: 'constructor-parameter', index, type: parameterType, data: new ReflectionDataMap() }));
-                }
-            },
-            properties: {
-                initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type.prototype, key), isAccessor: false, data: new ReflectionDataMap() }))
-            },
-            staticProperties: {
-                initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type, key), isAccessor: false, data: new ReflectionDataMap() }))
-            },
-            methods: {
-                initializer: () => new FactoryMap((key) => {
-                    const parameters = getParameterTypes(type.prototype, key);
-                    const returnType = getReturnType(type.prototype, key);
-                    if (isUndefined(parameters)) {
-                        throw new Error(`Could not get parameters for method ${key.toString()} of type ${type.name}`);
-                    }
-                    return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ReflectionDataMap() })), returnType, data: new ReflectionDataMap() };
-                })
-            },
-            staticMethods: {
-                initializer: () => new FactoryMap((key) => {
-                    const parameters = getParameterTypes(type, key);
-                    const returnType = getReturnType(type, key);
-                    if (isUndefined(parameters)) {
-                        throw new Error(`Could not get parameters for static method ${key.toString()} of type ${type.name}`);
-                    }
-                    return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ReflectionDataMap() })), returnType, data: new ReflectionDataMap() };
-                })
-            },
-            data: { initializer: () => new ReflectionDataMap() }
-        });
-    }
+        return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
+      })
+    },
+    data: { initializer: () => new import_reflection_data_map.ReflectionDataMap() }
+  });
 }
-export const reflectionRegistry = new ReflectionRegistry();
+const reflectionRegistry = new ReflectionRegistry();

package/reflection/types.js

@@ -1 +1,16 @@
-export {};
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/reflection/utils.js

@@ -1,111 +1,139 @@
-import { toArray } from '../utils/array/array.js';
-import { noop } from '../utils/noop.js';
-import { assert, isDefined, isFunction, isSymbol } from '../utils/type-guards.js';
-import { getDecoratorData } from './decorator-data.js';
-import { reflectionRegistry } from './registry.js';
-// eslint-disable-next-line max-lines-per-function
-export function createDecorator(options, handler = noop) {
-    // eslint-disable-next-line max-statements, max-lines-per-function
-    function decoratorWrapper(...args) {
-        const data = getDecoratorData(...args);
-        const optionsType = (data.type == 'constructor-parameter') ? 'constructorParameter'
-            : (data.type == 'method-parameter') ? 'methodParameter'
-                : data.type;
-        const valid = (options[optionsType] == true)
-            || (optionsType == 'methodParameter' && ((options.methodParameter == true) || (options.parameter == true)))
-            || (optionsType == 'constructorParameter' && ((options.constructorParameter == true) || (options.parameter == true)));
-        assert(valid, () => `Decorator cannot be used for ${data.type}.`);
-        const metadata = reflectionRegistry.registerDecoratorData(data);
-        if (isDefined(options.data)) {
-            metadata.data.setMany(options.data, options.mergeData);
-        }
-        const result = handler(data, metadata, args);
-        if (isDefined(options.include)) {
-            for (const include of toArray(options.include)) {
-                include(...args); // eslint-disable-line @typescript-eslint/no-unsafe-argument
-            }
-        }
-        return result;
+"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 utils_exports = {};
+__export(utils_exports, {
+  createAccessorDecorator: () => createAccessorDecorator,
+  createClassDecorator: () => createClassDecorator,
+  createConstructorParameterDecorator: () => createConstructorParameterDecorator,
+  createDecorator: () => createDecorator,
+  createMethodDecorator: () => createMethodDecorator,
+  createMethodParameterDecorator: () => createMethodParameterDecorator,
+  createParameterDecorator: () => createParameterDecorator,
+  createPropertyDecorator: () => createPropertyDecorator,
+  createPropertyOrAccessorDecorator: () => createPropertyOrAccessorDecorator,
+  getConstructor: () => getConstructor,
+  getTypeInfoString: () => getTypeInfoString,
+  printType: () => printType,
+  wrapDecorator: () => wrapDecorator,
+  wrapDecoratorFactory: () => wrapDecoratorFactory
+});
+module.exports = __toCommonJS(utils_exports);
+var import_array = require("../utils/array/array.js");
+var import_noop = require("../utils/noop.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_decorator_data = require("./decorator-data.js");
+var import_registry = require("./registry.js");
+function createDecorator(options, handler = import_noop.noop) {
+  function decoratorWrapper(...args) {
+    const data = (0, import_decorator_data.getDecoratorData)(...args);
+    const optionsType = data.type == "constructor-parameter" ? "constructorParameter" : data.type == "method-parameter" ? "methodParameter" : data.type;
+    const valid = options[optionsType] == true || optionsType == "methodParameter" && (options.methodParameter == true || options.parameter == true) || optionsType == "constructorParameter" && (options.constructorParameter == true || options.parameter == true);
+    (0, import_type_guards.assert)(valid, () => `Decorator cannot be used for ${data.type}.`);
+    const metadata = import_registry.reflectionRegistry.registerDecoratorData(data);
+    if ((0, import_type_guards.isDefined)(options.data)) {
+      metadata.data.setMany(options.data, options.mergeData);
     }
-    return decoratorWrapper;
+    const result = handler(data, metadata, args);
+    if ((0, import_type_guards.isDefined)(options.include)) {
+      for (const include of (0, import_array.toArray)(options.include)) {
+        include(...args);
+      }
+    }
+    return result;
+  }
+  return decoratorWrapper;
 }
-export function createClassDecorator(options = {}) {
-    return createDecorator({ ...options, class: true }, options.handler);
+function createClassDecorator(options = {}) {
+  return createDecorator({ ...options, class: true }, options.handler);
 }
-export function createPropertyDecorator(options = {}) {
-    return createDecorator({ ...options, property: true }, options.handler);
+function createPropertyDecorator(options = {}) {
+  return createDecorator({ ...options, property: true }, options.handler);
 }
-export function createAccessorDecorator(options = {}) {
-    return createDecorator({ ...options, accessor: true }, options.handler);
+function createAccessorDecorator(options = {}) {
+  return createDecorator({ ...options, accessor: true }, options.handler);
 }
-export function createPropertyOrAccessorDecorator(options = {}) {
-    return createDecorator({ ...options, property: true, accessor: true }, options.handler);
+function createPropertyOrAccessorDecorator(options = {}) {
+  return createDecorator({ ...options, property: true, accessor: true }, options.handler);
 }
-export function createMethodDecorator(options = {}) {
-    return createDecorator({ ...options, method: true }, options.handler);
+function createMethodDecorator(options = {}) {
+  return createDecorator({ ...options, method: true }, options.handler);
 }
-export function createMethodParameterDecorator(options = {}) {
-    return createDecorator({ ...options, methodParameter: true }, options.handler);
+function createMethodParameterDecorator(options = {}) {
+  return createDecorator({ ...options, methodParameter: true }, options.handler);
 }
-export function createConstructorParameterDecorator(options = {}) {
-    return createDecorator({ ...options, constructorParameter: true }, options.handler);
+function createConstructorParameterDecorator(options = {}) {
+  return createDecorator({ ...options, constructorParameter: true }, options.handler);
 }
-export function createParameterDecorator(options = {}) {
-    return createDecorator({ ...options, parameter: true }, options.handler);
+function createParameterDecorator(options = {}) {
+  return createDecorator({ ...options, parameter: true }, options.handler);
 }
-export function wrapDecoratorFactory(decoratorFactory, options) {
-    function wrappedDecoratorFactory(...args) {
-        const decorator = decoratorFactory(...args);
-        return wrapDecorator(decorator, options);
-    }
-    return wrappedDecoratorFactory;
+function wrapDecoratorFactory(decoratorFactory, options) {
+  function wrappedDecoratorFactory(...args) {
+    const decorator = decoratorFactory(...args);
+    return wrapDecorator(decorator, options);
+  }
+  return wrappedDecoratorFactory;
 }
-export function wrapDecorator(decorator, options) {
-    const wrappedDecorator = createDecorator({
-        class: true,
-        property: true,
-        method: true,
-        parameter: true,
-        methodParameter: true,
-        constructorParameter: true,
-        ...options
-    }, (data, metadata, args) => {
-        options?.handler?.(data, metadata, args);
-        return decorator(...args); // eslint-disable-line @typescript-eslint/no-unsafe-argument
-    });
-    return wrappedDecorator;
+function wrapDecorator(decorator, options) {
+  const wrappedDecorator = createDecorator({
+    class: true,
+    property: true,
+    method: true,
+    parameter: true,
+    methodParameter: true,
+    constructorParameter: true,
+    ...options
+  }, (data, metadata, args) => {
+    options?.handler?.(data, metadata, args);
+    return decorator(...args);
+  });
+  return wrappedDecorator;
 }
-export function getConstructor(constructorOrTarget) {
-    return isFunction(constructorOrTarget)
-        ? constructorOrTarget
-        : constructorOrTarget.constructor;
+function getConstructor(constructorOrTarget) {
+  return (0, import_type_guards.isFunction)(constructorOrTarget) ? constructorOrTarget : constructorOrTarget.constructor;
 }
-export function getTypeInfoString(type) {
-    const lines = [];
-    const metadata = reflectionRegistry.getMetadata(type);
-    const constructorParameters = metadata?.parameters?.map((parameter) => parameter.type?.name ?? '<unknown>').join(', ') ?? '?';
-    lines.push(`${type.name}(${constructorParameters})`);
-    for (const [key, propertyMetadata] of (metadata?.staticProperties ?? [])) {
-        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        lines.push(`  static ${propertyKey}: ${propertyMetadata.type.name}`);
-    }
-    for (const [key, methodMetadata] of (metadata?.staticMethods ?? [])) {
-        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(', ');
-        lines.push(`  static ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? 'void'}`);
-    }
-    for (const [key, propertyMetadata] of (metadata?.properties ?? [])) {
-        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        lines.push(`  ${propertyKey}: ${propertyMetadata.type.name}`);
-    }
-    for (const [key, methodMetadata] of (metadata?.methods ?? [])) {
-        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
-        const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(', ');
-        lines.push(`  ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? 'void'}`);
-    }
-    return lines.join('\n');
+function getTypeInfoString(type) {
+  const lines = [];
+  const metadata = import_registry.reflectionRegistry.getMetadata(type);
+  const constructorParameters = metadata?.parameters?.map((parameter) => parameter.type?.name ?? "<unknown>").join(", ") ?? "?";
+  lines.push(`${type.name}(${constructorParameters})`);
+  for (const [key, propertyMetadata] of metadata?.staticProperties ?? []) {
+    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
+    lines.push(`  static ${propertyKey}: ${propertyMetadata.type.name}`);
+  }
+  for (const [key, methodMetadata] of metadata?.staticMethods ?? []) {
+    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
+    const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(", ");
+    lines.push(`  static ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? "void"}`);
+  }
+  for (const [key, propertyMetadata] of metadata?.properties ?? []) {
+    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
+    lines.push(`  ${propertyKey}: ${propertyMetadata.type.name}`);
+  }
+  for (const [key, methodMetadata] of metadata?.methods ?? []) {
+    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
+    const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(", ");
+    lines.push(`  ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? "void"}`);
+  }
+  return lines.join("\n");
 }
-export function printType(type) {
-    const text = getTypeInfoString(type);
-    console.log(text); // eslint-disable-line no-console
+function printType(type) {
+  const text = getTypeInfoString(type);
+  console.log(text);
 }

package/require.js

@@ -1,6 +1,29 @@
+"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 require_exports = {};
+__export(require_exports, {
+  dynamicRequire: () => dynamicRequire
+});
+module.exports = __toCommonJS(require_exports);
 function getRequire() {
-    return require;
+  return require;
 }
-export function dynamicRequire(id) {
-    return getRequire()(id);
+function dynamicRequire(id) {
+  return getRequire()(id);
 }

package/rpc/endpoints/message-port.rpc-endpoint.js

@@ -1,32 +1,51 @@
-import { isBrowser } from '../../environment.js';
-import { fromEvent, map } from 'rxjs';
-import { RpcEndpoint } from '../rpc-endpoint.js';
-export class MessagePortRpcEndpoint extends RpcEndpoint {
-    source;
-    _postMessage;
-    supportsTransfers = true;
-    message$;
-    constructor(source) {
-        super();
-        this.source = (isBrowser && ((typeof SharedWorker == 'function') && (source instanceof SharedWorker)))
-            ? source.port
-            : source;
-        this.message$ = fromEvent(this.source, 'message').pipe(map((message) => ((message instanceof MessageEvent) ? { ...message.data, metadata: { source: message } } : message)));
-        this._postMessage = isBrowser
-            ? (data, transfer) => this.source.postMessage(data, { transfer })
-            : (data, transfer) => this.source.postMessage(data, transfer);
+"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 message_port_rpc_endpoint_exports = {};
+__export(message_port_rpc_endpoint_exports, {
+  MessagePortRpcEndpoint: () => MessagePortRpcEndpoint
+});
+module.exports = __toCommonJS(message_port_rpc_endpoint_exports);
+var import_environment = require("../../environment.js");
+var import_rxjs = require("rxjs");
+var import_rpc_endpoint = require("../rpc-endpoint.js");
+class MessagePortRpcEndpoint extends import_rpc_endpoint.RpcEndpoint {
+  source;
+  _postMessage;
+  supportsTransfers = true;
+  message$;
+  constructor(source) {
+    super();
+    this.source = import_environment.isBrowser && (typeof SharedWorker == "function" && source instanceof SharedWorker) ? source.port : source;
+    this.message$ = (0, import_rxjs.fromEvent)(this.source, "message").pipe((0, import_rxjs.map)((message) => message instanceof MessageEvent ? { ...message.data, metadata: { source: message } } : message));
+    this._postMessage = import_environment.isBrowser ? (data, transfer) => this.source.postMessage(data, { transfer }) : (data, transfer) => this.source.postMessage(data, transfer);
+  }
+  start() {
+    if (this.source instanceof MessagePort) {
+      this.source.start();
     }
-    start() {
-        if (this.source instanceof MessagePort) {
-            this.source.start();
-        }
-    }
-    close() {
-        if (this.source instanceof MessagePort) {
-            this.source.close();
-        }
-    }
-    postMessage(data, transfer) {
-        this._postMessage(data, transfer);
+  }
+  close() {
+    if (this.source instanceof MessagePort) {
+      this.source.close();
     }
+  }
+  postMessage(data, transfer) {
+    this._postMessage(data, transfer);
+  }
 }