vitest-auto-spy 5.55.0 → 5.56.0

package/CHANGELOG.md

@@ -10,6 +10,70 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.56.0] - 2026-09-30
+
+### Fixed
+
+- **`no-real-component-provider` no longer reports a double the spec declares itself.** Under
+  `{ childInjectors: true }` a read by position, such as
+  `query(By.css('app-footer')).children[0].injector.get(FooterDouble)`, was reported unless the class
+  also appeared in `By.directive(…)`. Classes the file declares (`class FooterDouble {}`,
+  `const X = class {}`, inside a `describe` too) are now left alone as test doubles; a production
+  class they extend is still reported when read.
+- **`no-inline-test-data` no longer counts short tuples or flag bags as repeated data.** An array of
+  up to three short numbers, booleans or strings (`[1, 5]`, `['0', '1']`) is a coordinate or an id
+  list, and an object of up to three `true`/`false` keys (`{ recursive: true, force: true }`) is an
+  options bag; neither is reported as a repeat. `{ from: [1, 1], to: [1, 5] }` written three times
+  is now reported once per copy instead of once per tuple. A copy that sits inside a literal already
+  reported is no longer reported a second time. On a consumer suite of ~85 specs, 16 of the 37
+  reports at the defaults were such tuples.
+- **`no-inline-test-data` no longer asks to move an expected value out of the test.** A long literal
+  passed to `toEqual`, `toStrictEqual`, `toMatchObject`, `toHaveBeenCalledWith` and the other
+  equality matchers, or to `expect.objectContaining` / `arrayContaining`, is what the test checks:
+  the message now asks to keep its shape inline and names the largest part inside it to move, or to
+  check fewer entries when it has none.
+- **`shared-env-without-restore` reads the options a setup file really passes.** It used to regex
+  the text between the parentheses, so `setupAutoSpy(OPTIONS)` and
+  `setupAutoSpy({ ...OPTIONS, blockNetwork: false })` were told every restore switch was off. An
+  object declared in the file or imported from another module of the repository now counts, spreads
+  apply in order with a later key winning, and a value the check cannot read is never reported as
+  off. Each setup file is judged on its own calls and named in its own finding, instead of one call
+  anywhere silencing the finding for every setup file; the setup files the runner config lists still
+  add up, since they run together.
+
+### Added
+
+- **`no-inline-test-data` suggests a spec-local `const` for a literal that reads the spec's own
+  names.** A repeated literal that reads or spreads a `const`, `let`, function or parameter the spec
+  declares (`['-a', 'Chrome', TARGET]`, `{ ...EMPTY, id: 1 }`) gets a message that asks to name it
+  once beside that binding, since a `*.mock.ts` cannot see it. With the two `no-inline-test-data` fixes above,
+  this adds 1.16 kB min+gzip to `/eslint-plugin` (52.04 → 53.20 kB), which only ESLint loads, never a
+  test run.
+- **`createAutoMock<T>(config)` — options without a placeholder seed.**
+  `createAutoMock<EventSource>({ returnsUndefined: ['close'] })` (and the same on `autoMocked`) reads
+  the bag as configuration instead of storing it as a seed, so `createAutoMock<T>(undefined, { … })`
+  is no longer the only spelling. The one argument counts as options only when every key is an option
+  and at least one of them is `returnsUndefined`, `selfReturning`, `returnsClass`,
+  `observablePropsToSpyOn`, `onUnstubbedCall` or `onUnstubbedRead`. `{ strict: true }`, `{ name }` or
+  `{ returns }` alone could be a real member of `T`, so they stay seeds at runtime and the compiler
+  rejects them where `T` has no such member; pass them second as before. Any second argument (`{}`
+  included) keeps the first a seed.
+- **`returnsClass: { method: Class }` — a method that returns a double of another class, in one
+  entry.** `provideAutoSpy(ReportFactory, { returnsClass: { create: Report } })` replaces
+  `const report = createSpyFromClass(Report)` plus `returns: { create: asInstance(report) }`. Every
+  call answers the same `Spy<Report>`, one per outer double, reached as `asSpy(factory.create(…))`.
+  Taken by every factory that takes `returns` (`createSpyFromClass`, `createSpyFromInstance`,
+  `createAutoMock`, `autoMocked`, `provideAutoSpy`, `provideAutoSpyForToken`,
+  `registerAutoSpyDefaults`). It counts as configured under `strict`, merges key by key in
+  registrations, and a method also named in `returns` answers that value.
+- **`doctor` warns when a build tsconfig ships the test data next to the specs**
+  (`tsconfig-ships-mock-file`). `no-inline-test-data` moves data to a `*.mock.ts` beside the spec,
+  and a generated `tsconfig.lib.json` usually excludes only `**/*.spec.ts`, so `tsc` or a
+  declaration plugin emits every mock file into the package. A config whose `exclude` has a spec glob
+  but lets a `*.mock.ts`, `*.fixtures.ts` or `__mocks__/` file through is reported, with the
+  `exclude` globs to add. App configs, configs next to `ng-package.json`, `noEmit` configs and
+  configs another one extends are left alone. The `no-inline-test-data` docs say the same.
+
 ## [5.55.0] - 2026-09-30
 
 ### Fixed
@@ -6684,7 +6748,8 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.55.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.56.0...HEAD
+[5.56.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.55.0...v5.56.0
 [5.55.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.54.0...v5.55.0
 [5.54.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.53.0...v5.54.0
 [5.53.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.52.0...v5.53.0

package/README.md

@@ -15,7 +15,7 @@ replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spie
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-29.8%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-30.0%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -1295,6 +1295,7 @@ error  tsconfig-glob-matches-nothing libs/users/tsconfig.spec.json
 | -------------------------------------- | --------------------------------------------------------------------------------------------------------- |
 | `tsconfig-glob-matches-nothing`        | An `include` pattern that matches no file, so it type-checks nothing                                      |
 | `tsconfig-file-missing`                | A `files` entry naming a file that is gone                                                                |
+| `tsconfig-ships-mock-file`             | A build tsconfig that excludes the specs but compiles the `*.mock.ts` next to them into the package       |
 | `spec-imported-by-non-spec`            | A production module importing a `*.spec.ts`                                                               |
 | `spec-exports-fixture`                 | A spec importing another spec, whose hooks then run in the wrong file                                     |
 | `foreign-runner-pragma`                | `@jest-config` or a bare `@jest-environment` that no runner here reads                                    |
@@ -3812,6 +3813,7 @@ Helpers on each spied member, by return type:
 | `instanceMethodsToSpyOn`            | same as `methodsToSpyOn`, for callables on the instance (`signal()` fields, arrow props, `signalStore()` methods)     |
 | `observablePropsToSpyOn`            | Observable properties to spy                                                                                          |
 | `returnsUndefined`                  | methods that answer `undefined`, counted as configured under `strict`                                                 |
+| `returnsClass`                      | `{ create: Report }`: the method answers one spy of that class per double, reached as `asSpy(double.create())`        |
 | `gettersToSpyOn` / `settersToSpyOn` | accessors to spy                                                                                                      |
 | `autoSpyAccessors`                  | spies every getter and setter on the prototype                                                                        |
 | `fillMissing`                       | answers a name the prototype never had with a spy (a partially abstract class)                                        |

package/agent-docs/checklist.md

@@ -84,8 +84,11 @@ cannot name, since ESM fails to link first — with the runner's entry to use. F
 Angular suites: `angular-testbed-split` (an Analog config without `server.deps.inline: ['vitest-auto-spy']`,
 which gives `/angular` a second `TestBed`), `angular-cache-off-in-ci` (the builder cache never reaches
 CI: +33 % per run on a 700-file suite), `shared-env-without-restore` (a shared environment without
-the `setupAutoSpy` restore options) and `mock-registry-capture-drops-sentinel` (a hand-rolled registry
-pruner that can drop the `clearAllMocks` sweep). The `tsconfig` checks do not judge a `../` entry,
+the `setupAutoSpy` restore options; each setup file is judged on its own calls, an options object declared,
+imported or spread counts, and a value it cannot read is never called off) and `mock-registry-capture-drops-sentinel` (a hand-rolled registry
+pruner that can drop the `clearAllMocks` sweep). `tsconfig-ships-mock-file` warns about a build
+tsconfig whose `exclude` leaves out the specs but not the `*.mock.ts` / `*.fixtures.ts` / `__mocks__/`
+files beside them, so they ship in the package. The `tsconfig` checks do not judge a `../` entry,
 a missing generated `.d.ts` in `files`, or `include` on a scan that hit its cap, and the import graph
 ignores specifiers in comments and strings and follows tsconfig `paths` / `baseUrl` through `extends`.
 It is worth one run after any large edit to a test suite — especially after a codemod, which is where

package/agent-docs/configuration.md

@@ -36,6 +36,7 @@ createSpyFromClass(MyService, {
 | `overrides` | Replaces **any member** with the value as written — a field, a signal, an `Observable` property. The member is no longer a spy, except a plain function seeded on a method (class factories only), which becomes its spy. Named in both, `overrides` wins. |
 | `selfReturning` | The named methods answer the double itself — a default like `returns`; a name in both answers `returns`. |
 | `returnsUndefined` | The list form of `returns: { m: undefined }` — `provideAutoSpy(CartStore, { strict: true, returnsUndefined: ['add', 'remove', 'clear'] })`; a name also in `returns` answers that. `createAutoMock`, `provideAutoSpyForToken` and `registerAutoSpyDefaults` take it too. |
+| `returnsClass` | `{ method: Class }` — the method answers a spy of that class, built once per double (`asSpy(double.m())` reaches it; that read is a call). The one-entry form of `returns: { m: asInstance(createSpyFromClass(Class)) }`; `returns` wins for the same name. Every factory that takes `returns` takes it. With nothing seeded, `createAutoMock<T>({ returnsUndefined: [...] })` takes the options first. |
 
 ### `instanceMethodsToSpyOn` for members discovery cannot see
 

package/agent-docs/eslint.md

@@ -73,7 +73,7 @@ export default [
 | `no-dead-schemas` | `error` | — | `schemas` on a testing module with no `declarations` — the schema applies to nothing; the file decides, so a `declarations` in another `configureTestingModule` call silences it |
 | `no-import-time-spread` | `error` | suggest | `export const x = [...Imported]` at module scope → a `TypeError`, or a silently empty object, while the bundle loads |
 | `no-unregistered-inject-spy` | `error` | — | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler. A `providers` value is read when it is an array literal or a never-mutated `const` holding one (`{ providers }`, a quoted `'providers':` key too); anything else makes the file unreadable and silent |
-| `no-real-component-provider` | `error` | — | `fixture.debugElement.injector.get(X)` for a component-level provider nothing in the file replaced → the real store under a component spec; `overrideComponentProvider(CartComponent, X)` — the fix names the class `By.directive(…)` found or the one class the file creates, `Component` when there are several; `{ ignoreTokens }` for an intended integration test; `{ childInjectors: true }` also reads `query(…)`, `queryAll(…)[i]` and `children[i]` injectors, leaving classes named in `By.directive(…)` alone |
+| `no-real-component-provider` | `error` | — | `fixture.debugElement.injector.get(X)` for a component-level provider nothing in the file replaced → the real store under a component spec; `overrideComponentProvider(CartComponent, X)` — the fix names the class `By.directive(…)` found or the one class the file creates, `Component` when there are several; `{ ignoreTokens }` for an intended integration test; `{ childInjectors: true }` also reads `query(…)`, `queryAll(…)[i]` and `children[i]` injectors, leaving classes named in `By.directive(…)` alone; classes the spec declares itself are doubles and never reported |
 | `prefer-render-shallow` | `warn` | suggest | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children. Under `{ templates: 'never' }` also every DOM read (`nativeElement`, any `By.*`, the global `document`, `inject(DOCUMENT)`…, once per statement), a `@Component` with markup declared in the spec and a `template:` handed to `renderShallow` / `prepareShallow`; a file that calls or imports `createDirectiveHost` is exempt |
 | `prefer-set-inputs` | `warn` | suggest | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })` — the name is resolved against the compiled definition before the first write (an undeclared one is an `NG0303` and no change) and the value is typed. The run collapses into one call and a `detectChanges()` under it goes; offered, not applied, because `stable()` ticks and a zone.js suite answers that with `NG0101` |
 | `prefer-to-have-signal-value` | `warn` | `--fix` | `expect(component.total()).toBe(3)` / `toEqual(…)` → `expect(component.total).toHaveSignalValue(3)`, `toStrictEqual` → `{ strict: true }`, `toBeNull()` / `toBeUndefined()` → `toHaveSignalValue(null)` / `(undefined)`; the matcher names the signal in the failure and refuses a value that is not one. **Type-aware**: the signal is recognised by Angular's brand on its type, so methods, functions and getters are never reported, and without `parserOptions.project` it reports nothing. A `toBe` against an object-typed signal (`expect(list.items()).toBe(items)`) is an identity check the deep matcher would lose, so it is reported only when the expected value is a primitive literal or the signal's type is primitive |
@@ -100,7 +100,7 @@ export default [
 | `no-outer-binding-in-mock-factory` | `error` | — | a `vi.mock(path, factory)` factory reading a top-level `const` / `let` / `var` / `class` declared outside `vi.hoisted` — the factory is hoisted above it, so the read is `Cannot access 'x' before initialization` → `const { user } = vi.hoisted(() => ({ user: … }))`. Only reads made while the factory runs count; function declarations, imports, type positions and `vi.doMock` are not reported |
 | `no-relative-mock-under-builder` | `error` | — | `vi.mock` / `doMock` / `importMock` / `unmock` / `doUnmock` with a specifier starting `.` or `/` in a spec `@angular/build:unit-test` runs — the builder throws on it → `provideAutoSpy(X)`, or `overrideComponentProvider` for a component's own provider. **Silent until** an `@angular/build:unit-test` / `@nx/angular:unit-test` target serving the file is found (the `no-redundant-mock-reset` search) or `{ builder: 'unit-test' }` says so; a tsconfig path alias to a workspace file is reported too (the builder bundles it, so the mock silently does nothing) unless every run's `buildTarget` lists it in `externalDependencies` |
 | `no-real-wait-in-test` | `warn` | — | a sleep on the real clock — `new Promise((r) => setTimeout(r, N))` in any spelling where `resolve` reaches the timer, `setTimeout(N)` from `node:timers/promises`; a `sleep(ms)` helper once, at its definition; a missing or `0` delay is left alone → `setupFakeTimers()` + `await advanceTimers(N)`, or wait for the outcome (`vi.waitFor`, `fixture.whenStable()`) |
-| `no-inline-test-data` | `warn` | — | test data inline in a spec — a data literal over `maxLines` (20) lines, or the same literal `repeats` (3) times in one file with at least `minValues` (2) values, one spelled out → export it once from `<name>.mock.ts` next to the spec. Never reported: module wiring (`providers`, `imports`…), `it.each` tables, `vi.mock` factories, literals holding a function, and files named `*.mock.ts` / `*.fixture.ts` / under `__mocks__/` |
+| `no-inline-test-data` | `warn` | — | test data inline in a spec — a data literal over `maxLines` (20) lines, or the same literal `repeats` (3) times in one file with at least `minValues` (2) values, one spelled out → export it once from `<name>.mock.ts` next to the spec (a `tsc`-built library must add `**/*.mock.ts` to its build tsconfig's `exclude`). A copy that reads a name the spec declares → a spec-local `const` instead. A long expected value (`toEqual`, `toMatchObject`, `toHaveBeenCalledWith`…) → keep its shape inline, move the largest part the message names. Never reported: module wiring (`providers`, `imports`…), `it.each` tables, `vi.mock` factories, literals holding a function, short tuples (`[1, 5]`, `['0', '1']`) and flag bags (≤ 3 boolean keys) as repeats, and files named `*.mock.ts` / `*.fixture.ts` / under `__mocks__/` |
 | `no-disabled-testbed-teardown` | `error` | — | `destroyAfterEach: false`, in `initTestEnvironment` or one `configureTestingModule` — every fixture outlives its test, `ngOnDestroy` never runs → delete it (Angular's default since v13) and fix the test that then fails. A config scoped to `**/*.spec.ts` must add the setup file to `files` |
 | `no-redundant-mock-reset` | `error` | `--fix` / suggest | a mock reset the runner already performs between tests — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — standing where nothing the file wrote ran since the runner's own: the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear as the last statement of an `afterEach` → delete it, and the hook with it where that is all it held. A restore or reset in `afterEach` / `afterAll` is never reported: after the last test it is what takes a spy off before the `afterAll` hooks. **Silent** until the flags are known: options `{ clearMocks, restoreMocks, mockReset }` (or `{ configFile }` naming the runner config) first, then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text; a config that leaves `clearMocks` out counts it on from Vitest 5 (its default). Where an `@angular/build:unit-test` / `@nx/angular:unit-test` target (found in `angular.json` / `project.json` above the file) also serves the spec, a config flag counts only if that target's `runnerConfig` applies it too — without `runnerConfig` the builder runs Vitest's defaults, so `restoreMocks` / `mockReset` from `vitest.config.ts` do not make a reset dead there, while a clear stays reported on Vitest 5; the rule's inline flags are not narrowed. A config built by a factory or `mergeConfig` from another module is not read through — name its flags as `{ configFile, configFlags: { clearMocks: true } }`, read as if the file set them, so the builder narrowing still applies (`configFlags` needs `configFile`; `doctor` notes the case as `mock-reset-config-unread`). `setupAutoSpy({ restoreMocks: true })` is not the runner's `restoreMocks` (it restores in an `afterEach`, after the test) — never pass the rule a flag only the setup file sets. Flag matches call, never family — `restoreMocks` walks only the spies `vi.spyOn` installed. `--fix` only in a file whose only before-hook it is; a suggestion otherwise; never inside a test body |
 | `no-unasserted-argument` | `warn` | — | a bare `expect(spy).toHaveBeenCalled()` on evidence from the file: the same subject asserted with `toHaveBeenCalledWith(…)` in another test, or a title containing `with` over a body whose every assertion is a bare call → `toHaveBeenCalledWith(…)` / `mustBeCalledWith(…)`. `not.toHaveBeenCalled()` and the counting matchers are never reported |

package/agent-docs/factories.md

@@ -51,6 +51,20 @@ not with the intersection spelt out. `returns` also takes an optional method wri
 `getMinZoom?: (() => number) | undefined` — the way Leaflet and other third-party typings declare
 them.
 
+**Options alone go in the first argument** when nothing is seeded:
+`createAutoMock<EventSource>({ returnsUndefined: ['close'] })`. The single argument is read as options
+only when every key is an option and at least one is `returnsUndefined`, `selfReturning`,
+`returnsClass`, `observablePropsToSpyOn`, `onUnstubbedCall` or `onUnstubbedRead`; `autoMocked` reads
+it the same way. `{ strict: true }`, `{ name }` or `{ returns }` alone could be members of `T`, so the
+compiler rejects them there — pass them second, `createAutoMock<T>(undefined, { strict: true })`. Any
+second argument (`{}` included) keeps the first a seed.
+
+**A method that returns another class's double is one entry:** `returnsClass: { create: Report }` on
+any factory that takes `returns` builds `createSpyFromClass(Report)` once per outer double and makes
+`create()` answer it. Reach it with `asSpy(factory.create('a'))` — typed `Spy<Report>`, but that read
+is a recorded call, so keep `const report = createSpyFromClass(Report)` +
+`returns: { create: asInstance(report) }` when the spec asserts `create`'s call count.
+
 `createMock<T>()` is the one to reach for on data shapes — it returns a plain `T`, so it satisfies a
 `no-type-assertion` lint rule without an `eslint-disable` on every fixture. `createMock<T>(undefined)`
 is the same call as `createMock<T>()` and answers `{}`, **not** `undefined` — a forwarding helper
@@ -158,7 +172,7 @@ but the last is a _read_. A node that is **called** returns what it was configur
 default that is `undefined`, so `mockDeep<AppLogger>().channel('app').info('x')` is a `TypeError` at
 the second call — while `DeepMockProxy<AppLogger>` types it perfectly, so nothing warns. Pass
 `{ selfReturning: true }` for a fluent API, or use
-`createAutoMock<T>(undefined, { selfReturning: ['channel'] })` when only one method chains:
+`createAutoMock<T>({ selfReturning: ['channel'] })` when only one method chains:
 
 ```ts
 const logger = mockDeep<AppLogger>({}, { selfReturning: true });
@@ -204,7 +218,7 @@ the same path in the assertion, or, for an API where every command answers the *
 `createAutoMock` instead, where `selfReturning` names methods that answer one double:
 
 ```ts
-const chain = createAutoMock<ChainedCommands>(undefined, { selfReturning: ['focus', 'insertContent'] });
+const chain = createAutoMock<ChainedCommands>({ selfReturning: ['focus', 'insertContent'] });
 const editor = createAutoMock<Editor>(undefined, { returns: { chain: asInstance(chain) } });
 
 editor.chain().focus().insertContent('text').run();

package/dist/angular-diagnostics.js

@@ -1,14 +1,14 @@
 import { pendingRequestsReport, assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, HTTP_TESTING_BRAND, beforeTestBedReset, verifyOnTeardown } from './chunk-JCTHGJTY.js';
 export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-JCTHGJTY.js';
-import { failOnUnspiedProvider, onTestBedFileEnd, isLazyDoubleFactory } from './chunk-OXONPFSL.js';
+import { failOnUnspiedProvider, onTestBedFileEnd, isLazyDoubleFactory } from './chunk-KHALREYP.js';
 import './chunk-T5MQSNRX.js';
 import './chunk-4JY7KIJG.js';
-import './chunk-JMBAECZN.js';
-import './chunk-UTOPAD66.js';
+import './chunk-RQLUH6RE.js';
+import './chunk-LKXOKRTC.js';
 import './chunk-F7UPX6YV.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-MDWE3FCP.js';
-import { isAutoSpyLike } from './chunk-UOKFQQ5H.js';
+import './chunk-UH2Q7RTQ.js';
+import { isAutoSpyLike } from './chunk-TXC3L3FO.js';
 import { count, sourceClassName, taskName } from './chunk-DYAS4OK4.js';
 import { angularPendingRequests, angularShadowedProviders, angularDeadSchemas, angularNgModuleScopesAuto } from './chunk-IATDAQMO.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/angular-doubles.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { InjectionToken, AbstractType, Injector, ValueProvider, FactoryProvider, ProviderToken, ChangeDetectorRef } from '@angular/core';
-import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-qYoxQi5C.js';
+import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-NphKNopY.js';
 import { DomSanitizer } from '@angular/platform-browser';
 import 'vitest';
 

package/dist/angular-doubles.js

@@ -1,16 +1,16 @@
-import { useVitestAdapter } from './chunk-ZVF3E6T7.js';
-import { describeInstance } from './chunk-M4CUD2XH.js';
+import { useVitestAdapter } from './chunk-JFROAGGY.js';
+import { describeInstance } from './chunk-3OEYMUV3.js';
 import { angularInternalsError } from './chunk-4JY7KIJG.js';
-import { createSpyFromClass } from './chunk-UTOPAD66.js';
-import './chunk-HRE4K6N3.js';
-import './chunk-7LZ6V5UO.js';
+import { createSpyFromClass } from './chunk-LKXOKRTC.js';
+import './chunk-XZ5JUXKT.js';
+import './chunk-ZTT2QLMJ.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-75WPOZKE.js';
 import './chunk-F7UPX6YV.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-MXKNUVYR.js';
-import { createFunctionSpy } from './chunk-MDWE3FCP.js';
-import './chunk-UOKFQQ5H.js';
+import { createFunctionSpy } from './chunk-UH2Q7RTQ.js';
+import './chunk-TXC3L3FO.js';
 import { sourceClassName } from './chunk-DYAS4OK4.js';
 import { angularDialog } from './chunk-IATDAQMO.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/angular-router.d.ts

@@ -1,6 +1,6 @@
 import { Type, Injector, FactoryProvider, Provider } from '@angular/core';
 import { Params, Data, UrlSegment, ActivatedRoute, Route, ResolveData, Navigation, Router, Event } from '@angular/router';
-import { h as AddSpyMethodsByReturnTypes } from './types-qYoxQi5C.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-NphKNopY.js';
 import { SpyLocation } from '@angular/common/testing';
 
 /**

package/dist/angular-router.js

@@ -1,8 +1,8 @@
-import { describeInstance } from './chunk-M4CUD2XH.js';
+import { describeInstance } from './chunk-3OEYMUV3.js';
 import { angularInternalsError } from './chunk-4JY7KIJG.js';
 import { getTestFinishedHook } from './chunk-MXKNUVYR.js';
-import { createFunctionSpy } from './chunk-MDWE3FCP.js';
-import './chunk-UOKFQQ5H.js';
+import { createFunctionSpy } from './chunk-UH2Q7RTQ.js';
+import './chunk-TXC3L3FO.js';
 import { count } from './chunk-DYAS4OK4.js';
 import { angularRouteDouble, angularRouterInject, angularRouterEvents, angularLocationDouble, angularRouteWiring, angularRouterDouble } from './chunk-IATDAQMO.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/angular.d.ts

@@ -1,13 +1,13 @@
 import './vitest-mock-types-B17-xaWt.js';
-export { w as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, x as provideAutoSpyForToken, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-CM-leczv.js';
-import { o as DeepPartial, m as ClassType, C as ClassSpyConfiguration, S as Spy, t as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-qYoxQi5C.js';
-export { J as SubjectOf } from './types-qYoxQi5C.js';
+export { w as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, x as provideAutoSpyForToken, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-BDQ6MqwO.js';
+import { o as DeepPartial, m as ClassType, C as ClassSpyConfiguration, S as Spy, u as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, s as NotAPublicKey } from './types-NphKNopY.js';
+export { K as SubjectOf } from './types-NphKNopY.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
-import { A as AutoMockConfiguration, D as DeepReadonly } from './emission-sync-xEda8ZCk.js';
-export { C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, n as expectNoEmissionSync, s as setEmissionTimeout } from './emission-sync-xEda8ZCk.js';
+import { b as AutoMockConfiguration, D as DeepReadonly } from './emission-sync-CNbHIKGX.js';
+export { C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, s as setEmissionTimeout } from './emission-sync-CNbHIKGX.js';
 import { TestAPI } from 'vitest';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-C6zITWXE.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-CE9gNMPY.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BkGvSEzV.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-vydpb5c5.js';
 import '@angular/core/testing';
 
 /**

package/dist/bun-angular.d.ts

@@ -1,10 +1,10 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as ObservablePropSpyMethods, t as OnlyMethodKeysOf, u as OnlyObservablePropsOf, v as OnlyPropsOf, w as Overload, x as OverloadChoice, y as Overloads, P as PropStubValue, S as Spy, z as SpyDisposable, B as SpyOptions, G as StrictSpyConfiguration, H as SubjectLike, J as SubjectOf, U as UnstubbedCall, K as UnstubbedCallHandler, L as UnstubbedRead, Q as UnstubbedReadHandler, V as ValueConfig, R as ValueConfigPerCall, W as WithMockReturnValue } from './types-qYoxQi5C.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, R as UnstubbedReadHandler, V as ValueConfig, T as ValueConfigPerCall, W as WithMockReturnValue } from './types-NphKNopY.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, n as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-xEda8ZCk.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-COBYU0WJ.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CE9gNMPY.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-Bg6JWPgu.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-CM-leczv.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-CNbHIKGX.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-Dhlx2i2x.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-vydpb5c5.js';
+export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DdJ251KZ.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-BDQ6MqwO.js';
 import '@angular/core';
 import '@angular/core/testing';
 

package/dist/bun-angular.js

@@ -1,25 +1,25 @@
-import { withTestBedSplitExplained } from './chunk-OXONPFSL.js';
-export { injectSpy, provideAutoSpy } from './chunk-OXONPFSL.js';
+import { withTestBedSplitExplained } from './chunk-KHALREYP.js';
+export { injectSpy, provideAutoSpy } from './chunk-KHALREYP.js';
 import { stable, flushEffects } from './chunk-RHGDQQNC.js';
 export { flushEffects, stable } from './chunk-RHGDQQNC.js';
 import { readSignalSymbol } from './chunk-T5MQSNRX.js';
 import { angularInternalsError } from './chunk-4JY7KIJG.js';
 import './chunk-VLEU3CWT.js';
-import { createSpyForToken } from './chunk-TIXTHSW4.js';
-export { createNestUnit } from './chunk-TIXTHSW4.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-GHKBJN2T.js';
-import { mockValueProp } from './chunk-JMBAECZN.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-JMBAECZN.js';
-import { closestName } from './chunk-UTOPAD66.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-UTOPAD66.js';
+import { createSpyForToken } from './chunk-RAJTKMDV.js';
+export { createNestUnit } from './chunk-RAJTKMDV.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-3IINYLDB.js';
+import { mockValueProp } from './chunk-RQLUH6RE.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
+import { closestName } from './chunk-LKXOKRTC.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-LKXOKRTC.js';
 import { fakeClockBacklog } from './chunk-SF4GKKN4.js';
 import './chunk-SOROJD3W.js';
 import './chunk-75WPOZKE.js';
 import './chunk-F7UPX6YV.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-MXKNUVYR.js';
-export { createFunctionSpy, errorHandler } from './chunk-MDWE3FCP.js';
-import { libraryWarn } from './chunk-UOKFQQ5H.js';
+export { createFunctionSpy, errorHandler } from './chunk-UH2Q7RTQ.js';
+import { libraryWarn } from './chunk-TXC3L3FO.js';
 import { displayPath, sourceClassName, count } from './chunk-DYAS4OK4.js';
 import { angularEffects, angularTrackRuns, bunAngular, angularUnreadResource, angularCreateWithAutoSpies, angularResources, angularTypedElements, angularOverrideLate, angularInputs, angularKeepTemplate } from './chunk-IATDAQMO.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/bun.d.ts

@@ -1,6 +1,6 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as ObservablePropSpyMethods, t as OnlyMethodKeysOf, u as OnlyObservablePropsOf, v as OnlyPropsOf, w as Overload, x as OverloadChoice, y as Overloads, P as PropStubValue, S as Spy, z as SpyDisposable, B as SpyOptions, G as StrictSpyConfiguration, H as SubjectLike, J as SubjectOf, U as UnstubbedCall, K as UnstubbedCallHandler, L as UnstubbedRead, Q as UnstubbedReadHandler, V as ValueConfig, R as ValueConfigPerCall, W as WithMockReturnValue } from './types-qYoxQi5C.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, R as UnstubbedReadHandler, V as ValueConfig, T as ValueConfigPerCall, W as WithMockReturnValue } from './types-NphKNopY.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, n as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-xEda8ZCk.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-COBYU0WJ.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CE9gNMPY.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-Bg6JWPgu.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-CNbHIKGX.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-Dhlx2i2x.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-vydpb5c5.js';
+export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DdJ251KZ.js';

package/dist/bun.js

@@ -1,16 +1,16 @@
 import './chunk-VLEU3CWT.js';
-export { createNestUnit } from './chunk-TIXTHSW4.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-GHKBJN2T.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-JMBAECZN.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-UTOPAD66.js';
+export { createNestUnit } from './chunk-RAJTKMDV.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-3IINYLDB.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-LKXOKRTC.js';
 import './chunk-SF4GKKN4.js';
 import './chunk-SOROJD3W.js';
 import './chunk-75WPOZKE.js';
 import './chunk-F7UPX6YV.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-MXKNUVYR.js';
-export { createFunctionSpy, errorHandler } from './chunk-MDWE3FCP.js';
-import './chunk-UOKFQQ5H.js';
+export { createFunctionSpy, errorHandler } from './chunk-UH2Q7RTQ.js';
+import './chunk-TXC3L3FO.js';
 import './chunk-DYAS4OK4.js';
 import './chunk-IATDAQMO.js';
 import './chunk-ENCEEH23.js';

package/dist/{chunk-GHKBJN2T.js → chunk-3IINYLDB.js}

@@ -1,11 +1,11 @@
-import { mockValueProp, mockAccessorsProp } from './chunk-JMBAECZN.js';
-import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-UTOPAD66.js';
+import { mockValueProp, mockAccessorsProp } from './chunk-RQLUH6RE.js';
+import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-LKXOKRTC.js';
 import { fakeClockAdvice, fakeClockBacklog } from './chunk-SF4GKKN4.js';
 import { unpatchedSetTimeout, unpatchedClearTimeout } from './chunk-SOROJD3W.js';
 import { redefineFailure } from './chunk-F7UPX6YV.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-MDWE3FCP.js';
-import { isMarkedMock, reportMisconfiguration, DEEP_CHILDREN } from './chunk-UOKFQQ5H.js';
+import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-UH2Q7RTQ.js';
+import { isMarkedMock, reportMisconfiguration, DEEP_CHILDREN } from './chunk-TXC3L3FO.js';
 import { count, displayPath } from './chunk-DYAS4OK4.js';
 import { moduleMocksAssert, moduleMocksNoOp, narrow, adoptMock, observableFailures, strictModePassthrough, createSpyFromClassReturns, captureArg, eventLoopUntil, mockConstructor, createSpyFromClassLiveDomNode } from './chunk-IATDAQMO.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/{chunk-M4CUD2XH.js → chunk-3OEYMUV3.js}

@@ -1,4 +1,4 @@
-import { isAutoSpyLike } from './chunk-UOKFQQ5H.js';
+import { isAutoSpyLike } from './chunk-TXC3L3FO.js';
 import { sourceClassName } from './chunk-DYAS4OK4.js';
 
 // src/lib/angular-instance-name.ts

package/dist/{chunk-ZVF3E6T7.js → chunk-JFROAGGY.js}

@@ -1,4 +1,4 @@
-import { createVitestMockAdapter } from './chunk-HRE4K6N3.js';
+import { createVitestMockAdapter } from './chunk-XZ5JUXKT.js';
 import { registerRunnerHooks } from './chunk-MXKNUVYR.js';
 import { hasMockAdapter, registerMockAdapter } from './shared-state.js';
 import { vi, afterEach, beforeEach } from 'vitest';

package/dist/{chunk-OXONPFSL.js → chunk-KHALREYP.js}

@@ -1,6 +1,6 @@
-import { currentSpecFile } from './chunk-JMBAECZN.js';
-import { createSpyFromClass } from './chunk-UTOPAD66.js';
-import { isAutoSpyLike, misconfigurationThrows, reportMisconfiguration } from './chunk-UOKFQQ5H.js';
+import { currentSpecFile } from './chunk-RQLUH6RE.js';
+import { createSpyFromClass } from './chunk-LKXOKRTC.js';
+import { isAutoSpyLike, misconfigurationThrows, reportMisconfiguration } from './chunk-TXC3L3FO.js';
 import { count, displayPath, sourceClassName } from './chunk-DYAS4OK4.js';
 import { setup, angularComponentStub, angularInjectSpyReal, angularTestBedCopies, installationVitest } from './chunk-IATDAQMO.js';
 import { withDocs } from './chunk-ENCEEH23.js';