first commit

node_modules/@angular/platform-browser/fesm2022/animations.mjs

@@ -0,0 +1,194 @@
+/**
+ * @license Angular v17.0.8
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { Injectable, Inject, RendererFactory2, NgZone, ANIMATION_MODULE_TYPE, NgModule } from '@angular/core';
+export { ANIMATION_MODULE_TYPE } from '@angular/core';
+import { ɵDomRendererFactory2, BrowserModule } from '@angular/platform-browser';
+import * as i1 from '@angular/animations/browser';
+import { ɵAnimationEngine, ɵWebAnimationsStyleNormalizer, ɵAnimationRendererFactory, ɵAnimationStyleNormalizer, AnimationDriver, ɵWebAnimationsDriver, NoopAnimationDriver } from '@angular/animations/browser';
+import { DOCUMENT } from '@angular/common';
+
+class InjectableAnimationEngine extends ɵAnimationEngine {
+    // The `ApplicationRef` is injected here explicitly to force the dependency ordering.
+    // Since the `ApplicationRef` should be created earlier before the `AnimationEngine`, they
+    // both have `ngOnDestroy` hooks and `flush()` must be called after all views are destroyed.
+    constructor(doc, driver, normalizer, appRef) {
+        super(doc, driver, normalizer);
+    }
+    ngOnDestroy() {
+        this.flush();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: InjectableAnimationEngine, deps: [{ token: DOCUMENT }, { token: i1.AnimationDriver }, { token: i1.ɵAnimationStyleNormalizer }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: InjectableAnimationEngine }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: InjectableAnimationEngine, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.AnimationDriver }, { type: i1.ɵAnimationStyleNormalizer }, { type: i0.ApplicationRef }] });
+function instantiateDefaultStyleNormalizer() {
+    return new ɵWebAnimationsStyleNormalizer();
+}
+function instantiateRendererFactory(renderer, engine, zone) {
+    return new ɵAnimationRendererFactory(renderer, engine, zone);
+}
+const SHARED_ANIMATION_PROVIDERS = [
+    { provide: ɵAnimationStyleNormalizer, useFactory: instantiateDefaultStyleNormalizer },
+    { provide: ɵAnimationEngine, useClass: InjectableAnimationEngine }, {
+        provide: RendererFactory2,
+        useFactory: instantiateRendererFactory,
+        deps: [ɵDomRendererFactory2, ɵAnimationEngine, NgZone]
+    }
+];
+/**
+ * Separate providers from the actual module so that we can do a local modification in Google3 to
+ * include them in the BrowserModule.
+ */
+const BROWSER_ANIMATIONS_PROVIDERS = [
+    { provide: AnimationDriver, useFactory: () => new ɵWebAnimationsDriver() },
+    { provide: ANIMATION_MODULE_TYPE, useValue: 'BrowserAnimations' }, ...SHARED_ANIMATION_PROVIDERS
+];
+/**
+ * Separate providers from the actual module so that we can do a local modification in Google3 to
+ * include them in the BrowserTestingModule.
+ */
+const BROWSER_NOOP_ANIMATIONS_PROVIDERS = [
+    { provide: AnimationDriver, useClass: NoopAnimationDriver },
+    { provide: ANIMATION_MODULE_TYPE, useValue: 'NoopAnimations' }, ...SHARED_ANIMATION_PROVIDERS
+];
+
+/**
+ * Exports `BrowserModule` with additional [dependency-injection providers](guide/glossary#provider)
+ * for use with animations. See [Animations](guide/animations).
+ * @publicApi
+ */
+class BrowserAnimationsModule {
+    /**
+     * Configures the module based on the specified object.
+     *
+     * @param config Object used to configure the behavior of the `BrowserAnimationsModule`.
+     * @see {@link BrowserAnimationsModuleConfig}
+     *
+     * @usageNotes
+     * When registering the `BrowserAnimationsModule`, you can use the `withConfig`
+     * function as follows:
+     * ```
+     * @NgModule({
+     *   imports: [BrowserAnimationsModule.withConfig(config)]
+     * })
+     * class MyNgModule {}
+     * ```
+     */
+    static withConfig(config) {
+        return {
+            ngModule: BrowserAnimationsModule,
+            providers: config.disableAnimations ? BROWSER_NOOP_ANIMATIONS_PROVIDERS :
+                BROWSER_ANIMATIONS_PROVIDERS
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: BrowserAnimationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.8", ngImport: i0, type: BrowserAnimationsModule, exports: [BrowserModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: BrowserAnimationsModule, providers: BROWSER_ANIMATIONS_PROVIDERS, imports: [BrowserModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: BrowserAnimationsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [BrowserModule],
+                    providers: BROWSER_ANIMATIONS_PROVIDERS,
+                }]
+        }] });
+/**
+ * Returns the set of [dependency-injection providers](guide/glossary#provider)
+ * to enable animations in an application. See [animations guide](guide/animations)
+ * to learn more about animations in Angular.
+ *
+ * @usageNotes
+ *
+ * The function is useful when you want to enable animations in an application
+ * bootstrapped using the `bootstrapApplication` function. In this scenario there
+ * is no need to import the `BrowserAnimationsModule` NgModule at all, just add
+ * providers returned by this function to the `providers` list as show below.
+ *
+ * ```typescript
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     provideAnimations()
+ *   ]
+ * });
+ * ```
+ *
+ * @publicApi
+ */
+function provideAnimations() {
+    // Return a copy to prevent changes to the original array in case any in-place
+    // alterations are performed to the `provideAnimations` call results in app code.
+    return [...BROWSER_ANIMATIONS_PROVIDERS];
+}
+/**
+ * A null player that must be imported to allow disabling of animations.
+ * @publicApi
+ */
+class NoopAnimationsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: NoopAnimationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.8", ngImport: i0, type: NoopAnimationsModule, exports: [BrowserModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: NoopAnimationsModule, providers: BROWSER_NOOP_ANIMATIONS_PROVIDERS, imports: [BrowserModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: NoopAnimationsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [BrowserModule],
+                    providers: BROWSER_NOOP_ANIMATIONS_PROVIDERS,
+                }]
+        }] });
+/**
+ * Returns the set of [dependency-injection providers](guide/glossary#provider)
+ * to disable animations in an application. See [animations guide](guide/animations)
+ * to learn more about animations in Angular.
+ *
+ * @usageNotes
+ *
+ * The function is useful when you want to bootstrap an application using
+ * the `bootstrapApplication` function, but you need to disable animations
+ * (for example, when running tests).
+ *
+ * ```typescript
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     provideNoopAnimations()
+ *   ]
+ * });
+ * ```
+ *
+ * @publicApi
+ */
+function provideNoopAnimations() {
+    // Return a copy to prevent changes to the original array in case any in-place
+    // alterations are performed to the `provideNoopAnimations` call results in app code.
+    return [...BROWSER_NOOP_ANIMATIONS_PROVIDERS];
+}
+
+/**
+ * @module
+ * @description
+ * Entry point for all animation APIs of the animation browser package.
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+
+// This file is not used to build this module. It is only used during editing
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BrowserAnimationsModule, NoopAnimationsModule, provideAnimations, provideNoopAnimations, InjectableAnimationEngine as ɵInjectableAnimationEngine };
+//# sourceMappingURL=animations.mjs.map

node_modules/@angular/platform-browser/fesm2022/animations/async.mjs

@@ -0,0 +1,259 @@
+/**
+ * @license Angular v17.0.8
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { DOCUMENT } from '@angular/common';
+import { ɵRuntimeError, makeEnvironmentProviders, RendererFactory2, NgZone, ANIMATION_MODULE_TYPE } from '@angular/core';
+import { ɵDomRendererFactory2 } from '@angular/platform-browser';
+
+const ANIMATION_PREFIX = '@';
+class AsyncAnimationRendererFactory {
+    /**
+     *
+     * @param moduleImpl allows to provide a mock implmentation (or will load the animation module)
+     */
+    constructor(doc, delegate, zone, animationType, moduleImpl) {
+        this.doc = doc;
+        this.delegate = delegate;
+        this.zone = zone;
+        this.animationType = animationType;
+        this.moduleImpl = moduleImpl;
+        this._rendererFactoryPromise = null;
+    }
+    /**
+     * @internal
+     */
+    loadImpl() {
+        const moduleImpl = this.moduleImpl ?? import('@angular/animations/browser');
+        return moduleImpl
+            .catch((e) => {
+            throw new ɵRuntimeError(5300 /* RuntimeErrorCode.ANIMATION_RENDERER_ASYNC_LOADING_FAILURE */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                'Async loading for animations package was ' +
+                    'enabled, but loading failed. Angular falls back to using regular rendering. ' +
+                    'No animations will be displayed and their styles won\'t be applied.');
+        })
+            .then(({ ɵcreateEngine, ɵAnimationRendererFactory }) => {
+            // We can't create the renderer yet because we might need the hostElement and the type
+            // Both are provided in createRenderer().
+            const engine = ɵcreateEngine(this.animationType, this.doc);
+            const rendererFactory = new ɵAnimationRendererFactory(this.delegate, engine, this.zone);
+            this.delegate = rendererFactory;
+            return rendererFactory;
+        });
+    }
+    /**
+     * This method is delegating the renderer creation to the factories.
+     * It uses default factory while the animation factory isn't loaded
+     * and will rely on the animation factory once it is loaded.
+     *
+     * Calling this method will trigger as side effect the loading of the animation module
+     * if the renderered component uses animations.
+     */
+    createRenderer(hostElement, rendererType) {
+        const renderer = this.delegate.createRenderer(hostElement, rendererType);
+        if (renderer.ɵtype === 0 /* AnimationRendererType.Regular */) {
+            // The factory is already loaded, this is an animation renderer
+            return renderer;
+        }
+        // We need to prevent the DomRenderer to throw an error because of synthetic properties
+        if (typeof renderer.throwOnSyntheticProps === 'boolean') {
+            renderer.throwOnSyntheticProps = false;
+        }
+        // Using a dynamic renderer to switch the renderer implementation once the module is loaded.
+        const dynamicRenderer = new DynamicDelegationRenderer(renderer);
+        // Kick off the module loading if the component uses animations but the module hasn't been
+        // loaded yet.
+        if (rendererType?.data?.['animation'] && !this._rendererFactoryPromise) {
+            this._rendererFactoryPromise = this.loadImpl();
+        }
+        this._rendererFactoryPromise
+            ?.then((animationRendererFactory) => {
+            const animationRenderer = animationRendererFactory.createRenderer(hostElement, rendererType);
+            dynamicRenderer.use(animationRenderer);
+        })
+            .catch(e => {
+            // Permanently use regular renderer when loading fails.
+            dynamicRenderer.use(renderer);
+        });
+        return dynamicRenderer;
+    }
+    begin() {
+        this.delegate.begin?.();
+    }
+    end() {
+        this.delegate.end?.();
+    }
+    whenRenderingDone() {
+        return this.delegate.whenRenderingDone?.() ?? Promise.resolve();
+    }
+}
+/**
+ * The class allows to dynamicly switch between different renderer implementations
+ * by changing the delegate renderer.
+ */
+class DynamicDelegationRenderer {
+    constructor(delegate) {
+        this.delegate = delegate;
+        // List of callbacks that need to be replayed on the animation renderer once its loaded
+        this.replay = [];
+        this.ɵtype = 1 /* AnimationRendererType.Delegated */;
+    }
+    use(impl) {
+        this.delegate = impl;
+        if (this.replay !== null) {
+            // Replay queued actions using the animation renderer to apply
+            // all events and properties collected while loading was in progress.
+            for (const fn of this.replay) {
+                fn(impl);
+            }
+            // Set to `null` to indicate that the queue was processed
+            // and we no longer need to collect events and properties.
+            this.replay = null;
+        }
+    }
+    get data() {
+        return this.delegate.data;
+    }
+    destroy() {
+        this.replay = null;
+        this.delegate.destroy();
+    }
+    createElement(name, namespace) {
+        return this.delegate.createElement(name, namespace);
+    }
+    createComment(value) {
+        return this.delegate.createComment(value);
+    }
+    createText(value) {
+        return this.delegate.createText(value);
+    }
+    get destroyNode() {
+        return this.delegate.destroyNode;
+    }
+    appendChild(parent, newChild) {
+        this.delegate.appendChild(parent, newChild);
+    }
+    insertBefore(parent, newChild, refChild, isMove) {
+        this.delegate.insertBefore(parent, newChild, refChild, isMove);
+    }
+    removeChild(parent, oldChild, isHostElement) {
+        this.delegate.removeChild(parent, oldChild, isHostElement);
+    }
+    selectRootElement(selectorOrNode, preserveContent) {
+        return this.delegate.selectRootElement(selectorOrNode, preserveContent);
+    }
+    parentNode(node) {
+        return this.delegate.parentNode(node);
+    }
+    nextSibling(node) {
+        return this.delegate.nextSibling(node);
+    }
+    setAttribute(el, name, value, namespace) {
+        this.delegate.setAttribute(el, name, value, namespace);
+    }
+    removeAttribute(el, name, namespace) {
+        this.delegate.removeAttribute(el, name, namespace);
+    }
+    addClass(el, name) {
+        this.delegate.addClass(el, name);
+    }
+    removeClass(el, name) {
+        this.delegate.removeClass(el, name);
+    }
+    setStyle(el, style, value, flags) {
+        this.delegate.setStyle(el, style, value, flags);
+    }
+    removeStyle(el, style, flags) {
+        this.delegate.removeStyle(el, style, flags);
+    }
+    setProperty(el, name, value) {
+        // We need to keep track of animation properties set on default renderer
+        // So we can also set them also on the animation renderer
+        if (this.shouldReplay(name)) {
+            this.replay.push((renderer) => renderer.setProperty(el, name, value));
+        }
+        this.delegate.setProperty(el, name, value);
+    }
+    setValue(node, value) {
+        this.delegate.setValue(node, value);
+    }
+    listen(target, eventName, callback) {
+        // We need to keep track of animation events registred by the default renderer
+        // So we can also register them against the animation renderer
+        if (this.shouldReplay(eventName)) {
+            this.replay.push((renderer) => renderer.listen(target, eventName, callback));
+        }
+        return this.delegate.listen(target, eventName, callback);
+    }
+    shouldReplay(propOrEventName) {
+        //`null` indicates that we no longer need to collect events and properties
+        return this.replay !== null && propOrEventName.startsWith(ANIMATION_PREFIX);
+    }
+}
+
+/**
+ * Returns the set of [dependency-injection providers](guide/glossary#provider)
+ * to enable animations in an application. See [animations guide](guide/animations)
+ * to learn more about animations in Angular.
+ *
+ * When you use this function instead of the eager `provideAnimations()`, animations won't be
+ * renderered until the renderer is loaded.
+ *
+ * @usageNotes
+ *
+ * The function is useful when you want to enable animations in an application
+ * bootstrapped using the `bootstrapApplication` function. In this scenario there
+ * is no need to import the `BrowserAnimationsModule` NgModule at all, just add
+ * providers returned by this function to the `providers` list as show below.
+ *
+ * ```typescript
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     provideAnimationsAsync()
+ *   ]
+ * });
+ * ```
+ *
+ * @param type pass `'noop'` as argument to disable animations.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+function provideAnimationsAsync(type = 'animations') {
+    return makeEnvironmentProviders([
+        {
+            provide: RendererFactory2,
+            useFactory: (doc, renderer, zone) => {
+                return new AsyncAnimationRendererFactory(doc, renderer, zone, type);
+            },
+            deps: [DOCUMENT, ɵDomRendererFactory2, NgZone],
+        },
+        {
+            provide: ANIMATION_MODULE_TYPE,
+            useValue: type === 'noop' ? 'NoopAnimations' : 'BrowserAnimations',
+        },
+    ]);
+}
+
+/**
+ * @module
+ * @description
+ * Entry point for all animation APIs of the animation browser package.
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+
+// This file is not used to build this module. It is only used during editing
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { provideAnimationsAsync, AsyncAnimationRendererFactory as ɵAsyncAnimationRendererFactory };
+//# sourceMappingURL=async.mjs.map

node_modules/@angular/platform-browser/fesm2022/testing.mjs

@@ -0,0 +1,68 @@
+/**
+ * @license Angular v17.0.8
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { PlatformLocation } from '@angular/common';
+import { MockPlatformLocation } from '@angular/common/testing';
+import * as i0 from '@angular/core';
+import { PLATFORM_INITIALIZER, createPlatformFactory, platformCore, APP_ID, provideZoneChangeDetection, ɵZoneAwareQueueingScheduler, ɵEffectScheduler, NgModule } from '@angular/core';
+import { ɵBrowserDomAdapter, BrowserModule } from '@angular/platform-browser';
+
+function initBrowserTests() {
+    ɵBrowserDomAdapter.makeCurrent();
+}
+const _TEST_BROWSER_PLATFORM_PROVIDERS = [{ provide: PLATFORM_INITIALIZER, useValue: initBrowserTests, multi: true }];
+/**
+ * Platform for testing
+ *
+ * @publicApi
+ */
+const platformBrowserTesting = createPlatformFactory(platformCore, 'browserTesting', _TEST_BROWSER_PLATFORM_PROVIDERS);
+/**
+ * NgModule for testing.
+ *
+ * @publicApi
+ */
+class BrowserTestingModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: BrowserTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.8", ngImport: i0, type: BrowserTestingModule, exports: [BrowserModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: BrowserTestingModule, providers: [
+            { provide: APP_ID, useValue: 'a' },
+            provideZoneChangeDetection(),
+            { provide: PlatformLocation, useClass: MockPlatformLocation },
+            { provide: ɵZoneAwareQueueingScheduler },
+            { provide: ɵEffectScheduler, useExisting: ɵZoneAwareQueueingScheduler },
+        ], imports: [BrowserModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: BrowserTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [BrowserModule],
+                    providers: [
+                        { provide: APP_ID, useValue: 'a' },
+                        provideZoneChangeDetection(),
+                        { provide: PlatformLocation, useClass: MockPlatformLocation },
+                        { provide: ɵZoneAwareQueueingScheduler },
+                        { provide: ɵEffectScheduler, useExisting: ɵZoneAwareQueueingScheduler },
+                    ]
+                }]
+        }] });
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the platform-browser/testing package.
+ */
+
+/// <reference types="jasmine" />
+
+// This file is not used to build this module. It is only used during editing
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BrowserTestingModule, platformBrowserTesting };
+//# sourceMappingURL=testing.mjs.map

node_modules/@angular/platform-browser/fesm2022/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","sources":["../../../../../../packages/platform-browser/testing/src/browser.ts","../../../../../../packages/platform-browser/testing/src/testing.ts","../../../../../../packages/platform-browser/testing/public_api.ts","../../../../../../packages/platform-browser/testing/index.ts","../../../../../../packages/platform-browser/testing/testing.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {PlatformLocation} from '@angular/common';\nimport {MockPlatformLocation} from '@angular/common/testing';\nimport {APP_ID, createPlatformFactory, NgModule, PLATFORM_INITIALIZER, platformCore, provideZoneChangeDetection, StaticProvider, ɵEffectScheduler as EffectScheduler, ɵZoneAwareQueueingScheduler as ZoneAwareQueueingScheduler} from '@angular/core';\nimport {BrowserModule, ɵBrowserDomAdapter as BrowserDomAdapter} from '@angular/platform-browser';\n\nfunction initBrowserTests() {\n  BrowserDomAdapter.makeCurrent();\n}\n\nconst _TEST_BROWSER_PLATFORM_PROVIDERS: StaticProvider[] =\n    [{provide: PLATFORM_INITIALIZER, useValue: initBrowserTests, multi: true}];\n\n/**\n * Platform for testing\n *\n * @publicApi\n */\nexport const platformBrowserTesting =\n    createPlatformFactory(platformCore, 'browserTesting', _TEST_BROWSER_PLATFORM_PROVIDERS);\n\n/**\n * NgModule for testing.\n *\n * @publicApi\n */\n@NgModule({\n  exports: [BrowserModule],\n  providers: [\n    {provide: APP_ID, useValue: 'a'},\n    provideZoneChangeDetection(),\n    {provide: PlatformLocation, useClass: MockPlatformLocation},\n    {provide: ZoneAwareQueueingScheduler},\n    {provide: EffectScheduler, useExisting: ZoneAwareQueueingScheduler},\n  ]\n})\nexport class BrowserTestingModule {\n}\n","/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @module\n * @description\n * Entry point for all public APIs of the platform-browser/testing package.\n */\nexport * from './browser';\n","/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/// <reference types=\"jasmine\" />\n\n/**\n * @module\n * @description\n * Entry point for all public APIs of this package.\n */\nexport * from './src/testing';\n","/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// This file is not used to build this module. It is only used during editing\n// by the TypeScript language service and during build for verification. `ngc`\n// replaces this file with production index.ts when it rewrites private symbol\n// names.\n\nexport * from './public_api';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":["BrowserDomAdapter","ZoneAwareQueueingScheduler","EffectScheduler"],"mappings":";;;;;;;;;;;;AAYA,SAAS,gBAAgB,GAAA;IACvBA,kBAAiB,CAAC,WAAW,EAAE,CAAC;AAClC,CAAC;AAED,MAAM,gCAAgC,GAClC,CAAC,EAAC,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;AAE/E;;;;AAIG;AACI,MAAM,sBAAsB,GAC/B,qBAAqB,CAAC,YAAY,EAAE,gBAAgB,EAAE,gCAAgC,EAAE;AAE5F;;;;AAIG;MAWU,oBAAoB,CAAA;yHAApB,oBAAoB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,QAAA,EAAA,CAAA,CAAA,EAAA;AAApB,IAAA,SAAA,IAAA,CAAA,IAAA,GAAA,EAAA,CAAA,mBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,mBAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,oBAAoB,YATrB,aAAa,CAAA,EAAA,CAAA,CAAA,EAAA;AASZ,IAAA,SAAA,IAAA,CAAA,IAAA,GAAA,EAAA,CAAA,mBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,mBAAA,EAAA,QAAA,EAAA,EAAA,EAAA,IAAA,EAAA,oBAAoB,EARpB,SAAA,EAAA;AACT,YAAA,EAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAC;AAChC,YAAA,0BAA0B,EAAE;AAC5B,YAAA,EAAC,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,oBAAoB,EAAC;YAC3D,EAAC,OAAO,EAAEC,2BAA0B,EAAC;AACrC,YAAA,EAAC,OAAO,EAAEC,gBAAe,EAAE,WAAW,EAAED,2BAA0B,EAAC;AACpE,SAAA,EAAA,OAAA,EAAA,CAPS,aAAa,CAAA,EAAA,CAAA,CAAA,EAAA;;sGASZ,oBAAoB,EAAA,UAAA,EAAA,CAAA;kBAVhC,QAAQ;AAAC,YAAA,IAAA,EAAA,CAAA;oBACR,OAAO,EAAE,CAAC,aAAa,CAAC;AACxB,oBAAA,SAAS,EAAE;AACT,wBAAA,EAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAC;AAChC,wBAAA,0BAA0B,EAAE;AAC5B,wBAAA,EAAC,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,oBAAoB,EAAC;wBAC3D,EAAC,OAAO,EAAEA,2BAA0B,EAAC;AACrC,wBAAA,EAAC,OAAO,EAAEC,gBAAe,EAAE,WAAW,EAAED,2BAA0B,EAAC;AACpE,qBAAA;AACF,iBAAA,CAAA;;;ACjCD;;;;AAIG;;ACJH;;ACAA;;ACRA;;AAEG;;;;"}