mutts 1.0.6 → 1.0.8

package/package.json

@@ -1,19 +1,57 @@
 {
   "name": "mutts",
   "description": "Modern UTility TS: A collection of TypeScript utilities",
-  "version": "1.0.6",
-  "main": "src/index.ts",
-  "module": "src/index.ts",
-  "types": "src/index.ts",
+  "version": "1.0.8",
+  "main": "dist/browser.cjs",
+  "module": "dist/browser.esm.js",
+  "types": "dist/browser.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "source": "./src/index.ts",
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.js",
-      "script": "./dist/mutts.umd.min.js"
+      "test-node": {
+        "import": "./src/entry-node.ts"
+      },
+      "test-browser": {
+        "import": "./src/entry-browser.ts"
+      },
+      "node": {
+        "types": "./dist/node.d.ts",
+        "import": "./dist/node.esm.js",
+        "require": "./dist/node.cjs"
+      },
+      "default": {
+        "types": "./dist/browser.d.ts",
+        "import": "./dist/browser.esm.js",
+        "require": "./dist/browser.cjs"
+      }
     },
-    "./src/*": "./src/*"
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.esm.js",
+      "require": "./dist/browser.cjs"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.esm.js",
+      "require": "./dist/node.cjs"
+    },
+    "./src": {
+      "node": {
+        "types": "./src/entry-node.ts",
+        "import": "./src/entry-node.ts"
+      },
+      "default": {
+        "types": "./src/entry-browser.ts",
+        "import": "./src/entry-browser.ts"
+      }
+    },
+    "./src/browser": {
+      "types": "./src/entry-browser.ts",
+      "import": "./src/entry-browser.ts"
+    },
+    "./src/node": {
+      "types": "./src/entry-node.ts",
+      "import": "./src/entry-node.ts"
+    }
   },
   "files": [
     "dist",
@@ -27,14 +65,20 @@
     "build": "npm run build:js && npm run build:devtools",
     "build:watch": "rollup -c --watch",
     "prepublishOnly": "npm run build",
-    "test": "NODE_OPTIONS=--expose-gc jest",
-    "test:coverage": "NODE_OPTIONS=--expose-gc jest --coverage",
-    "test:coverage:watch": "NODE_OPTIONS=--expose-gc jest --coverage --watch",
-    "test:legacy": "TSCONFIG=tsconfig.legacy.json jest --detectOpenHandles --testPathPatterns=decorator",
-    "test:modern": "TSCONFIG=tsconfig.modern.json jest --detectOpenHandles --testPathPatterns=decorator",
-    "test:profile": "RUN_PROFILING=1 NODE_OPTIONS=--expose-gc jest --testPathPatterns=profiling",
-    "test:profile:benchmark": "RUN_PROFILING=1 NODE_OPTIONS=--expose-gc jest --testPathPatterns=profiling --testNamePattern=benchmark",
-    "test:profile:detailed": "RUN_PROFILING=1 node --prof node_modules/jest/bin/jest.js --testPathPatterns=profiling --no-coverage",
+    "test": "npm run test:node && npm run test:browser",
+    "test:node": "TEST_ENV=node NODE_OPTIONS='--expose-gc' vitest run",
+    "test:browser": "TEST_ENV=browser vitest run --browser",
+    "test:zone:node": "TEST_ENV=node vitest run tests/zone.test.ts",
+    "test:zone:browser": "TEST_ENV=browser vitest run tests/zone.test.ts",
+    "test:async:node": "TEST_ENV=node vitest run tests/async-hook.test.ts",
+    "test:async:browser": "TEST_ENV=browser vitest run tests/async-hook.test.ts",
+    "test:coverage": "TEST_ENV=node vitest run --coverage",
+    "test:coverage:watch": "TEST_ENV=node vitest run --coverage --watch",
+    "test:legacy": "TEST_ENV=node TSCONFIG=tsconfig.legacy.json vitest run --detectOpenHandles",
+    "test:modern": "TEST_ENV=node TSCONFIG=tsconfig.modern.json vitest run --detectOpenHandles",
+    "test:profile": "RUN_PROFILING=1 NODE_OPTIONS=--expose-gc vitest run",
+    "test:profile:benchmark": "RUN_PROFILING=1 NODE_OPTIONS=--expose-gc vitest run -t benchmark",
+    "test:profile:detailed": "RUN_PROFILING=1 node --prof node_modules/vitest/vitest.mjs --no-coverage",
     "benchmark:save": "tsx tests/profiling/benchmark.ts save",
     "benchmark:compare": "tsx tests/profiling/benchmark.ts compare",
     "benchmark:list": "tsx tests/profiling/benchmark.ts list",
@@ -70,25 +114,25 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.0.6",
-    "@jest/globals": "^30.2.0",
     "@rollup/plugin-commonjs": "^28.0.6",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.4",
-    "@types/jest": "^30.0.0",
     "@types/node": "^22.10.10",
-    "jest": "^30.0.4",
+    "@vitest/browser": "^4.0.18",
+    "@vitest/browser-playwright": "^4.0.18",
+    "playwright": "^1.58.1",
     "rollup": "^4.52.2",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-dts": "^6.2.3",
     "rollup-plugin-typescript2": "^0.36.0",
-    "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "tsx": "^4.20.4",
     "typescript": "^5.8.3",
-    "vis-network": "^9.1.9"
+    "vis-network": "^9.1.9",
+    "vitest": "^4.0.18"
   },
   "packageManager": "pnpm@10.7.1+sha512.2d92c86b7928dc8284f53494fb4201f983da65f0fb4f0d40baafa5cf628fa31dae3e5968f12466f17df7e97310e30f343a648baea1b9b350685dafafffdf5808"
 }

package/src/async/browser.ts

@@ -0,0 +1,319 @@
+import { Hook, Restorer, asyncHooks } from '.'
+
+const hooks = new Set<Hook>()
+const promiseContexts = new WeakMap<Promise<any>, Set<Restorer>>()
+
+asyncHooks.addHook = function (hook: Hook) {
+	hooks.add(hook)
+	return () => {
+		hooks.delete(hook)
+	}
+}
+
+// [HACK]: Sanitization
+// If a Promise is created inside the zone, it carries the "Sticky" zone context.
+// If returned to the outer scope, that context leaks. We wrap it in a new Promise
+// created here (in the outer scope) to break the chain and sanitize the return value.
+// See BROWSER_ASYNC_POLYFILL.md for full details.
+asyncHooks.sanitizePromise = (res: any) => {
+    if (res && typeof (res as any).then === 'function') {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                (res as any).then(resolve, reject)
+            }, 0)
+        })
+    }
+    return res
+}
+
+function captureRestorers() {
+	const restorers = new Set<Restorer>()
+	for (const hook of hooks) {
+		const restorer = hook()
+		if (restorer) restorers.add(restorer)
+	}
+	return restorers
+}
+
+function wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined, capturedRestorers?: Set<Restorer>) {
+	if (typeof fn !== 'function') return fn
+	const restorers = capturedRestorers || captureRestorers()
+	return function (this: any, ...args: Args) {
+		const undoers: (() => void)[] = []
+		for (const restore of restorers) undoers.push(restore())
+		try {
+			return fn.apply(this, args)
+		} finally {
+			if (originals.queueMicrotask) {
+				// Double microtask ensures we run after the first await resumption microtask
+				originals.queueMicrotask.call(globalThis, () => {
+					originals.queueMicrotask.call(globalThis, () => {
+						originals.queueMicrotask.call(globalThis, () => {
+							for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
+						})
+					})
+				})
+			} else {
+				for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
+			}
+		}
+	}
+}
+
+const targetWrappers = new WeakMap<any, Map<string, WeakMap<Function, Function>>>()
+
+function patchEventTarget(proto: any) {
+	if (!proto || !proto.addEventListener || !proto.removeEventListener) return
+	const nativeAdd = proto.addEventListener
+	const nativeRemove = proto.removeEventListener
+
+	proto.addEventListener = function (this: any, type: string, listener: any, options: any) {
+		if (typeof listener !== 'function') {
+			return nativeAdd.call(this, type, listener, options)
+		}
+
+		let types = targetWrappers.get(this)
+		if (!types) {
+			types = new Map()
+			targetWrappers.set(this, types)
+		}
+		let listeners = types.get(type)
+		if (!listeners) {
+			listeners = new WeakMap()
+			types.set(type, listeners)
+		}
+
+		let wrapped = listeners.get(listener)
+		if (!wrapped) {
+			wrapped = wrap(listener)
+			listeners.set(listener, wrapped)
+		}
+		
+		return nativeAdd.call(this, type, wrapped, options)
+	}
+
+	proto.removeEventListener = function (this: any, type: string, listener: any, options: any) {
+		if (typeof listener !== 'function') {
+			return nativeRemove.call(this, type, listener, options)
+		}
+
+		const types = targetWrappers.get(this)
+		if (types) {
+			const listeners = types.get(type)
+			if (listeners) {
+				const wrapped = listeners.get(listener)
+				if (wrapped) {
+					return nativeRemove.call(this, type, wrapped, options)
+				}
+			}
+		}
+		
+		return nativeRemove.call(this, type, listener, options)
+	}
+}
+
+function patchOnProperties(proto: any) {
+	if (!proto) return
+	for (const prop of Object.getOwnPropertyNames(proto)) {
+		if (prop.startsWith('on')) {
+			const desc = Object.getOwnPropertyDescriptor(proto, prop)
+			if (desc && desc.set && desc.configurable) {
+				const nativeSet = desc.set
+				Object.defineProperty(proto, prop, {
+					...desc,
+					set: function (this: any, fn: any) {
+						nativeSet.call(this, wrap(fn))
+					}
+				})
+			}
+		}
+	}
+}
+
+if (typeof EventTarget !== 'undefined') {
+	patchEventTarget(EventTarget.prototype)
+}
+
+const prototypesToPatch = [
+	typeof EventTarget !== 'undefined' && EventTarget.prototype,
+	typeof HTMLElement !== 'undefined' && HTMLElement.prototype,
+	typeof Window !== 'undefined' && Window.prototype,
+	typeof Document !== 'undefined' && Document.prototype,
+	typeof MessagePort !== 'undefined' && MessagePort.prototype,
+	typeof XMLHttpRequest !== 'undefined' && XMLHttpRequest.prototype,
+	typeof IDBRequest !== 'undefined' && IDBRequest.prototype,
+	typeof IDBTransaction !== 'undefined' && IDBTransaction.prototype,
+	typeof IDBDatabase !== 'undefined' && IDBDatabase.prototype,
+	typeof FileReader !== 'undefined' && FileReader.prototype,
+	typeof AbortSignal !== 'undefined' && AbortSignal.prototype,
+]
+
+for (const proto of prototypesToPatch) {
+	if (proto) {
+		patchOnProperties(proto)
+	}
+}
+
+const GLOBAL_ORIGINALS = Symbol.for('mutts.originals');
+const GLOBAL_PROMISE = Symbol.for('mutts.OriginalPromise');
+
+let originals: any;
+let OriginalPromise: any;
+
+if ((globalThis as any)[GLOBAL_ORIGINALS]) {
+    originals = (globalThis as any)[GLOBAL_ORIGINALS];
+    OriginalPromise = (globalThis as any)[GLOBAL_PROMISE];
+} else {
+    OriginalPromise = globalThis.Promise;
+    originals = {
+        then: OriginalPromise.prototype.then,
+        catch: OriginalPromise.prototype.catch,
+        finally: OriginalPromise.prototype.finally,
+        resolve: OriginalPromise.resolve,
+        reject: OriginalPromise.reject,
+        all: OriginalPromise.all,
+        allSettled: (OriginalPromise as any).allSettled,
+        race: OriginalPromise.race,
+        any: (OriginalPromise as any).any,
+        setTimeout: globalThis.setTimeout,
+        setInterval: globalThis.setInterval,
+        setImmediate: (globalThis as any).setImmediate,
+        requestAnimationFrame: (globalThis as any).requestAnimationFrame,
+        queueMicrotask: globalThis.queueMicrotask,
+    };
+    (globalThis as any)[GLOBAL_ORIGINALS] = originals;
+    (globalThis as any)[GLOBAL_PROMISE] = OriginalPromise;
+}
+
+// Ensure modern statics are captured even if originals was cached from an older version
+if (!originals.allSettled) originals.allSettled = (OriginalPromise as any).allSettled
+if (!originals.any) originals.any = (OriginalPromise as any).any
+if (!originals.race) originals.race = OriginalPromise.race
+
+function patchedThen(this: any, onFulfilled: any, onRejected: any) {
+	const context = promiseContexts.get(this) || captureRestorers()
+	const nextPromise = originals.then.call(this, wrap(onFulfilled, context), wrap(onRejected, context))
+	if (context.size > 0) promiseContexts.set(nextPromise, context)
+	return nextPromise
+}
+
+function patchedCatch(this: any, onRejected: any) {
+	const context = promiseContexts.get(this) || captureRestorers()
+	const nextPromise = originals.catch.call(this, wrap(onRejected, context))
+	if (context.size > 0) promiseContexts.set(nextPromise, context)
+	return nextPromise
+}
+
+function patchedFinally(this: any, onFinally: any) {
+	const context = promiseContexts.get(this) || captureRestorers()
+	const nextPromise = originals.finally.call(this, wrap(onFinally, context))
+	if (context.size > 0) promiseContexts.set(nextPromise, context)
+	return nextPromise
+}
+
+function PatchedPromise<T>(this: any, executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) {
+    if (typeof executor === 'function') {
+        const p = new OriginalPromise((resolve, reject) => {
+            const wrappedResolve = wrap(resolve)
+            const wrappedReject = wrap(reject)
+            executor(wrappedResolve, wrappedReject)
+        })
+        const context = captureRestorers()
+        promiseContexts.set(p, context) // Always set, even if empty (Sticky Root)
+        return p
+    }
+    return new OriginalPromise(executor)
+}
+
+// Copy statics
+Object.assign(PatchedPromise, (OriginalPromise as any))
+
+// Inherit prototype for instanceof checks
+PatchedPromise.prototype = OriginalPromise.prototype
+
+PatchedPromise.resolve = function<T>(value?: T | PromiseLike<T>): Promise<T> {
+    const p = originals.resolve.call(OriginalPromise, value) as Promise<T>
+    const context = captureRestorers()
+    // Ensure we don't overwrite if it already has context (e.g. from constructor)
+    if (context.size > 0 && !promiseContexts.has(p)) promiseContexts.set(p, context)
+    return p
+} as any
+
+PatchedPromise.reject = function<T = never>(reason?: any): Promise<T> {
+    const p = originals.reject.call(OriginalPromise, reason) as Promise<T>
+    const context = captureRestorers()
+    if (context.size > 0) promiseContexts.set(p, context)
+    return p
+} as any
+
+PatchedPromise.all = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]> {
+    const p = originals.all.call(OriginalPromise, values) as Promise<Awaited<T>[]>
+    const context = captureRestorers()
+    if (context.size > 0) promiseContexts.set(p, context)
+    return p
+} as any
+
+PatchedPromise.allSettled = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]> {
+    const p = (originals.allSettled as any).call(OriginalPromise, values)
+    const context = captureRestorers()
+    if (context.size > 0) promiseContexts.set(p, context)
+    return p
+} as any
+
+PatchedPromise.race = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>> {
+    const p = originals.race.call(OriginalPromise, values) as Promise<Awaited<T>>
+    const context = captureRestorers()
+    if (context.size > 0) promiseContexts.set(p, context)
+    return p
+} as any
+
+PatchedPromise.any = function<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>> {
+    const p = (originals.any as any).call(OriginalPromise, values)
+    const context = captureRestorers()
+    if (context.size > 0) promiseContexts.set(p, context)
+    return p
+} as any
+
+// Only apply patches if not already applied (or re-apply safely)
+// Note: OriginalPromise.prototype might be shared if we used the global one.
+// We must ensure we don't patch it twice if it's the SAME object.
+if (OriginalPromise.prototype.then !== patchedThen) {
+    OriginalPromise.prototype.then = patchedThen as any
+    OriginalPromise.prototype.catch = patchedCatch as any
+    OriginalPromise.prototype.finally = patchedFinally as any
+}
+
+try {
+	Object.defineProperty(OriginalPromise, Symbol.species, {
+		get: () => PatchedPromise,
+		configurable: true
+	})
+} catch (e) {}
+
+;(globalThis as any).Promise = PatchedPromise
+
+globalThis.setTimeout = ((callback: Function, ...args: any[]) => {
+	return originals.setTimeout.call(globalThis, wrap(callback as any), ...args)
+}) as any
+
+globalThis.setInterval = ((callback: Function, ...args: any[]) => {
+	return originals.setInterval.call(globalThis, wrap(callback as any), ...args)
+}) as any
+
+if (originals.setImmediate) {
+	;(globalThis as any).setImmediate = ((callback: Function, ...args: any[]) => {
+		return originals.setImmediate.call(globalThis, wrap(callback as any), ...args)
+	}) as any
+}
+
+if (originals.requestAnimationFrame) {
+	globalThis.requestAnimationFrame = (callback: FrameRequestCallback) => {
+		return originals.requestAnimationFrame.call(globalThis, wrap(callback))
+	}
+}
+
+if (originals.queueMicrotask) {
+	globalThis.queueMicrotask = (callback: VoidFunction): void => {
+		originals.queueMicrotask.call(globalThis, wrap(callback))
+	}
+}

package/src/async/index.ts

@@ -0,0 +1,23 @@
+export type Restorer = () => () => void
+export type Hook = () => Restorer
+
+export const asyncHooks = {
+	addHook(_hook: Hook): () => void {
+		throw 'One must import the library from the server or the client side'
+	},
+    /** 
+     * [Hack] Sanitize a promise (or value) to prevent context leaks. 
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p: any): any {
+        return p
+    }
+}
+
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+export const asyncHook = (hook: Hook) => asyncHooks.addHook(hook)

package/src/async/node.ts

@@ -0,0 +1,104 @@
+import { createHook } from 'node:async_hooks'
+import { Hook, Restorer, asyncHooks } from '.'
+
+// 1. Generic async_hooks implementation for Hooks
+// This maintains support for 'asyncHooks.addHook' for generic use cases.
+
+const hooks = new Set<Hook>()
+asyncHooks.addHook = function (hook: Hook) {
+	hooks.add(hook)
+	return () => {
+		hooks.delete(hook)
+	}
+}
+
+const contexts = new Map<number, Restorer[]>()
+const activeUndoers = new Map<number, (() => void)[]>()
+
+// Helper to capture current hooks state
+function captureRestorers() {
+	if (hooks.size === 0) return []
+	const restorers: Restorer[] = []
+	for (const h of hooks) {
+		const r = h()
+		if (r) restorers.push(r)
+	}
+	return restorers
+}
+
+// Manual Wrap function to handle Promise callbacks
+function wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined) {
+	if (typeof fn !== 'function') return fn
+	const restorers = captureRestorers()
+	if (restorers.length === 0) return fn
+
+	return function (this: any, ...args: Args) {
+		const undoers: (() => void)[] = []
+		for (const restore of restorers) {
+			const u = restore()
+			if (u) undoers.push(u)
+		}
+		try {
+			return fn.apply(this, args)
+		} finally {
+			for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
+		}
+	}
+}
+
+const hook = createHook({
+	init(asyncId, type, triggerId, resource) {
+		// Used for native resources like Timers
+		const restorers = captureRestorers()
+		if (restorers.length > 0) contexts.set(asyncId, restorers)
+	},
+	before(asyncId) {
+		const restorers = contexts.get(asyncId)
+		if (!restorers) return
+		const undoers: (() => void)[] = []
+		for (const restore of restorers) {
+			const u = restore()
+			if (u) undoers.push(u)
+		}
+		if (undoers.length > 0) activeUndoers.set(asyncId, undoers)
+	},
+	after(asyncId) {
+		const undoers = activeUndoers.get(asyncId)
+		if (!undoers) return
+		for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
+		activeUndoers.delete(asyncId)
+	},
+	destroy(asyncId) {
+		contexts.delete(asyncId)
+		activeUndoers.delete(asyncId)
+	},
+})
+hook.enable()
+
+// 2. Shadow Promise Implementation
+// Ensures V8 await resumptions are visible as .then callbacks, wrapping them to restore context.
+
+const OriginalPromise = globalThis.Promise
+const originalMethods = {
+	then: OriginalPromise.prototype.then,
+	catch: OriginalPromise.prototype.catch,
+	finally: OriginalPromise.prototype.finally,
+	resolve: OriginalPromise.resolve,
+	reject: OriginalPromise.reject,
+	all: OriginalPromise.all,
+}
+
+
+
+// Patch prototype
+OriginalPromise.prototype.then = function(onFulfilled, onRejected) {
+	return originalMethods.then.call(this, wrap(onFulfilled), wrap(onRejected))
+} as any
+OriginalPromise.prototype.catch = function(onRejected) {
+	return originalMethods.catch.call(this, wrap(onRejected))
+} as any
+OriginalPromise.prototype.finally = function(onFinally) {
+	return originalMethods.finally.call(this, wrap(onFinally))
+} as any
+
+

package/src/decorator.ts

@@ -62,7 +62,11 @@ type DDMethod<T> = (
 	name: PropertyKey
 ) => ((this: T, ...args: any[]) => any) | void
 
-type DDGetter<T> = (original: (this: T) => any, target: any, name: PropertyKey) => ((this: T) => any) | void
+type DDGetter<T> = (
+	original: (this: T) => any,
+	target: any,
+	name: PropertyKey
+) => ((this: T) => any) | void
 
 type DDSetter<T> = (
 	original: (this: T, value: any) => void,

package/src/destroyable.ts

@@ -117,7 +117,7 @@ export function Destroyable<
 		base = undefined
 	}
 	if (!base) {
-		base = class { } as T
+		base = class {} as T
 	}
 
 	return class Destroyable extends (base as T) {

package/src/entry-browser.ts

@@ -0,0 +1,5 @@
+// Import environment-specific patches first (SIDE EFFECTS)
+import './async/browser'
+
+// Then export the library
+export * from './index'

package/src/entry-node.ts

@@ -0,0 +1,5 @@
+// Import environment-specific patches first (SIDE EFFECTS)
+import './async/node'
+
+// Then export the library
+export * from './index'

package/src/index.d.ts

@@ -1,9 +1,12 @@
-// Augment Array.isArray to properly handle readonly arrays in type narrowing
-interface ArrayConstructor {
-	/**
-	 * Determines whether an object is an array.
-	 * @param arg Any value to test.
-	 * @returns True if the value is an array (mutable or readonly), false otherwise.
-	 */
-	isArray(arg: any): arg is any[] | readonly any[]
-}
+export * from './decorator';
+export * from './destroyable';
+export * from './eventful';
+export * from './indexable';
+export * from './iterableWeak';
+export * from './mixins';
+export * from './promiseChain';
+export * from './reactive';
+export * from './std-decorators';
+export * from './utils';
+export * from './zone';
+export * from './async';