1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 | import { ViewEncapsulation, Injectable, RendererFactory2, Inject, NgZone, InjectionToken, NgModule } from '@angular/core';
|
8 | import { ɵDomRendererFactory2, BrowserModule } from '@angular/platform-browser';
|
9 | import { AnimationBuilder, sequence, AnimationFactory } from '@angular/animations';
|
10 | import { ɵAnimationEngine, AnimationDriver, ɵAnimationStyleNormalizer, ɵsupportsWebAnimations, ɵWebAnimationsDriver, ɵCssKeyframesDriver, ɵWebAnimationsStyleNormalizer, ɵNoopAnimationDriver } from '@angular/animations/browser';
|
11 | import { DOCUMENT } from '@angular/common';
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 | class BrowserAnimationBuilder extends AnimationBuilder {
|
18 | |
19 |
|
20 |
|
21 |
|
22 | constructor(rootRenderer, doc) {
|
23 | super();
|
24 | this._nextAnimationId = 0;
|
25 |
|
26 | const typeData = ( ({
|
27 | id: '0',
|
28 | encapsulation: ViewEncapsulation.None,
|
29 | styles: [],
|
30 | data: { animation: [] }
|
31 | }));
|
32 | this._renderer = ( (rootRenderer.createRenderer(doc.body, typeData)));
|
33 | }
|
34 | |
35 |
|
36 |
|
37 |
|
38 | build(animation) {
|
39 |
|
40 | const id = this._nextAnimationId.toString();
|
41 | this._nextAnimationId++;
|
42 |
|
43 | const entry = Array.isArray(animation) ? sequence(animation) : animation;
|
44 | issueAnimationCommand(this._renderer, null, id, 'register', [entry]);
|
45 | return new BrowserAnimationFactory(id, this._renderer);
|
46 | }
|
47 | }
|
48 | BrowserAnimationBuilder.decorators = [
|
49 | { type: Injectable }
|
50 | ];
|
51 |
|
52 | BrowserAnimationBuilder.ctorParameters = () => [
|
53 | { type: RendererFactory2 },
|
54 | { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
|
55 | ];
|
56 | if (false) {
|
57 | |
58 |
|
59 |
|
60 |
|
61 | BrowserAnimationBuilder.prototype._nextAnimationId;
|
62 | |
63 |
|
64 |
|
65 |
|
66 | BrowserAnimationBuilder.prototype._renderer;
|
67 | }
|
68 | class BrowserAnimationFactory extends AnimationFactory {
|
69 | |
70 |
|
71 |
|
72 |
|
73 | constructor(_id, _renderer) {
|
74 | super();
|
75 | this._id = _id;
|
76 | this._renderer = _renderer;
|
77 | }
|
78 | |
79 |
|
80 |
|
81 |
|
82 |
|
83 | create(element, options) {
|
84 | return new RendererAnimationPlayer(this._id, element, options || {}, this._renderer);
|
85 | }
|
86 | }
|
87 | if (false) {
|
88 | |
89 |
|
90 |
|
91 |
|
92 | BrowserAnimationFactory.prototype._id;
|
93 | |
94 |
|
95 |
|
96 |
|
97 | BrowserAnimationFactory.prototype._renderer;
|
98 | }
|
99 | class RendererAnimationPlayer {
|
100 | |
101 |
|
102 |
|
103 |
|
104 |
|
105 |
|
106 | constructor(id, element, options, _renderer) {
|
107 | this.id = id;
|
108 | this.element = element;
|
109 | this._renderer = _renderer;
|
110 | this.parentPlayer = null;
|
111 | this._started = false;
|
112 | this.totalTime = 0;
|
113 | this._command('create', options);
|
114 | }
|
115 | |
116 |
|
117 |
|
118 |
|
119 |
|
120 |
|
121 | _listen(eventName, callback) {
|
122 | return this._renderer.listen(this.element, `@@${this.id}:${eventName}`, callback);
|
123 | }
|
124 | |
125 |
|
126 |
|
127 |
|
128 |
|
129 |
|
130 | _command(command, ...args) {
|
131 | return issueAnimationCommand(this._renderer, this.element, this.id, command, args);
|
132 | }
|
133 | |
134 |
|
135 |
|
136 |
|
137 | onDone(fn) { this._listen('done', fn); }
|
138 | |
139 |
|
140 |
|
141 |
|
142 | onStart(fn) { this._listen('start', fn); }
|
143 | |
144 |
|
145 |
|
146 |
|
147 | onDestroy(fn) { this._listen('destroy', fn); }
|
148 | |
149 |
|
150 |
|
151 | init() { this._command('init'); }
|
152 | |
153 |
|
154 |
|
155 | hasStarted() { return this._started; }
|
156 | |
157 |
|
158 |
|
159 | play() {
|
160 | this._command('play');
|
161 | this._started = true;
|
162 | }
|
163 | |
164 |
|
165 |
|
166 | pause() { this._command('pause'); }
|
167 | |
168 |
|
169 |
|
170 | restart() { this._command('restart'); }
|
171 | |
172 |
|
173 |
|
174 | finish() { this._command('finish'); }
|
175 | |
176 |
|
177 |
|
178 | destroy() { this._command('destroy'); }
|
179 | |
180 |
|
181 |
|
182 | reset() { this._command('reset'); }
|
183 | |
184 |
|
185 |
|
186 |
|
187 | setPosition(p) { this._command('setPosition', p); }
|
188 | |
189 |
|
190 |
|
191 | getPosition() { return 0; }
|
192 | }
|
193 | if (false) {
|
194 |
|
195 | RendererAnimationPlayer.prototype.parentPlayer;
|
196 | |
197 |
|
198 |
|
199 |
|
200 | RendererAnimationPlayer.prototype._started;
|
201 |
|
202 | RendererAnimationPlayer.prototype.totalTime;
|
203 |
|
204 | RendererAnimationPlayer.prototype.id;
|
205 |
|
206 | RendererAnimationPlayer.prototype.element;
|
207 | |
208 |
|
209 |
|
210 |
|
211 | RendererAnimationPlayer.prototype._renderer;
|
212 | }
|
213 |
|
214 |
|
215 |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 | function issueAnimationCommand(renderer, element, id, command, args) {
|
222 | return renderer.setProperty(element, `@@${id}:${command}`, args);
|
223 | }
|
224 |
|
225 |
|
226 |
|
227 |
|
228 |
|
229 |
|
230 | const ANIMATION_PREFIX = '@';
|
231 |
|
232 | const DISABLE_ANIMATIONS_FLAG = '@.disabled';
|
233 | class AnimationRendererFactory {
|
234 | |
235 |
|
236 |
|
237 |
|
238 |
|
239 | constructor(delegate, engine, _zone) {
|
240 | this.delegate = delegate;
|
241 | this.engine = engine;
|
242 | this._zone = _zone;
|
243 | this._currentId = 0;
|
244 | this._microtaskId = 1;
|
245 | this._animationCallbacksBuffer = [];
|
246 | this._rendererCache = new Map();
|
247 | this._cdRecurDepth = 0;
|
248 | this.promise = Promise.resolve(0);
|
249 | engine.onRemovalComplete = ( |
250 |
|
251 |
|
252 |
|
253 |
|
254 | (element, delegate) => {
|
255 |
|
256 |
|
257 |
|
258 |
|
259 | if (delegate && delegate.parentNode(element)) {
|
260 | delegate.removeChild(element.parentNode, element);
|
261 | }
|
262 | });
|
263 | }
|
264 | |
265 |
|
266 |
|
267 |
|
268 |
|
269 | createRenderer(hostElement, type) {
|
270 |
|
271 | const EMPTY_NAMESPACE_ID = '';
|
272 |
|
273 |
|
274 |
|
275 | const delegate = this.delegate.createRenderer(hostElement, type);
|
276 | if (!hostElement || !type || !type.data || !type.data['animation']) {
|
277 |
|
278 | let renderer = this._rendererCache.get(delegate);
|
279 | if (!renderer) {
|
280 | renderer = new BaseAnimationRenderer(EMPTY_NAMESPACE_ID, delegate, this.engine);
|
281 |
|
282 | this._rendererCache.set(delegate, renderer);
|
283 | }
|
284 | return renderer;
|
285 | }
|
286 |
|
287 | const componentId = type.id;
|
288 |
|
289 | const namespaceId = type.id + '-' + this._currentId;
|
290 | this._currentId++;
|
291 | this.engine.register(namespaceId, hostElement);
|
292 |
|
293 | const animationTriggers = ( (type.data['animation']));
|
294 | animationTriggers.forEach(( |
295 |
|
296 |
|
297 |
|
298 | trigger => this.engine.registerTrigger(componentId, namespaceId, hostElement, trigger.name, trigger)));
|
299 | return new AnimationRenderer(this, namespaceId, delegate, this.engine);
|
300 | }
|
301 | |
302 |
|
303 |
|
304 | begin() {
|
305 | this._cdRecurDepth++;
|
306 | if (this.delegate.begin) {
|
307 | this.delegate.begin();
|
308 | }
|
309 | }
|
310 | |
311 |
|
312 |
|
313 |
|
314 | _scheduleCountTask() {
|
315 |
|
316 | this.promise.then(( |
317 |
|
318 |
|
319 | () => { this._microtaskId++; }));
|
320 | }
|
321 | |
322 |
|
323 |
|
324 |
|
325 |
|
326 |
|
327 |
|
328 | scheduleListenerCallback(count, fn, data) {
|
329 | if (count >= 0 && count < this._microtaskId) {
|
330 | this._zone.run(( |
331 |
|
332 |
|
333 | () => fn(data)));
|
334 | return;
|
335 | }
|
336 | if (this._animationCallbacksBuffer.length == 0) {
|
337 | Promise.resolve(null).then(( |
338 |
|
339 |
|
340 | () => {
|
341 | this._zone.run(( |
342 |
|
343 |
|
344 | () => {
|
345 | this._animationCallbacksBuffer.forEach(( |
346 |
|
347 |
|
348 |
|
349 | tuple => {
|
350 | const [fn, data] = tuple;
|
351 | fn(data);
|
352 | }));
|
353 | this._animationCallbacksBuffer = [];
|
354 | }));
|
355 | }));
|
356 | }
|
357 | this._animationCallbacksBuffer.push([fn, data]);
|
358 | }
|
359 | |
360 |
|
361 |
|
362 | end() {
|
363 | this._cdRecurDepth--;
|
364 |
|
365 |
|
366 | if (this._cdRecurDepth == 0) {
|
367 | this._zone.runOutsideAngular(( |
368 |
|
369 |
|
370 | () => {
|
371 | this._scheduleCountTask();
|
372 | this.engine.flush(this._microtaskId);
|
373 | }));
|
374 | }
|
375 | if (this.delegate.end) {
|
376 | this.delegate.end();
|
377 | }
|
378 | }
|
379 | |
380 |
|
381 |
|
382 | whenRenderingDone() { return this.engine.whenRenderingDone(); }
|
383 | }
|
384 | AnimationRendererFactory.decorators = [
|
385 | { type: Injectable }
|
386 | ];
|
387 |
|
388 | AnimationRendererFactory.ctorParameters = () => [
|
389 | { type: RendererFactory2 },
|
390 | { type: ɵAnimationEngine },
|
391 | { type: NgZone }
|
392 | ];
|
393 | if (false) {
|
394 | |
395 |
|
396 |
|
397 |
|
398 | AnimationRendererFactory.prototype._currentId;
|
399 | |
400 |
|
401 |
|
402 |
|
403 | AnimationRendererFactory.prototype._microtaskId;
|
404 | |
405 |
|
406 |
|
407 |
|
408 | AnimationRendererFactory.prototype._animationCallbacksBuffer;
|
409 | |
410 |
|
411 |
|
412 |
|
413 | AnimationRendererFactory.prototype._rendererCache;
|
414 | |
415 |
|
416 |
|
417 |
|
418 | AnimationRendererFactory.prototype._cdRecurDepth;
|
419 | |
420 |
|
421 |
|
422 |
|
423 | AnimationRendererFactory.prototype.promise;
|
424 | |
425 |
|
426 |
|
427 |
|
428 | AnimationRendererFactory.prototype.delegate;
|
429 | |
430 |
|
431 |
|
432 |
|
433 | AnimationRendererFactory.prototype.engine;
|
434 | |
435 |
|
436 |
|
437 |
|
438 | AnimationRendererFactory.prototype._zone;
|
439 | }
|
440 | class BaseAnimationRenderer {
|
441 | |
442 |
|
443 |
|
444 |
|
445 |
|
446 | constructor(namespaceId, delegate, engine) {
|
447 | this.namespaceId = namespaceId;
|
448 | this.delegate = delegate;
|
449 | this.engine = engine;
|
450 | this.destroyNode = this.delegate.destroyNode ? ( |
451 |
|
452 |
|
453 |
|
454 | (n) => ( (delegate.destroyNode))(n)) : null;
|
455 | }
|
456 | |
457 |
|
458 |
|
459 | get data() { return this.delegate.data; }
|
460 | |
461 |
|
462 |
|
463 | destroy() {
|
464 | this.engine.destroy(this.namespaceId, this.delegate);
|
465 | this.delegate.destroy();
|
466 | }
|
467 | |
468 |
|
469 |
|
470 |
|
471 |
|
472 | createElement(name, namespace) {
|
473 | return this.delegate.createElement(name, namespace);
|
474 | }
|
475 | |
476 |
|
477 |
|
478 |
|
479 | createComment(value) { return this.delegate.createComment(value); }
|
480 | |
481 |
|
482 |
|
483 |
|
484 | createText(value) { return this.delegate.createText(value); }
|
485 | |
486 |
|
487 |
|
488 |
|
489 |
|
490 | appendChild(parent, newChild) {
|
491 | this.delegate.appendChild(parent, newChild);
|
492 | this.engine.onInsert(this.namespaceId, newChild, parent, false);
|
493 | }
|
494 | |
495 |
|
496 |
|
497 |
|
498 |
|
499 |
|
500 | insertBefore(parent, newChild, refChild) {
|
501 | this.delegate.insertBefore(parent, newChild, refChild);
|
502 | this.engine.onInsert(this.namespaceId, newChild, parent, true);
|
503 | }
|
504 | |
505 |
|
506 |
|
507 |
|
508 |
|
509 |
|
510 | removeChild(parent, oldChild, isHostElement) {
|
511 | this.engine.onRemove(this.namespaceId, oldChild, this.delegate, isHostElement);
|
512 | }
|
513 | |
514 |
|
515 |
|
516 |
|
517 |
|
518 | selectRootElement(selectorOrNode, preserveContent) {
|
519 | return this.delegate.selectRootElement(selectorOrNode, preserveContent);
|
520 | }
|
521 | |
522 |
|
523 |
|
524 |
|
525 | parentNode(node) { return this.delegate.parentNode(node); }
|
526 | |
527 |
|
528 |
|
529 |
|
530 | nextSibling(node) { return this.delegate.nextSibling(node); }
|
531 | |
532 |
|
533 |
|
534 |
|
535 |
|
536 |
|
537 |
|
538 | setAttribute(el, name, value, namespace) {
|
539 | this.delegate.setAttribute(el, name, value, namespace);
|
540 | }
|
541 | |
542 |
|
543 |
|
544 |
|
545 |
|
546 |
|
547 | removeAttribute(el, name, namespace) {
|
548 | this.delegate.removeAttribute(el, name, namespace);
|
549 | }
|
550 | |
551 |
|
552 |
|
553 |
|
554 |
|
555 | addClass(el, name) { this.delegate.addClass(el, name); }
|
556 | |
557 |
|
558 |
|
559 |
|
560 |
|
561 | removeClass(el, name) { this.delegate.removeClass(el, name); }
|
562 | |
563 |
|
564 |
|
565 |
|
566 |
|
567 |
|
568 |
|
569 | setStyle(el, style, value, flags) {
|
570 | this.delegate.setStyle(el, style, value, flags);
|
571 | }
|
572 | |
573 |
|
574 |
|
575 |
|
576 |
|
577 |
|
578 | removeStyle(el, style, flags) {
|
579 | this.delegate.removeStyle(el, style, flags);
|
580 | }
|
581 | |
582 |
|
583 |
|
584 |
|
585 |
|
586 |
|
587 | setProperty(el, name, value) {
|
588 | if (name.charAt(0) == ANIMATION_PREFIX && name == DISABLE_ANIMATIONS_FLAG) {
|
589 | this.disableAnimations(el, !!value);
|
590 | }
|
591 | else {
|
592 | this.delegate.setProperty(el, name, value);
|
593 | }
|
594 | }
|
595 | |
596 |
|
597 |
|
598 |
|
599 |
|
600 | setValue(node, value) { this.delegate.setValue(node, value); }
|
601 | |
602 |
|
603 |
|
604 |
|
605 |
|
606 |
|
607 | listen(target, eventName, callback) {
|
608 | return this.delegate.listen(target, eventName, callback);
|
609 | }
|
610 | |
611 |
|
612 |
|
613 |
|
614 |
|
615 |
|
616 | disableAnimations(element, value) {
|
617 | this.engine.disableAnimations(element, value);
|
618 | }
|
619 | }
|
620 | if (false) {
|
621 |
|
622 | BaseAnimationRenderer.prototype.destroyNode;
|
623 | |
624 |
|
625 |
|
626 |
|
627 | BaseAnimationRenderer.prototype.namespaceId;
|
628 |
|
629 | BaseAnimationRenderer.prototype.delegate;
|
630 |
|
631 | BaseAnimationRenderer.prototype.engine;
|
632 | }
|
633 | class AnimationRenderer extends BaseAnimationRenderer {
|
634 | |
635 |
|
636 |
|
637 |
|
638 |
|
639 |
|
640 | constructor(factory, namespaceId, delegate, engine) {
|
641 | super(namespaceId, delegate, engine);
|
642 | this.factory = factory;
|
643 | this.namespaceId = namespaceId;
|
644 | }
|
645 | |
646 |
|
647 |
|
648 |
|
649 |
|
650 |
|
651 | setProperty(el, name, value) {
|
652 | if (name.charAt(0) == ANIMATION_PREFIX) {
|
653 | if (name.charAt(1) == '.' && name == DISABLE_ANIMATIONS_FLAG) {
|
654 | value = value === undefined ? true : !!value;
|
655 | this.disableAnimations(el, ( (value)));
|
656 | }
|
657 | else {
|
658 | this.engine.process(this.namespaceId, el, name.substr(1), value);
|
659 | }
|
660 | }
|
661 | else {
|
662 | this.delegate.setProperty(el, name, value);
|
663 | }
|
664 | }
|
665 | |
666 |
|
667 |
|
668 |
|
669 |
|
670 |
|
671 | listen(target, eventName, callback) {
|
672 | if (eventName.charAt(0) == ANIMATION_PREFIX) {
|
673 |
|
674 | const element = resolveElementFromTarget(target);
|
675 |
|
676 | let name = eventName.substr(1);
|
677 |
|
678 | let phase = '';
|
679 |
|
680 |
|
681 | if (name.charAt(0) != ANIMATION_PREFIX) {
|
682 | [name, phase] = parseTriggerCallbackName(name);
|
683 | }
|
684 | return this.engine.listen(this.namespaceId, element, name, phase, ( |
685 |
|
686 |
|
687 |
|
688 | event => {
|
689 |
|
690 | const countId = (( (event)))['_data'] || -1;
|
691 | this.factory.scheduleListenerCallback(countId, callback, event);
|
692 | }));
|
693 | }
|
694 | return this.delegate.listen(target, eventName, callback);
|
695 | }
|
696 | }
|
697 | if (false) {
|
698 |
|
699 | AnimationRenderer.prototype.factory;
|
700 | }
|
701 |
|
702 |
|
703 |
|
704 |
|
705 | function resolveElementFromTarget(target) {
|
706 | switch (target) {
|
707 | case 'body':
|
708 | return document.body;
|
709 | case 'document':
|
710 | return document;
|
711 | case 'window':
|
712 | return window;
|
713 | default:
|
714 | return target;
|
715 | }
|
716 | }
|
717 |
|
718 |
|
719 |
|
720 |
|
721 | function parseTriggerCallbackName(triggerName) {
|
722 |
|
723 | const dotIndex = triggerName.indexOf('.');
|
724 |
|
725 | const trigger = triggerName.substring(0, dotIndex);
|
726 |
|
727 | const phase = triggerName.substr(dotIndex + 1);
|
728 | return [trigger, phase];
|
729 | }
|
730 |
|
731 |
|
732 |
|
733 |
|
734 |
|
735 | class InjectableAnimationEngine extends ɵAnimationEngine {
|
736 | |
737 |
|
738 |
|
739 |
|
740 |
|
741 | constructor(doc, driver, normalizer) {
|
742 | super(doc.body, driver, normalizer);
|
743 | }
|
744 | }
|
745 | InjectableAnimationEngine.decorators = [
|
746 | { type: Injectable }
|
747 | ];
|
748 |
|
749 | InjectableAnimationEngine.ctorParameters = () => [
|
750 | { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
|
751 | { type: AnimationDriver },
|
752 | { type: ɵAnimationStyleNormalizer }
|
753 | ];
|
754 |
|
755 |
|
756 |
|
757 | function instantiateSupportedAnimationDriver() {
|
758 | return ɵsupportsWebAnimations() ? new ɵWebAnimationsDriver() : new ɵCssKeyframesDriver();
|
759 | }
|
760 |
|
761 |
|
762 |
|
763 | function instantiateDefaultStyleNormalizer() {
|
764 | return new ɵWebAnimationsStyleNormalizer();
|
765 | }
|
766 |
|
767 |
|
768 |
|
769 |
|
770 |
|
771 |
|
772 | function instantiateRendererFactory(renderer, engine, zone) {
|
773 | return new AnimationRendererFactory(renderer, engine, zone);
|
774 | }
|
775 |
|
776 |
|
777 |
|
778 |
|
779 | const ANIMATION_MODULE_TYPE = new InjectionToken('AnimationModuleType');
|
780 |
|
781 | const SHARED_ANIMATION_PROVIDERS = [
|
782 | { provide: AnimationBuilder, useClass: BrowserAnimationBuilder },
|
783 | { provide: ɵAnimationStyleNormalizer, useFactory: instantiateDefaultStyleNormalizer },
|
784 | { provide: ɵAnimationEngine, useClass: InjectableAnimationEngine }, {
|
785 | provide: RendererFactory2,
|
786 | useFactory: instantiateRendererFactory,
|
787 | deps: [ɵDomRendererFactory2, ɵAnimationEngine, NgZone]
|
788 | }
|
789 | ];
|
790 |
|
791 |
|
792 |
|
793 |
|
794 |
|
795 | const BROWSER_ANIMATIONS_PROVIDERS = [
|
796 | { provide: AnimationDriver, useFactory: instantiateSupportedAnimationDriver },
|
797 | { provide: ANIMATION_MODULE_TYPE, useValue: 'BrowserAnimations' }, ...SHARED_ANIMATION_PROVIDERS
|
798 | ];
|
799 |
|
800 |
|
801 |
|
802 |
|
803 |
|
804 | const BROWSER_NOOP_ANIMATIONS_PROVIDERS = [
|
805 | { provide: AnimationDriver, useClass: ɵNoopAnimationDriver },
|
806 | { provide: ANIMATION_MODULE_TYPE, useValue: 'NoopAnimations' }, ...SHARED_ANIMATION_PROVIDERS
|
807 | ];
|
808 |
|
809 |
|
810 |
|
811 |
|
812 |
|
813 |
|
814 |
|
815 |
|
816 |
|
817 |
|
818 | class BrowserAnimationsModule {
|
819 | }
|
820 | BrowserAnimationsModule.decorators = [
|
821 | { type: NgModule, args: [{
|
822 | exports: [BrowserModule],
|
823 | providers: BROWSER_ANIMATIONS_PROVIDERS,
|
824 | },] }
|
825 | ];
|
826 |
|
827 |
|
828 |
|
829 |
|
830 | class NoopAnimationsModule {
|
831 | }
|
832 | NoopAnimationsModule.decorators = [
|
833 | { type: NgModule, args: [{
|
834 | exports: [BrowserModule],
|
835 | providers: BROWSER_NOOP_ANIMATIONS_PROVIDERS,
|
836 | },] }
|
837 | ];
|
838 |
|
839 |
|
840 |
|
841 |
|
842 |
|
843 |
|
844 |
|
845 |
|
846 |
|
847 |
|
848 |
|
849 |
|
850 |
|
851 |
|
852 |
|
853 |
|
854 |
|
855 |
|
856 |
|
857 |
|
858 |
|
859 |
|
860 |
|
861 |
|
862 |
|
863 | export { BaseAnimationRenderer as ɵangular_packages_platform_browser_animations_animations_f, BROWSER_ANIMATIONS_PROVIDERS as ɵangular_packages_platform_browser_animations_animations_d, BROWSER_NOOP_ANIMATIONS_PROVIDERS as ɵangular_packages_platform_browser_animations_animations_e, instantiateDefaultStyleNormalizer as ɵangular_packages_platform_browser_animations_animations_b, instantiateRendererFactory as ɵangular_packages_platform_browser_animations_animations_c, instantiateSupportedAnimationDriver as ɵangular_packages_platform_browser_animations_animations_a, BrowserAnimationsModule, NoopAnimationsModule, ANIMATION_MODULE_TYPE, BrowserAnimationBuilder as ɵBrowserAnimationBuilder, BrowserAnimationFactory as ɵBrowserAnimationFactory, AnimationRenderer as ɵAnimationRenderer, AnimationRendererFactory as ɵAnimationRendererFactory, InjectableAnimationEngine as ɵInjectableAnimationEngine };
|
864 |
|