static-injector 5.0.1 → 6.0.0

package/import/error_handler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Provides a hook for centralized exception handling.
+ *
+ * The default implementation of `ErrorHandler` prints error messages to the `console`. To
+ * intercept error handling, write a custom exception handler that replaces this default as
+ * appropriate for your app.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * ```ts
+ * class MyErrorHandler implements ErrorHandler {
+ *   handleError(error) {
+ *     // do something with the exception
+ *   }
+ * }
+ *
+ * // Provide in standalone apps
+ * bootstrapApplication(AppComponent, {
+ *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
+ * })
+ *
+ * // Provide in module-based apps
+ * @NgModule({
+ *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
+ * })
+ * class MyModule {}
+ * ```
+ *
+ * @publicApi
+ */
+export declare class ErrorHandler {
+    /**
+     * @internal
+     */
+    _console: Console;
+    handleError(error: any): void;
+}

package/{typings → import}/errors.d.ts

@@ -3,7 +3,7 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * The list of error codes used in runtime code of the `core` package.
@@ -13,7 +13,7 @@
  * angular.io. This extra annotation is needed to avoid introducing a separate set to store
  * error codes which have guides, which might leak into runtime code.
  *
- * Full list of available error guides can be found at https://angular.io/errors.
+ * Full list of available error guides can be found at https://angular.dev/errors.
  *
  * Error code ranges per package:
  *  - core (this package): 100-999
@@ -51,6 +51,7 @@ export declare const enum RuntimeErrorCode {
     HOST_DIRECTIVE_UNDEFINED_BINDING = 311,
     HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
     MULTIPLE_MATCHING_PIPES = 313,
+    UNINITIALIZED_LET_ACCESS = 314,
     MULTIPLE_PLATFORMS = 400,
     PLATFORM_NOT_FOUND = 401,
     MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
@@ -59,6 +60,7 @@ export declare const enum RuntimeErrorCode {
     ASYNC_INITIALIZERS_STILL_RUNNING = 405,
     APPLICATION_REF_ALREADY_DESTROYED = 406,
     RENDERER_NOT_FOUND = 407,
+    PROVIDED_BOTH_ZONE_AND_ZONELESS = 408,
     HYDRATION_NODE_MISMATCH = -500,
     HYDRATION_MISSING_SIBLINGS = -501,
     HYDRATION_MISSING_NODE = -502,
@@ -67,12 +69,13 @@ export declare const enum RuntimeErrorCode {
     MISSING_HYDRATION_ANNOTATIONS = -505,
     HYDRATION_STABLE_TIMEDOUT = -506,
     MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,
+    MISCONFIGURED_INCREMENTAL_HYDRATION = 508,
     SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,
     REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,
     ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT = -602,
     INVALID_I18N_STRUCTURE = 700,
     MISSING_LOCALE_DATA = 701,
-    DEFER_LOADING_FAILED = 750,
+    DEFER_LOADING_FAILED = -750,
     IMPORT_PROVIDERS_FROM_STANDALONE = 800,
     INVALID_DIFFER_INPUT = 900,
     NO_SUPPORTING_DIFFER_FACTORY = 901,
@@ -88,19 +91,22 @@ export declare const enum RuntimeErrorCode {
     VIEW_ALREADY_DESTROYED = 911,
     COMPONENT_ID_COLLISION = -912,
     IMAGE_PERFORMANCE_WARNING = -913,
+    UNEXPECTED_ZONEJS_PRESENT_IN_ZONELESS_MODE = 914,
     REQUIRED_INPUT_NO_VALUE = -950,
     REQUIRED_QUERY_NO_VALUE = -951,
-    REQUIRED_MODEL_NO_VALUE = -952,
+    REQUIRED_MODEL_NO_VALUE = 952,
     OUTPUT_REF_DESTROYED = 953,
-    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000,
-    RUNTIME_DEPS_ORPHAN_COMPONENT = 1001
+    LOOP_TRACK_DUPLICATE_KEYS = -955,
+    LOOP_TRACK_RECREATE = -956,
+    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 980,
+    RUNTIME_DEPS_ORPHAN_COMPONENT = 981
 }
 /**
  * Class that represents a runtime error.
  * Formats and outputs the error message in a consistent way.
  *
  * Example:
- * ```
+ * ```ts
  *  throw new RuntimeError(
  *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
  *    ngDevMode && 'Injector has already been destroyed.');

package/import/index.d.ts

@@ -0,0 +1,37 @@
+import type { InjectableDecorator } from './di/injectable';
+import { Injector } from './di/injector';
+import { EnvironmentProviders, Provider } from './di/interface/provider';
+import { R3Injector } from './di/r3_injector';
+import { InjectorScope } from './di/scope';
+export * from './di/injectable';
+export * from './di/metadata';
+export * from './di/r3_injector';
+export * from './di/interface/defs';
+export * from './di/injector_compatibility';
+export * from './di/injection_token';
+export * from './di/null_injector';
+export * from './di/injector';
+export * from './di/interface/injector';
+export * from './di/scope';
+export * from './render3/instructions/di';
+export * from './core_reactivity_export_internal';
+export * from './change_detection/scheduling/zoneless_scheduling';
+export * from './change_detection/scheduling/zoneless_scheduling_impl';
+export * from './resource';
+export declare class StaticInjectOptions {
+    static injectOptions: Parameters<InjectableDecorator>[0];
+}
+export declare class RootStaticInjectOptions {
+    static injectOptions: Parameters<InjectableDecorator>[0];
+}
+export declare function createInjector(options: {
+    providers: Array<Provider | EnvironmentProviders>;
+    parent: Injector;
+    name?: string;
+    scopes?: Set<InjectorScope>;
+}): R3Injector;
+export declare function createRootInjector(options: {
+    providers: Array<Provider | EnvironmentProviders>;
+    name?: string;
+    scopes?: Set<InjectorScope>;
+}): R3Injector;

package/{typings → import}/interface/lifecycle_hooks.d.ts

@@ -3,13 +3,13 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * A lifecycle hook that is called when a directive, pipe, or service is destroyed.
  * Use for any custom cleanup that needs to occur when the
  * instance is destroyed.
- * @see [Lifecycle hooks guide](guide/lifecycle-hooks)
+ * @see [Lifecycle hooks guide](guide/components/lifecycle)
  *
  * @usageNotes
  * The following snippet shows how a component can implement this interface

package/{typings → import}/interface/type.d.ts

@@ -3,7 +3,7 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * @description
@@ -31,28 +31,23 @@ export interface AbstractType<T> extends Function {
 export interface Type<T> extends Function {
     new (...args: any[]): T;
 }
-export type Mutable<T extends {
-    [x: string]: any;
-}, K extends string> = {
-    [P in K]: T[P];
-};
 /**
  * Returns a writable type version of type.
  *
  * USAGE:
  * Given:
- * ```
+ * ```ts
  * interface Person {readonly name: string}
  * ```
  *
  * We would like to get a read/write version of `Person`.
- * ```
+ * ```ts
  * const WritablePerson = Writable<Person>;
  * ```
  *
  * The result is that you can do:
  *
- * ```
+ * ```ts
  * const readonlyPerson: Person = {name: 'Marry'};
  * readonlyPerson.name = 'John'; // TypeError
  * (readonlyPerson as WritablePerson).name = 'John'; // OK

package/import/linker/destroy_ref.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { EnvironmentInjector } from '../di';
+/**
+ * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
+ * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
+ * is injected in a component or directive, the callbacks run when that component or
+ * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ *
+ * @publicApi
+ */
+export declare abstract class DestroyRef {
+    /**
+     * Registers a destroy callback in a given lifecycle scope.  Returns a cleanup function that can
+     * be invoked to unregister the callback.
+     *
+     * @usageNotes
+     * ### Example
+     * ```ts
+     * const destroyRef = inject(DestroyRef);
+     *
+     * // register a destroy callback
+     * const unregisterFn = destroyRef.onDestroy(() => doSomethingOnDestroy());
+     *
+     * // stop the destroy callback from executing if needed
+     * unregisterFn();
+     * ```
+     */
+    abstract onDestroy(callback: () => void): () => void;
+    /**
+     * @internal
+     * @nocollapse
+     */
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static __NG_ENV_ID__: (injector: EnvironmentInjector) => DestroyRef;
+}

package/import/pending_tasks.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { BehaviorSubject } from 'rxjs';
+import { OnDestroy } from './interface/lifecycle_hooks';
+/**
+ * Internal implementation of the pending tasks service.
+ */
+export declare class PendingTasksInternal implements OnDestroy {
+    private taskId;
+    private pendingTasks;
+    private get _hasPendingTasks();
+    hasPendingTasks: BehaviorSubject<boolean>;
+    add(): number;
+    has(taskId: number): boolean;
+    remove(taskId: number): void;
+    ngOnDestroy(): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+/**
+ * Service that keeps track of pending tasks contributing to the stableness of Angular
+ * application. While several existing Angular services (ex.: `HttpClient`) will internally manage
+ * tasks influencing stability, this API gives control over stability to library and application
+ * developers for specific cases not covered by Angular internals.
+ *
+ * The concept of stability comes into play in several important scenarios:
+ * - SSR process needs to wait for the application stability before serializing and sending rendered
+ * HTML;
+ * - tests might want to delay assertions until the application becomes stable;
+ *
+ * @usageNotes
+ * ```ts
+ * const pendingTasks = inject(PendingTasks);
+ * const taskCleanup = pendingTasks.add();
+ * // do work that should block application's stability and then:
+ * taskCleanup();
+ * ```
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export declare class PendingTasks {
+    private internalPendingTasks;
+    private scheduler;
+    /**
+     * Adds a new task that should block application's stability.
+     * @returns A cleanup function that removes a task when called.
+     */
+    add(): () => void;
+    /**
+     * Runs an asynchronous function and blocks the application's stability until the function completes.
+     *
+     * ```ts
+     * pendingTasks.run(async () => {
+     *   const userData = await fetch('/api/user');
+     *   this.userData.set(userData);
+     * });
+     * ```
+     *
+     * Application stability is at least delayed until the next tick after the `run` method resolves
+     * so it is safe to make additional updates to application state that would require UI synchronization:
+     *
+     * ```ts
+     * const userData = await pendingTasks.run(() => fetch('/api/user'));
+     * this.userData.set(userData);
+     * ```
+     *
+     * @param fn The asynchronous function to execute
+     */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}

package/{typings → import}/render3/definition_factory.d.ts

@@ -3,7 +3,7 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { Type } from '../interface/type';
 /**

package/{typings → import}/render3/errors_di.d.ts

@@ -3,7 +3,7 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 import type { ProviderToken } from '../di';
 /** Throws an error when a token is not found in DI. */

package/{typings → import}/render3/fields.d.ts

@@ -3,7 +3,7 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 export declare const NG_FACTORY_DEF: string;
 /**

package/{typings → import}/render3/instructions/di.d.ts

@@ -3,7 +3,7 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a

package/import/render3/reactivity/api.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { SIGNAL } from '@angular/core/primitives/signals';
+/**
+ * A reactive value which notifies consumers of any changes.
+ *
+ * Signals are functions which returns their current value. To access the current value of a signal,
+ * call it.
+ *
+ * Ordinary values can be turned into `Signal`s with the `signal` function.
+ */
+export type Signal<T> = (() => T) & {
+    [SIGNAL]: unknown;
+};
+/**
+ * Checks if the given `value` is a reactive `Signal`.
+ */
+export declare function isSignal(value: unknown): value is Signal<unknown>;
+/**
+ * A comparison function which can determine if two values are equal.
+ */
+export type ValueEqualityFn<T> = (a: T, b: T) => boolean;

package/import/render3/reactivity/asserts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Asserts that the current stack frame is not within a reactive context. Useful
+ * to disallow certain code from running inside a reactive context (see {@link toSignal}).
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+export declare function assertNotInReactiveContext(debugFn: Function, extraContext?: string): void;

package/import/render3/reactivity/computed.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { Signal, ValueEqualityFn } from './api';
+/**
+ * Options passed to the `computed` creation function.
+ */
+export interface CreateComputedOptions<T> {
+    /**
+     * A comparison function which defines equality for computed values.
+     */
+    equal?: ValueEqualityFn<T>;
+    /**
+     * A debug name for the computed signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
+}
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ */
+export declare function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T>;

package/import/render3/reactivity/effect.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { ReactiveNode, SIGNAL } from '@angular/core/primitives/signals';
+import { InjectionToken } from '../../di/injection_token';
+import { Injector } from '../../di/injector';
+import { ChangeDetectionScheduler } from '../../change_detection/scheduling/zoneless_scheduling';
+import { EffectScheduler, SchedulableEffect } from './root_effect_scheduler';
+/**
+ * Toggle the flag on whether to use microtask effects (for testing).
+ */
+export declare function setUseMicrotaskEffectsByDefault(value: boolean): boolean;
+/**
+ * A global reactive effect, which can be manually destroyed.
+ *
+ * @developerPreview
+ */
+export interface EffectRef {
+    /**
+     * Shut down the effect, removing it from any upcoming scheduled executions.
+     */
+    destroy(): void;
+}
+export declare class EffectRefImpl implements EffectRef {
+    [SIGNAL]: EffectNode;
+    constructor(node: EffectNode);
+    destroy(): void;
+}
+/**
+ * Options passed to the `effect` function.
+ *
+ * @developerPreview
+ */
+export interface CreateEffectOptions {
+    /**
+     * The `Injector` in which to create the effect.
+     *
+     * If this is not provided, the current [injection context](guide/di/dependency-injection-context)
+     * will be used instead (via `inject`).
+     */
+    injector?: Injector;
+    /**
+     * Whether the `effect` should require manual cleanup.
+     *
+     * If this is `false` (the default) the effect will automatically register itself to be cleaned up
+     * with the current `DestroyRef`.
+     */
+    manualCleanup?: boolean;
+    /**
+     * Always create a root effect (which is scheduled as a microtask) regardless of whether `effect`
+     * is called within a component.
+     */
+    forceRoot?: true;
+    /**
+     * @deprecated no longer required, signal writes are allowed by default.
+     */
+    allowSignalWrites?: boolean;
+    /**
+     * A debug name for the effect. Used in Angular DevTools to identify the effect.
+     */
+    debugName?: string;
+}
+/**
+ * An effect can, optionally, register a cleanup function. If registered, the cleanup is executed
+ * before the next effect run. The cleanup function makes it possible to "cancel" any work that the
+ * previous effect run might have started.
+ *
+ * @developerPreview
+ */
+export type EffectCleanupFn = () => void;
+/**
+ * A callback passed to the effect function that makes it possible to register cleanup logic.
+ *
+ * @developerPreview
+ */
+export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
+/**
+ * Registers an "effect" that will be scheduled & executed whenever the signals that it reads
+ * changes.
+ *
+ * Angular has two different kinds of effect: component effects and root effects. Component effects
+ * are created when `effect()` is called from a component, directive, or within a service of a
+ * component/directive. Root effects are created when `effect()` is called from outside the
+ * component tree, such as in a root service, or when the `forceRoot` option is provided.
+ *
+ * The two effect types differ in their timing. Component effects run as a component lifecycle
+ * event during Angular's synchronization (change detection) process, and can safely read input
+ * signals or create/destroy views that depend on component state. Root effects run as microtasks
+ * and have no connection to the component tree or change detection.
+ *
+ * `effect()` must be run in injection context, unless the `injector` option is manually specified.
+ *
+ * @developerPreview
+ */
+export declare function effect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;
+export interface EffectNode extends ReactiveNode, SchedulableEffect {
+    hasRun: boolean;
+    cleanupFns: EffectCleanupFn[] | undefined;
+    injector: Injector;
+    notifier: ChangeDetectionScheduler;
+    onDestroyFn: () => void;
+    fn: (cleanupFn: EffectCleanupRegisterFn) => void;
+    run(): void;
+    destroy(): void;
+    maybeCleanup(): void;
+}
+export interface RootEffectNode extends EffectNode {
+    scheduler: EffectScheduler;
+}
+/**
+ * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
+ * injector.
+ */
+export declare const APP_EFFECT_SCHEDULER: InjectionToken<EffectScheduler>;
+export declare const BASE_EFFECT_NODE: Omit<EffectNode, 'fn' | 'destroy' | 'injector' | 'notifier'>;
+export declare const ROOT_EFFECT_NODE: Omit<RootEffectNode, 'fn' | 'scheduler' | 'notifier' | 'injector'>;
+export declare function createRootEffect(fn: (onCleanup: EffectCleanupRegisterFn) => void, scheduler: EffectScheduler, notifier: ChangeDetectionScheduler): RootEffectNode;

package/import/render3/reactivity/linked_signal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { WritableSignal } from './signal';
+import { ValueEqualityFn } from './api';
+/**
+ * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.
+ *
+ * @developerPreview
+ */
+export declare function linkedSignal<D>(computation: () => D, options?: {
+    equal?: ValueEqualityFn<NoInfer<D>>;
+}): WritableSignal<D>;
+/**
+ * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.
+ * This is an advanced API form where the computation has access to the previous value of the signal and the computation result.
+ *
+ * Note: The computation is reactive, meaning the linked signal will automatically update whenever any of the signals used within the computation change.
+ *
+ * @developerPreview
+ */
+export declare function linkedSignal<S, D>(options: {
+    source: () => S;
+    computation: (source: NoInfer<S>, previous?: {
+        source: NoInfer<S>;
+        value: NoInfer<D>;
+    }) => D;
+    equal?: ValueEqualityFn<NoInfer<D>>;
+}): WritableSignal<D>;

package/import/render3/reactivity/microtask_effect.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type { CreateEffectOptions, EffectCleanupRegisterFn, EffectRef } from './effect';
+import { type SchedulableEffect, ZoneAwareEffectScheduler } from './root_effect_scheduler';
+export declare class MicrotaskEffectScheduler extends ZoneAwareEffectScheduler {
+    private readonly pendingTasks;
+    private taskId;
+    schedule(effect: SchedulableEffect): void;
+    flush(): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+/**
+ * Create a global `Effect` for the given reactive function.
+ */
+export declare function microtaskEffect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;

package/import/render3/reactivity/patch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Controls whether effects use the legacy `microtaskEffect` by default.
+ */
+export declare const USE_MICROTASK_EFFECT_BY_DEFAULT = false;