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