@tstdl/base 0.85.14 → 0.86.0-beta2

package/serializer/serializer.js

@@ -1,292 +1,272 @@
-"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 serializer_exports = {};
-__export(serializer_exports, {
-  deserialize: () => deserialize,
-  serialize: () => serialize,
-  stringDeserialize: () => stringDeserialize,
-  stringSerialize: () => stringSerialize
-});
-module.exports = __toCommonJS(serializer_exports);
-var import_circular_buffer = require("../data-structures/circular-buffer.js");
-var import_sorted_array_list = require("../data-structures/sorted-array-list.js");
-var import_comparison = require("../utils/comparison.js");
-var import_forward_ref = require("../utils/object/forward-ref.js");
-var import_object = require("../utils/object/object.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_serializable = require("./serializable.js");
-var import_types = require("./types.js");
-function stringSerialize(value, options) {
-  const serialized2 = serialize(value, options);
-  return JSON.stringify(serialized2);
+/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/ban-types, max-lines-per-function, max-statements, complexity */
+import { CircularBuffer } from '../data-structures/circular-buffer.js';
+import { SortedArrayList } from '../data-structures/sorted-array-list.js';
+import { compareByValueSelection } from '../utils/comparison.js';
+import { ForwardRef } from '../utils/object/forward-ref.js';
+import { objectEntries } from '../utils/object/object.js';
+import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { getSerializerByTypeName, getTypeNameByConstructor, isRawSerializable } from './serializable.js';
+import { bigintNonPrimitiveType, functionNonPrimitiveType, globalSymbolNonPrimitiveType, rawNonPrimitiveType, refNonPrimitiveType, undefinedNonPrimitiveType } from './types.js';
+export function stringSerialize(value, options) {
+    const serialized = serialize(value, options);
+    return JSON.stringify(serialized);
 }
-function stringDeserialize(serialized2, options) {
-  const parsedStringSerialized = JSON.parse(serialized2);
-  return deserialize(parsedStringSerialized, options);
+export function stringDeserialize(serialized, options) {
+    const parsedStringSerialized = JSON.parse(serialized);
+    return deserialize(parsedStringSerialized, options);
 }
-function serialize(_value, options = {}, references = /* @__PURE__ */ new Map(), queue = new import_circular_buffer.CircularBuffer(), path2 = "$") {
-  let value = _value;
-  if ((0, import_type_guards.isDefined)(options.replacers)) {
-    for (const replacer of options.replacers) {
-      value = replacer(value);
+export function serialize(_value, options = {}, references = new Map(), queue = new CircularBuffer(), path = '$') {
+    let value = _value;
+    if (isDefined(options.replacers)) {
+        for (const replacer of options.replacers) {
+            value = replacer(value);
+        }
+    }
+    const type = typeof value;
+    if (type == 'boolean' || type == 'number' || value === null) {
+        return value;
     }
-  }
-  const type2 = typeof value;
-  if (type2 == "boolean" || type2 == "number" || value === null) {
-    return value;
-  }
-  if (type2 == "undefined") {
-    return { "<undefined>": null };
-  }
-  if (path2 == "$" && (0, import_type_guards.isDefined)(options.context)) {
-    for (const entry of (0, import_object.objectEntries)(options.context)) {
-      references.set(entry[1], `$['__context__']['${entry[0]}']`);
+    if (type == 'undefined') {
+        return { '<undefined>': null };
     }
-  }
-  const reference = references.get(value);
-  if ((0, import_type_guards.isDefined)(reference)) {
-    return { "<ref>": reference };
-  }
-  if (type2 == "string") {
-    if (value.length > path2.length + 50) {
-      references.set(value, path2);
+    if ((path == '$') && isDefined(options.context)) {
+        for (const entry of objectEntries(options.context)) {
+            references.set(entry[1], `$['__context__']['${entry[0]}']`);
+        }
     }
-    return value;
-  }
-  if (type2 == "bigint") {
-    const stringValue = value.toString(10);
-    if (stringValue.length > path2.length + 50) {
-      references.set(value, path2);
+    const reference = references.get(value);
+    if (isDefined(reference)) {
+        return { '<ref>': reference };
     }
-    return { "<bigint>": stringValue };
-  }
-  if (type2 == "symbol") {
-    const key = Symbol.keyFor(value);
-    if (key === void 0) {
-      throw new Error("only global symbols from Symbol.for(<key>) are supported");
+    if (type == 'string') {
+        if (value.length > (path.length + 50)) {
+            references.set(value, path);
+        }
+        return value;
     }
-    return { "<global-symbol>": key };
-  }
-  if (type2 == "function") {
-    if (options.allowUnsafe !== true) {
-      throw new Error("functions are only allowed if allowUnsafe option is true");
+    if (type == 'bigint') {
+        const stringValue = value.toString(10);
+        if (stringValue.length > (path.length + 50)) {
+            references.set(value, path);
+        }
+        return { '<bigint>': stringValue };
     }
-    references.set(value, path2);
-    const source = value.toString();
-    return { "<function>": source };
-  }
-  if (type2 == "object") {
-    let result2;
-    references.set(value, path2);
-    const constructor2 = value.constructor;
-    if (constructor2 == Array) {
-      const target = [];
-      target.length = value.length;
-      const queueItems = value.map((innerValue, index) => () => target[index] = serialize(innerValue, options, references, queue, `${path2}[${index}]`));
-      queue.addMany(queueItems);
-      result2 = target;
-    } else if (constructor2 == Object) {
-      const target = {};
-      const entries2 = (0, import_object.objectEntries)(value);
-      const queueItems = entries2.map(([key, innerValue]) => () => target[key] = serialize(innerValue, options, references, queue, `${path2}['${key.toString()}']`));
-      queue.addMany(queueItems);
-      result2 = target;
-    } else if ((0, import_serializable.isRawSerializable)(constructor2) || (0, import_type_guards.isDefined)(options.raws) && options.raws.includes(constructor2)) {
-      references.set(value, path2);
-      return { "<raw>": value };
-    } else {
-      const serializableType = (0, import_serializable.getTypeNameByConstructor)(constructor2);
-      if ((0, import_type_guards.isUndefined)(serializableType)) {
-        throw new Error(`constructor ${constructor2.name} has no serializer registered`);
-      }
-      const registration = (0, import_serializable.getSerializerByTypeName)(serializableType);
-      const typeString = getTypeString(serializableType);
-      const nonPrimitive = { [typeString]: null };
-      queue.add(() => {
-        const data = registration.serializer.call(value, value, options.data ?? {});
-        nonPrimitive[typeString] = registration.serializeData != false ? serialize(data, options, references, queue, `${path2}['${typeString}']`) : data;
-      });
-      result2 = nonPrimitive;
+    if (type == 'symbol') {
+        const key = Symbol.keyFor(value);
+        if (key === undefined) {
+            throw new Error('only global symbols from Symbol.for(<key>) are supported');
+        }
+        return { '<global-symbol>': key };
     }
-    if (path2 == "$") {
-      for (const fn2 of queue.consume()) {
-        fn2();
-      }
+    if (type == 'function') {
+        if (options.allowUnsafe !== true) {
+            throw new Error('functions are only allowed if allowUnsafe option is true');
+        }
+        references.set(value, path);
+        const source = value.toString();
+        return { '<function>': source };
+    }
+    if (type == 'object') { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+        let result;
+        references.set(value, path);
+        const constructor = value.constructor;
+        if (constructor == Array) {
+            const target = [];
+            target.length = value.length;
+            const queueItems = value.map((innerValue, index) => () => (target[index] = serialize(innerValue, options, references, queue, `${path}[${index}]`)));
+            queue.addMany(queueItems);
+            result = target;
+        }
+        else if (constructor == Object) {
+            const target = {};
+            const entries = objectEntries(value);
+            const queueItems = entries.map(([key, innerValue]) => () => (target[key] = serialize(innerValue, options, references, queue, `${path}['${key.toString()}']`)));
+            queue.addMany(queueItems);
+            result = target;
+        }
+        else if (isRawSerializable(constructor) || (isDefined(options.raws) && options.raws.includes(constructor))) {
+            references.set(value, path);
+            return { '<raw>': value };
+        }
+        else {
+            const serializableType = getTypeNameByConstructor(constructor);
+            if (isUndefined(serializableType)) {
+                throw new Error(`constructor ${constructor.name} has no serializer registered`);
+            }
+            const registration = getSerializerByTypeName(serializableType);
+            const typeString = getTypeString(serializableType);
+            const nonPrimitive = { [typeString]: null };
+            queue.add(() => {
+                const data = registration.serializer.call(value, value, options.data ?? {});
+                (nonPrimitive[typeString] = (registration.serializeData != false) ? serialize(data, options, references, queue, `${path}['${typeString}']`) : data);
+            });
+            result = nonPrimitive;
+        }
+        if (path == '$') {
+            for (const fn of queue.consume()) {
+                fn();
+            }
+        }
+        return result;
     }
-    return result2;
-  }
-  throw new Error(`Unsupported type '${type2}'.`);
+    throw new Error(`Unsupported type '${type}'.`);
 }
-function deserialize(serialized2, options) {
-  const context2 = getDeserializeContext(serialized2, options);
-  return _deserialize(serialized2, context2, "$", 0);
+export function deserialize(serialized, options) {
+    const context = getDeserializeContext(serialized, options);
+    return _deserialize(serialized, context, '$', 0);
 }
 function _deserialize(serialized, context, path, depth) {
-  const type = typeof serialized;
-  if (type == "number" || type == "boolean" || serialized === null) {
-    return serialized;
-  }
-  if (type == "string") {
-    context.references.set(path, serialized);
-    return serialized;
-  }
-  if (type == "undefined") {
-    return { "<undefined>": null };
-  }
-  if (type == "object") {
-    if (depth == 0 && (0, import_type_guards.isDefined)(context.options.context)) {
-      for (const entry of (0, import_object.objectEntries)(context.options.context)) {
-        context.references.set(`$['__context__']['${entry[0]}']`, entry[1]);
-      }
+    const type = typeof serialized;
+    if ((type == 'number') || (type == 'boolean') || (serialized === null)) {
+        return serialized;
     }
-    const entries = (0, import_object.objectEntries)(serialized);
-    const isNonPrimitive = entries.length == 1 && entries[0][0].startsWith("<") && entries[0][0].endsWith(">");
-    if (isNonPrimitive) {
-      const nonPrimitiveData = entries[0][1];
-      const nonPrimitiveType = entries[0][0].slice(1, -1);
-      switch (nonPrimitiveType) {
-        case import_types.undefinedNonPrimitiveType: {
-          return void 0;
-        }
-        case import_types.bigintNonPrimitiveType: {
-          const bigint = BigInt(nonPrimitiveData);
-          context.references.set(path, bigint);
-          return bigint;
+    if (type == 'string') {
+        context.references.set(path, serialized);
+        return serialized;
+    }
+    if (type == 'undefined') {
+        return { '<undefined>': null };
+    }
+    if (type == 'object') {
+        if ((depth == 0) && isDefined(context.options.context)) {
+            for (const entry of objectEntries(context.options.context)) {
+                context.references.set(`$['__context__']['${entry[0]}']`, entry[1]);
+            }
         }
-        case import_types.globalSymbolNonPrimitiveType: {
-          const symbol = Symbol.for(nonPrimitiveData);
-          context.references.set(path, symbol);
-          return symbol;
+        const entries = objectEntries(serialized);
+        const isNonPrimitive = (entries.length == 1) && entries[0][0].startsWith('<') && entries[0][0].endsWith('>');
+        if (isNonPrimitive) {
+            const nonPrimitiveData = entries[0][1];
+            const nonPrimitiveType = entries[0][0].slice(1, -1);
+            switch (nonPrimitiveType) {
+                case undefinedNonPrimitiveType: {
+                    return undefined;
+                }
+                case bigintNonPrimitiveType: {
+                    const bigint = BigInt(nonPrimitiveData);
+                    context.references.set(path, bigint);
+                    return bigint;
+                }
+                case globalSymbolNonPrimitiveType: {
+                    const symbol = Symbol.for(nonPrimitiveData);
+                    context.references.set(path, symbol);
+                    return symbol;
+                }
+                case functionNonPrimitiveType: {
+                    if (context.options.allowUnsafe !== true) {
+                        throw new Error('functions are only allowed if allowUnsafe option is true');
+                    }
+                    const fn = eval(nonPrimitiveData); // eslint-disable-line no-eval
+                    context.references.set(path, fn);
+                    return fn;
+                }
+                case rawNonPrimitiveType: {
+                    return nonPrimitiveData;
+                }
+                case refNonPrimitiveType: {
+                    const dereferenced = context.references.get(nonPrimitiveData);
+                    if (dereferenced == undefined) {
+                        throw new Error(`reference ${nonPrimitiveData} not found`);
+                    }
+                    return dereferenced;
+                }
+                default: {
+                    const registration = getSerializerByTypeName(nonPrimitiveType);
+                    if (registration == undefined) {
+                        throw new Error(`non-primitive type ${nonPrimitiveType} not registered`);
+                    }
+                    const forwardRef = ForwardRef.create();
+                    context.references.set(path, forwardRef);
+                    context.addToDeserializeQueue(() => {
+                        const deserializedData = _deserialize(nonPrimitiveData, context, `${path}['<${nonPrimitiveType}>']`, depth + 1);
+                        context.addToDeserializeQueue(() => {
+                            const deserialized = registration.deserializer(deserializedData, context.tryAddToDerefQueue, context.options.data ?? {});
+                            ForwardRef.setRef(forwardRef, deserialized);
+                        }, depth);
+                    }, depth);
+                    if (depth == 0) {
+                        drainQueues(context);
+                        return ForwardRef.deref(forwardRef);
+                    }
+                    return forwardRef;
+                }
+            }
         }
-        case import_types.functionNonPrimitiveType: {
-          if (context.options.allowUnsafe !== true) {
-            throw new Error("functions are only allowed if allowUnsafe option is true");
-          }
-          const fn = eval(nonPrimitiveData);
-          context.references.set(path, fn);
-          return fn;
+        let result;
+        const constructor = serialized.constructor;
+        if (constructor == Array) {
+            const deserializedArray = [];
+            deserializedArray.length = serialized.length;
+            context.references.set(path, deserializedArray);
+            const queueItems = serialized.map((innerValue, index) => () => {
+                const deserialized = _deserialize(innerValue, context, `${path}[${index}]`, depth + 1);
+                deserializedArray[index] = deserialized;
+                context.tryAddToDerefQueue(deserialized, (dereferenced) => (deserializedArray[index] = dereferenced));
+                return deserialized;
+            });
+            context.addManyToDeserializeQueue(queueItems, depth);
+            result = deserializedArray;
         }
-        case import_types.rawNonPrimitiveType: {
-          return nonPrimitiveData;
+        else if (constructor == Object) {
+            const deserializedObject = {};
+            context.references.set(path, deserializedObject);
+            const queueItems = entries.map(([key, innerValue]) => () => {
+                const deserialized = _deserialize(innerValue, context, `${path}['${key}']`, depth + 1);
+                deserializedObject[key] = deserialized;
+                context.tryAddToDerefQueue(deserialized, (dereferenced) => (deserializedObject[key] = dereferenced));
+                return deserialized;
+            });
+            context.addManyToDeserializeQueue(queueItems, depth);
+            result = deserializedObject;
         }
-        case import_types.refNonPrimitiveType: {
-          const dereferenced = context.references.get(nonPrimitiveData);
-          if (dereferenced == void 0) {
-            throw new Error(`reference ${nonPrimitiveData} not found`);
-          }
-          return dereferenced;
+        else {
+            throw new Error(`Unsupported constructor ${constructor.name}.`);
         }
-        default: {
-          const registration = (0, import_serializable.getSerializerByTypeName)(nonPrimitiveType);
-          if (registration == void 0) {
-            throw new Error(`non-primitive type ${nonPrimitiveType} not registered`);
-          }
-          const forwardRef = import_forward_ref.ForwardRef.create();
-          context.references.set(path, forwardRef);
-          context.addToDeserializeQueue(() => {
-            const deserializedData = _deserialize(nonPrimitiveData, context, `${path}['<${nonPrimitiveType}>']`, depth + 1);
-            context.addToDeserializeQueue(() => {
-              const deserialized = registration.deserializer(deserializedData, context.tryAddToDerefQueue, context.options.data ?? {});
-              import_forward_ref.ForwardRef.setRef(forwardRef, deserialized);
-            }, depth);
-          }, depth);
-          if (depth == 0) {
+        if (depth == 0) {
             drainQueues(context);
-            return import_forward_ref.ForwardRef.deref(forwardRef);
-          }
-          return forwardRef;
         }
-      }
-    }
-    let result;
-    const constructor = serialized.constructor;
-    if (constructor == Array) {
-      const deserializedArray = [];
-      deserializedArray.length = serialized.length;
-      context.references.set(path, deserializedArray);
-      const queueItems = serialized.map((innerValue, index) => () => {
-        const deserialized = _deserialize(innerValue, context, `${path}[${index}]`, depth + 1);
-        deserializedArray[index] = deserialized;
-        context.tryAddToDerefQueue(deserialized, (dereferenced) => deserializedArray[index] = dereferenced);
-        return deserialized;
-      });
-      context.addManyToDeserializeQueue(queueItems, depth);
-      result = deserializedArray;
-    } else if (constructor == Object) {
-      const deserializedObject = {};
-      context.references.set(path, deserializedObject);
-      const queueItems = entries.map(([key, innerValue]) => () => {
-        const deserialized = _deserialize(innerValue, context, `${path}['${key}']`, depth + 1);
-        deserializedObject[key] = deserialized;
-        context.tryAddToDerefQueue(deserialized, (dereferenced) => deserializedObject[key] = dereferenced);
-        return deserialized;
-      });
-      context.addManyToDeserializeQueue(queueItems, depth);
-      result = deserializedObject;
-    } else {
-      throw new Error(`Unsupported constructor ${constructor.name}.`);
+        return result;
     }
-    if (depth == 0) {
-      drainQueues(context);
-    }
-    return result;
-  }
-  throw new Error(`Unsupported type '${type}'.`);
+    throw new Error(`Unsupported type '${type}'.`);
 }
-function getTypeString(type2) {
-  return `<${type2}>`;
+function getTypeString(type) {
+    return `<${type}>`;
 }
 function getDeserializeContext(serializedRoot, options) {
-  const context2 = {
-    serializedRoot,
-    options: options ?? {},
-    references: /* @__PURE__ */ new Map(),
-    deserializeCounter: 0,
-    deserializeQueue: new import_sorted_array_list.SortedArrayList(void 0, (0, import_comparison.compareByValueSelection)((item) => item.depth, (item) => item.counter)),
-    derefQueue: new import_circular_buffer.CircularBuffer(),
-    addToDeserializeQueue(fn2, depth2) {
-      context2.deserializeQueue.add({ depth: depth2, counter: context2.deserializeCounter++, fn: fn2 });
-    },
-    addManyToDeserializeQueue(fns, depth2) {
-      for (const fn2 of fns) {
-        context2.deserializeQueue.add({ depth: depth2, counter: context2.deserializeCounter++, fn: fn2 });
-      }
-    },
-    tryAddToDerefQueue(value, callback) {
-      if (!import_forward_ref.ForwardRef.isForwardRef(value) || context2.options.doNotDereferenceForwardRefs == true) {
-        return false;
-      }
-      context2.derefQueue.add(() => {
-        const dereferenced = import_forward_ref.ForwardRef.deref(value);
-        callback(dereferenced);
-      });
-      return true;
-    }
-  };
-  return context2;
+    const context = {
+        serializedRoot,
+        options: options ?? {},
+        references: new Map(),
+        deserializeCounter: 0,
+        deserializeQueue: new SortedArrayList(undefined, compareByValueSelection((item) => item.depth, (item) => item.counter)),
+        derefQueue: new CircularBuffer(),
+        addToDeserializeQueue(fn, depth) {
+            context.deserializeQueue.add({ depth, counter: context.deserializeCounter++, fn });
+        },
+        addManyToDeserializeQueue(fns, depth) {
+            for (const fn of fns) {
+                context.deserializeQueue.add({ depth, counter: context.deserializeCounter++, fn });
+            }
+        },
+        tryAddToDerefQueue(value, callback) {
+            if (!ForwardRef.isForwardRef(value) || (context.options.doNotDereferenceForwardRefs == true)) {
+                return false;
+            }
+            context.derefQueue.add(() => {
+                const dereferenced = ForwardRef.deref(value);
+                callback(dereferenced);
+            });
+            return true;
+        }
+    };
+    return context;
 }
 function drainQueues({ deserializeQueue, derefQueue }) {
-  while (deserializeQueue.size > 0) {
-    const item = deserializeQueue.removeLast();
-    item.fn();
-  }
-  for (const fn2 of derefQueue.consume()) {
-    fn2();
-  }
+    while (deserializeQueue.size > 0) {
+        const item = deserializeQueue.removeLast();
+        item.fn();
+    }
+    for (const fn of derefQueue.consume()) {
+        fn();
+    }
 }

package/serializer/types.js

@@ -1,34 +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 types_exports = {};
-__export(types_exports, {
-  bigintNonPrimitiveType: () => bigintNonPrimitiveType,
-  functionNonPrimitiveType: () => functionNonPrimitiveType,
-  globalSymbolNonPrimitiveType: () => globalSymbolNonPrimitiveType,
-  rawNonPrimitiveType: () => rawNonPrimitiveType,
-  refNonPrimitiveType: () => refNonPrimitiveType,
-  undefinedNonPrimitiveType: () => undefinedNonPrimitiveType
-});
-module.exports = __toCommonJS(types_exports);
-const rawNonPrimitiveType = "raw";
-const undefinedNonPrimitiveType = "undefined";
-const bigintNonPrimitiveType = "bigint";
-const globalSymbolNonPrimitiveType = "global-symbol";
-const functionNonPrimitiveType = "function";
-const refNonPrimitiveType = "ref";
+export const rawNonPrimitiveType = 'raw';
+export const undefinedNonPrimitiveType = 'undefined';
+export const bigintNonPrimitiveType = 'bigint';
+export const globalSymbolNonPrimitiveType = 'global-symbol';
+export const functionNonPrimitiveType = 'function';
+export const refNonPrimitiveType = 'ref';

package/signals/api.js

@@ -1,46 +1,18 @@
-"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 api_exports = {};
-__export(api_exports, {
-  computed: () => computed,
-  configureSignals: () => configureSignals,
-  effect: () => effect,
-  isSignal: () => isSignal,
-  signal: () => signal,
-  toObservable: () => toObservable,
-  toSignal: () => toSignal,
-  untracked: () => untracked
-});
-module.exports = __toCommonJS(api_exports);
-let signal;
-let computed;
-let effect;
-let untracked;
-let isSignal;
-let toSignal;
-let toObservable;
-function configureSignals(configuration) {
-  signal = configuration.signal;
-  computed = configuration.computed;
-  effect = configuration.effect;
-  untracked = configuration.untracked;
-  isSignal = configuration.isSignal;
-  toSignal = configuration.toSignal;
-  toObservable = configuration.toObservable;
+/* eslint-disable import/no-mutable-exports */
+export let signal;
+export let computed;
+export let effect;
+export let untracked;
+export let isSignal;
+export let toSignal;
+export let toObservable;
+/* eslint-enable import/no-mutable-exports */
+export function configureSignals(configuration) {
+    signal = configuration.signal;
+    computed = configuration.computed;
+    effect = configuration.effect;
+    untracked = configuration.untracked;
+    isSignal = configuration.isSignal;
+    toSignal = configuration.toSignal;
+    toObservable = configuration.toObservable;
 }