1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 | import { getUrlScheme, syntaxError, Identifiers, JitCompiler, ProviderMeta, CompileReflector, ResourceLoader, JitSummaryResolver, SummaryResolver, Lexer, Parser, HtmlParser, I18NHtmlParser, CompilerConfig, TemplateParser, ElementSchemaRegistry, JitEvaluator, DirectiveNormalizer, UrlResolver, CompileMetadataResolver, NgModuleResolver, DirectiveResolver, PipeResolver, StaticSymbolCache, StyleCompiler, ViewCompiler, NgModuleCompiler, DomElementSchemaRegistry } from '@angular/compiler';
|
8 | import { ɵReflectionCapabilities, ɵstringify, ANALYZE_FOR_ENTRY_COMPONENTS, ElementRef, NgModuleRef, ViewContainerRef, ChangeDetectorRef, Renderer2, QueryList, TemplateRef, ɵCodegenComponentFactoryResolver, ComponentFactoryResolver, ComponentFactory, ComponentRef, NgModuleFactory, ɵcmf, ɵmod, ɵmpd, ɵregisterModuleFactory, Injector, ViewEncapsulation, ChangeDetectionStrategy, SecurityContext, LOCALE_ID, TRANSLATIONS_FORMAT, ɵinlineInterpolate, ɵinterpolate, ɵEMPTY_ARRAY, ɵEMPTY_MAP, Renderer, ɵvid, ɵeld, ɵand, ɵted, ɵdid, ɵprd, ɵqud, ɵpad, ɵpod, ɵppd, ɵpid, ɵnov, ɵncd, ɵunv, ɵcrt, ɵccf, InjectionToken, PACKAGE_ROOT_URL, Compiler, ɵConsole, MissingTranslationStrategy, Optional, Inject, TRANSLATIONS, isDevMode, createPlatformFactory, platformCore, COMPILER_OPTIONS, CompilerFactory, Injectable, PLATFORM_ID, ɵglobal, Version } from '@angular/core';
|
9 | import { ɵPLATFORM_BROWSER_ID } from '@angular/common';
|
10 | import { ɵINTERNAL_BROWSER_PLATFORM_PROVIDERS } from '@angular/platform-browser';
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 | const MODULE_SUFFIX = '';
|
18 |
|
19 | const builtinExternalReferences = createBuiltinExternalReferencesMap();
|
20 | class JitReflector {
|
21 | constructor() {
|
22 | this.reflectionCapabilities = new ɵReflectionCapabilities();
|
23 | }
|
24 | |
25 |
|
26 |
|
27 |
|
28 |
|
29 | componentModuleUrl(type, cmpMetadata) {
|
30 |
|
31 | const moduleId = cmpMetadata.moduleId;
|
32 | if (typeof moduleId === 'string') {
|
33 |
|
34 | const scheme = getUrlScheme(moduleId);
|
35 | return scheme ? moduleId : `package:${moduleId}${MODULE_SUFFIX}`;
|
36 | }
|
37 | else if (moduleId !== null && moduleId !== void 0) {
|
38 | throw syntaxError(`moduleId should be a string in "${ɵstringify(type)}". See https://goo.gl/wIDDiL for more information.\n` +
|
39 | `If you're using Webpack you should inline the template and the styles, see https://goo.gl/X2J8zc.`);
|
40 | }
|
41 | return `./${ɵstringify(type)}`;
|
42 | }
|
43 | |
44 |
|
45 |
|
46 |
|
47 | parameters(typeOrFunc) {
|
48 | return this.reflectionCapabilities.parameters(typeOrFunc);
|
49 | }
|
50 | |
51 |
|
52 |
|
53 |
|
54 | tryAnnotations(typeOrFunc) { return this.annotations(typeOrFunc); }
|
55 | |
56 |
|
57 |
|
58 |
|
59 | annotations(typeOrFunc) {
|
60 | return this.reflectionCapabilities.annotations(typeOrFunc);
|
61 | }
|
62 | |
63 |
|
64 |
|
65 |
|
66 | shallowAnnotations(typeOrFunc) {
|
67 | throw new Error('Not supported in JIT mode');
|
68 | }
|
69 | |
70 |
|
71 |
|
72 |
|
73 | propMetadata(typeOrFunc) {
|
74 | return this.reflectionCapabilities.propMetadata(typeOrFunc);
|
75 | }
|
76 | |
77 |
|
78 |
|
79 |
|
80 |
|
81 | hasLifecycleHook(type, lcProperty) {
|
82 | return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);
|
83 | }
|
84 | |
85 |
|
86 |
|
87 |
|
88 | guards(type) { return this.reflectionCapabilities.guards(type); }
|
89 | |
90 |
|
91 |
|
92 |
|
93 | resolveExternalReference(ref) {
|
94 | return builtinExternalReferences.get(ref) || ref.runtime;
|
95 | }
|
96 | }
|
97 | if (false) {
|
98 | |
99 |
|
100 |
|
101 |
|
102 | JitReflector.prototype.reflectionCapabilities;
|
103 | }
|
104 |
|
105 |
|
106 |
|
107 | function createBuiltinExternalReferencesMap() {
|
108 |
|
109 | const map = new Map();
|
110 | map.set(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS, ANALYZE_FOR_ENTRY_COMPONENTS);
|
111 | map.set(Identifiers.ElementRef, ElementRef);
|
112 | map.set(Identifiers.NgModuleRef, NgModuleRef);
|
113 | map.set(Identifiers.ViewContainerRef, ViewContainerRef);
|
114 | map.set(Identifiers.ChangeDetectorRef, ChangeDetectorRef);
|
115 | map.set(Identifiers.Renderer2, Renderer2);
|
116 | map.set(Identifiers.QueryList, QueryList);
|
117 | map.set(Identifiers.TemplateRef, TemplateRef);
|
118 | map.set(Identifiers.CodegenComponentFactoryResolver, ɵCodegenComponentFactoryResolver);
|
119 | map.set(Identifiers.ComponentFactoryResolver, ComponentFactoryResolver);
|
120 | map.set(Identifiers.ComponentFactory, ComponentFactory);
|
121 | map.set(Identifiers.ComponentRef, ComponentRef);
|
122 | map.set(Identifiers.NgModuleFactory, NgModuleFactory);
|
123 | map.set(Identifiers.createModuleFactory, ɵcmf);
|
124 | map.set(Identifiers.moduleDef, ɵmod);
|
125 | map.set(Identifiers.moduleProviderDef, ɵmpd);
|
126 | map.set(Identifiers.RegisterModuleFactoryFn, ɵregisterModuleFactory);
|
127 | map.set(Identifiers.Injector, Injector);
|
128 | map.set(Identifiers.ViewEncapsulation, ViewEncapsulation);
|
129 | map.set(Identifiers.ChangeDetectionStrategy, ChangeDetectionStrategy);
|
130 | map.set(Identifiers.SecurityContext, SecurityContext);
|
131 | map.set(Identifiers.LOCALE_ID, LOCALE_ID);
|
132 | map.set(Identifiers.TRANSLATIONS_FORMAT, TRANSLATIONS_FORMAT);
|
133 | map.set(Identifiers.inlineInterpolate, ɵinlineInterpolate);
|
134 | map.set(Identifiers.interpolate, ɵinterpolate);
|
135 | map.set(Identifiers.EMPTY_ARRAY, ɵEMPTY_ARRAY);
|
136 | map.set(Identifiers.EMPTY_MAP, ɵEMPTY_MAP);
|
137 | map.set(Identifiers.Renderer, Renderer);
|
138 | map.set(Identifiers.viewDef, ɵvid);
|
139 | map.set(Identifiers.elementDef, ɵeld);
|
140 | map.set(Identifiers.anchorDef, ɵand);
|
141 | map.set(Identifiers.textDef, ɵted);
|
142 | map.set(Identifiers.directiveDef, ɵdid);
|
143 | map.set(Identifiers.providerDef, ɵprd);
|
144 | map.set(Identifiers.queryDef, ɵqud);
|
145 | map.set(Identifiers.pureArrayDef, ɵpad);
|
146 | map.set(Identifiers.pureObjectDef, ɵpod);
|
147 | map.set(Identifiers.purePipeDef, ɵppd);
|
148 | map.set(Identifiers.pipeDef, ɵpid);
|
149 | map.set(Identifiers.nodeValue, ɵnov);
|
150 | map.set(Identifiers.ngContentDef, ɵncd);
|
151 | map.set(Identifiers.unwrapValue, ɵunv);
|
152 | map.set(Identifiers.createRendererType2, ɵcrt);
|
153 | map.set(Identifiers.createComponentFactory, ɵccf);
|
154 | return map;
|
155 | }
|
156 |
|
157 |
|
158 |
|
159 |
|
160 |
|
161 |
|
162 | const ERROR_COLLECTOR_TOKEN = new InjectionToken('ErrorCollector');
|
163 |
|
164 |
|
165 |
|
166 |
|
167 | const DEFAULT_PACKAGE_URL_PROVIDER = {
|
168 | provide: PACKAGE_ROOT_URL,
|
169 | useValue: '/'
|
170 | };
|
171 |
|
172 | const _NO_RESOURCE_LOADER = {
|
173 | |
174 |
|
175 |
|
176 |
|
177 | get(url) {
|
178 | throw new Error(`No ResourceLoader implementation has been provided. Can't read the url "${url}"`);
|
179 | }
|
180 | };
|
181 |
|
182 | const baseHtmlParser = new InjectionToken('HtmlParser');
|
183 | class CompilerImpl {
|
184 | |
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 |
|
191 |
|
192 |
|
193 |
|
194 |
|
195 |
|
196 |
|
197 | constructor(injector, _metadataResolver, templateParser, styleCompiler, viewCompiler, ngModuleCompiler, summaryResolver, compileReflector, jitEvaluator, compilerConfig, console) {
|
198 | this._metadataResolver = _metadataResolver;
|
199 | this._delegate = new JitCompiler(_metadataResolver, templateParser, styleCompiler, viewCompiler, ngModuleCompiler, summaryResolver, compileReflector, jitEvaluator, compilerConfig, console, this.getExtraNgModuleProviders.bind(this));
|
200 | this.injector = injector;
|
201 | }
|
202 | |
203 |
|
204 |
|
205 |
|
206 | getExtraNgModuleProviders() {
|
207 | return [this._metadataResolver.getProviderMetadata(new ProviderMeta(Compiler, { useValue: this }))];
|
208 | }
|
209 | |
210 |
|
211 |
|
212 |
|
213 |
|
214 | compileModuleSync(moduleType) {
|
215 | return ( (this._delegate.compileModuleSync(moduleType)));
|
216 | }
|
217 | |
218 |
|
219 |
|
220 |
|
221 |
|
222 | compileModuleAsync(moduleType) {
|
223 | return ( (this._delegate.compileModuleAsync(moduleType)));
|
224 | }
|
225 | |
226 |
|
227 |
|
228 |
|
229 |
|
230 | compileModuleAndAllComponentsSync(moduleType) {
|
231 |
|
232 | const result = this._delegate.compileModuleAndAllComponentsSync(moduleType);
|
233 | return {
|
234 | ngModuleFactory: ( (result.ngModuleFactory)),
|
235 | componentFactories: ( (result.componentFactories)),
|
236 | };
|
237 | }
|
238 | |
239 |
|
240 |
|
241 |
|
242 |
|
243 | compileModuleAndAllComponentsAsync(moduleType) {
|
244 | return this._delegate.compileModuleAndAllComponentsAsync(moduleType)
|
245 | .then(( |
246 |
|
247 |
|
248 |
|
249 | (result) => ({
|
250 | ngModuleFactory: ( (result.ngModuleFactory)),
|
251 | componentFactories: ( (result.componentFactories)),
|
252 | })));
|
253 | }
|
254 | |
255 |
|
256 |
|
257 |
|
258 | loadAotSummaries(summaries) { this._delegate.loadAotSummaries(summaries); }
|
259 | |
260 |
|
261 |
|
262 |
|
263 | hasAotSummary(ref) { return this._delegate.hasAotSummary(ref); }
|
264 | |
265 |
|
266 |
|
267 |
|
268 |
|
269 | getComponentFactory(component) {
|
270 | return ( (this._delegate.getComponentFactory(component)));
|
271 | }
|
272 | |
273 |
|
274 |
|
275 | clearCache() { this._delegate.clearCache(); }
|
276 | |
277 |
|
278 |
|
279 |
|
280 | clearCacheFor(type) { this._delegate.clearCacheFor(type); }
|
281 | |
282 |
|
283 |
|
284 |
|
285 | getModuleId(moduleType) {
|
286 |
|
287 | const meta = this._metadataResolver.getNgModuleMetadata(moduleType);
|
288 | return meta && meta.id || undefined;
|
289 | }
|
290 | }
|
291 | if (false) {
|
292 | |
293 |
|
294 |
|
295 |
|
296 | CompilerImpl.prototype._delegate;
|
297 |
|
298 | CompilerImpl.prototype.injector;
|
299 | |
300 |
|
301 |
|
302 |
|
303 | CompilerImpl.prototype._metadataResolver;
|
304 | }
|
305 |
|
306 |
|
307 |
|
308 |
|
309 |
|
310 | const COMPILER_PROVIDERS = ( ([
|
311 | { provide: CompileReflector, useValue: new JitReflector() },
|
312 | { provide: ResourceLoader, useValue: _NO_RESOURCE_LOADER },
|
313 | { provide: JitSummaryResolver, deps: [] },
|
314 | { provide: SummaryResolver, useExisting: JitSummaryResolver },
|
315 | { provide: ɵConsole, deps: [] },
|
316 | { provide: Lexer, deps: [] },
|
317 | { provide: Parser, deps: [Lexer] },
|
318 | {
|
319 | provide: baseHtmlParser,
|
320 | useClass: HtmlParser,
|
321 | deps: [],
|
322 | },
|
323 | {
|
324 | provide: I18NHtmlParser,
|
325 | useFactory: ( |
326 |
|
327 |
|
328 |
|
329 |
|
330 |
|
331 |
|
332 |
|
333 | (parser, translations, format, config, console) => {
|
334 | translations = translations || '';
|
335 |
|
336 | const missingTranslation = translations ? ( (config.missingTranslation)) : MissingTranslationStrategy.Ignore;
|
337 | return new I18NHtmlParser(parser, translations, format, missingTranslation, console);
|
338 | }),
|
339 | deps: [
|
340 | baseHtmlParser,
|
341 | [new Optional(), new Inject(TRANSLATIONS)],
|
342 | [new Optional(), new Inject(TRANSLATIONS_FORMAT)],
|
343 | [CompilerConfig],
|
344 | [ɵConsole],
|
345 | ]
|
346 | },
|
347 | {
|
348 | provide: HtmlParser,
|
349 | useExisting: I18NHtmlParser,
|
350 | },
|
351 | {
|
352 | provide: TemplateParser, deps: [CompilerConfig, CompileReflector,
|
353 | Parser, ElementSchemaRegistry,
|
354 | I18NHtmlParser, ɵConsole]
|
355 | },
|
356 | { provide: JitEvaluator, useClass: JitEvaluator, deps: [] },
|
357 | { provide: DirectiveNormalizer, deps: [ResourceLoader, UrlResolver, HtmlParser, CompilerConfig] },
|
358 | { provide: CompileMetadataResolver, deps: [CompilerConfig, HtmlParser, NgModuleResolver,
|
359 | DirectiveResolver, PipeResolver,
|
360 | SummaryResolver,
|
361 | ElementSchemaRegistry,
|
362 | DirectiveNormalizer, ɵConsole,
|
363 | [Optional, StaticSymbolCache],
|
364 | CompileReflector,
|
365 | [Optional, ERROR_COLLECTOR_TOKEN]] },
|
366 | DEFAULT_PACKAGE_URL_PROVIDER,
|
367 | { provide: StyleCompiler, deps: [UrlResolver] },
|
368 | { provide: ViewCompiler, deps: [CompileReflector] },
|
369 | { provide: NgModuleCompiler, deps: [CompileReflector] },
|
370 | { provide: CompilerConfig, useValue: new CompilerConfig() },
|
371 | { provide: Compiler, useClass: CompilerImpl, deps: [Injector, CompileMetadataResolver,
|
372 | TemplateParser, StyleCompiler,
|
373 | ViewCompiler, NgModuleCompiler,
|
374 | SummaryResolver, CompileReflector, JitEvaluator, CompilerConfig,
|
375 | ɵConsole] },
|
376 | { provide: DomElementSchemaRegistry, deps: [] },
|
377 | { provide: ElementSchemaRegistry, useExisting: DomElementSchemaRegistry },
|
378 | { provide: UrlResolver, deps: [PACKAGE_ROOT_URL] },
|
379 | { provide: DirectiveResolver, deps: [CompileReflector] },
|
380 | { provide: PipeResolver, deps: [CompileReflector] },
|
381 | { provide: NgModuleResolver, deps: [CompileReflector] },
|
382 | ]));
|
383 |
|
384 |
|
385 |
|
386 | class JitCompilerFactory {
|
387 |
|
388 | |
389 |
|
390 |
|
391 | constructor(defaultOptions) {
|
392 |
|
393 | const compilerOptions = {
|
394 | useJit: true,
|
395 | defaultEncapsulation: ViewEncapsulation.Emulated,
|
396 | missingTranslation: MissingTranslationStrategy.Warning,
|
397 | };
|
398 | this._defaultOptions = [compilerOptions, ...defaultOptions];
|
399 | }
|
400 | |
401 |
|
402 |
|
403 |
|
404 | createCompiler(options = []) {
|
405 |
|
406 | const opts = _mergeOptions(this._defaultOptions.concat(options));
|
407 |
|
408 | const injector = Injector.create([
|
409 | COMPILER_PROVIDERS, {
|
410 | provide: CompilerConfig,
|
411 | useFactory: ( |
412 |
|
413 |
|
414 | () => {
|
415 | return new CompilerConfig({
|
416 |
|
417 |
|
418 | useJit: opts.useJit,
|
419 | jitDevMode: isDevMode(),
|
420 |
|
421 |
|
422 | defaultEncapsulation: opts.defaultEncapsulation,
|
423 | missingTranslation: opts.missingTranslation,
|
424 | preserveWhitespaces: opts.preserveWhitespaces,
|
425 | });
|
426 | }),
|
427 | deps: []
|
428 | },
|
429 | ( (opts.providers))
|
430 | ]);
|
431 | return injector.get(Compiler);
|
432 | }
|
433 | }
|
434 | if (false) {
|
435 | |
436 |
|
437 |
|
438 |
|
439 | JitCompilerFactory.prototype._defaultOptions;
|
440 | }
|
441 |
|
442 |
|
443 |
|
444 |
|
445 | function _mergeOptions(optionsArr) {
|
446 | return {
|
447 | useJit: _lastDefined(optionsArr.map(( |
448 |
|
449 |
|
450 |
|
451 | options => options.useJit))),
|
452 | defaultEncapsulation: _lastDefined(optionsArr.map(( |
453 |
|
454 |
|
455 |
|
456 | options => options.defaultEncapsulation))),
|
457 | providers: _mergeArrays(optionsArr.map(( |
458 |
|
459 |
|
460 |
|
461 | options => ( (options.providers))))),
|
462 | missingTranslation: _lastDefined(optionsArr.map(( |
463 |
|
464 |
|
465 |
|
466 | options => options.missingTranslation))),
|
467 | preserveWhitespaces: _lastDefined(optionsArr.map(( |
468 |
|
469 |
|
470 |
|
471 | options => options.preserveWhitespaces))),
|
472 | };
|
473 | }
|
474 |
|
475 |
|
476 |
|
477 |
|
478 |
|
479 | function _lastDefined(args) {
|
480 | for (let i = args.length - 1; i >= 0; i--) {
|
481 | if (args[i] !== undefined) {
|
482 | return args[i];
|
483 | }
|
484 | }
|
485 | return undefined;
|
486 | }
|
487 |
|
488 |
|
489 |
|
490 |
|
491 | function _mergeArrays(parts) {
|
492 |
|
493 | const result = [];
|
494 | parts.forEach(( |
495 |
|
496 |
|
497 |
|
498 | (part) => part && result.push(...part)));
|
499 | return result;
|
500 | }
|
501 |
|
502 |
|
503 |
|
504 |
|
505 |
|
506 | const ɵ0 = {};
|
507 |
|
508 |
|
509 |
|
510 |
|
511 |
|
512 |
|
513 | const platformCoreDynamic = createPlatformFactory(platformCore, 'coreDynamic', [
|
514 | { provide: COMPILER_OPTIONS, useValue: ɵ0, multi: true },
|
515 | { provide: CompilerFactory, useClass: JitCompilerFactory, deps: [COMPILER_OPTIONS] },
|
516 | ]);
|
517 |
|
518 |
|
519 |
|
520 |
|
521 |
|
522 | class ResourceLoaderImpl extends ResourceLoader {
|
523 | |
524 |
|
525 |
|
526 |
|
527 | get(url) {
|
528 |
|
529 | let resolve;
|
530 |
|
531 | let reject;
|
532 |
|
533 | const promise = new Promise(( |
534 |
|
535 |
|
536 |
|
537 |
|
538 | (res, rej) => {
|
539 | resolve = res;
|
540 | reject = rej;
|
541 | }));
|
542 |
|
543 | const xhr = new XMLHttpRequest();
|
544 | xhr.open('GET', url, true);
|
545 | xhr.responseType = 'text';
|
546 | xhr.onload = ( |
547 |
|
548 |
|
549 | function () {
|
550 |
|
551 |
|
552 |
|
553 |
|
554 | const response = xhr.response || xhr.responseText;
|
555 |
|
556 |
|
557 | let status = xhr.status === 1223 ? 204 : xhr.status;
|
558 |
|
559 |
|
560 |
|
561 | if (status === 0) {
|
562 | status = response ? 200 : 0;
|
563 | }
|
564 | if (200 <= status && status <= 300) {
|
565 | resolve(response);
|
566 | }
|
567 | else {
|
568 | reject(`Failed to load ${url}`);
|
569 | }
|
570 | });
|
571 | xhr.onerror = ( |
572 |
|
573 |
|
574 | function () { reject(`Failed to load ${url}`); });
|
575 | xhr.send();
|
576 | return promise;
|
577 | }
|
578 | }
|
579 | ResourceLoaderImpl.decorators = [
|
580 | { type: Injectable }
|
581 | ];
|
582 |
|
583 |
|
584 |
|
585 |
|
586 |
|
587 | const ɵ0$1 = { providers: [{ provide: ResourceLoader, useClass: ResourceLoaderImpl, deps: [] }] }, ɵ1 = ɵPLATFORM_BROWSER_ID;
|
588 |
|
589 |
|
590 |
|
591 |
|
592 | const INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS = [
|
593 | ɵINTERNAL_BROWSER_PLATFORM_PROVIDERS,
|
594 | {
|
595 | provide: COMPILER_OPTIONS,
|
596 | useValue: ɵ0$1,
|
597 | multi: true
|
598 | },
|
599 | { provide: PLATFORM_ID, useValue: ɵ1 },
|
600 | ];
|
601 |
|
602 |
|
603 |
|
604 |
|
605 |
|
606 |
|
607 |
|
608 |
|
609 |
|
610 |
|
611 |
|
612 |
|
613 |
|
614 |
|
615 | class CachedResourceLoader extends ResourceLoader {
|
616 | constructor() {
|
617 | super();
|
618 | this._cache = (( (ɵglobal))).$templateCache;
|
619 | if (this._cache == null) {
|
620 | throw new Error('CachedResourceLoader: Template cache was not found in $templateCache.');
|
621 | }
|
622 | }
|
623 | |
624 |
|
625 |
|
626 |
|
627 | get(url) {
|
628 | if (this._cache.hasOwnProperty(url)) {
|
629 | return Promise.resolve(this._cache[url]);
|
630 | }
|
631 | else {
|
632 | return ( (Promise.reject('CachedResourceLoader: Did not find cached template for ' + url)));
|
633 | }
|
634 | }
|
635 | }
|
636 | if (false) {
|
637 | |
638 |
|
639 |
|
640 |
|
641 | CachedResourceLoader.prototype._cache;
|
642 | }
|
643 |
|
644 |
|
645 |
|
646 |
|
647 |
|
648 |
|
649 |
|
650 |
|
651 |
|
652 |
|
653 |
|
654 |
|
655 |
|
656 |
|
657 | const VERSION = new Version('8.2.9');
|
658 |
|
659 |
|
660 |
|
661 |
|
662 |
|
663 |
|
664 |
|
665 |
|
666 |
|
667 | const RESOURCE_CACHE_PROVIDER = [{ provide: ResourceLoader, useClass: CachedResourceLoader, deps: [] }];
|
668 |
|
669 |
|
670 |
|
671 |
|
672 | const platformBrowserDynamic = createPlatformFactory(platformCoreDynamic, 'browserDynamic', INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS);
|
673 |
|
674 |
|
675 |
|
676 |
|
677 |
|
678 |
|
679 |
|
680 |
|
681 |
|
682 |
|
683 |
|
684 |
|
685 |
|
686 |
|
687 |
|
688 | export { CachedResourceLoader as ɵangular_packages_platform_browser_dynamic_platform_browser_dynamic_a, VERSION, JitCompilerFactory, RESOURCE_CACHE_PROVIDER, platformBrowserDynamic, CompilerImpl as ɵCompilerImpl, platformCoreDynamic as ɵplatformCoreDynamic, INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS as ɵINTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS, ResourceLoaderImpl as ɵResourceLoaderImpl };
|
689 |
|