1292 lines
40 KiB
JavaScript
1292 lines
40 KiB
JavaScript
import {
|
|
DomEventsPlugin,
|
|
DomRendererFactory2,
|
|
EVENT_MANAGER_PLUGINS,
|
|
EventManager,
|
|
EventManagerPlugin,
|
|
SharedStylesHost
|
|
} from "./chunk-RDTKHKTF.js";
|
|
import {
|
|
withHttpTransferCache
|
|
} from "./chunk-ZKUNZJKW.js";
|
|
import {
|
|
CommonModule,
|
|
DomAdapter,
|
|
PLATFORM_BROWSER_ID,
|
|
getDOM,
|
|
setRootDomAdapter
|
|
} from "./chunk-PSDIAYZ2.js";
|
|
import {
|
|
XhrFactory,
|
|
parseCookieValue
|
|
} from "./chunk-6UNWJBON.js";
|
|
import {
|
|
ApplicationModule,
|
|
ApplicationRef,
|
|
Console,
|
|
DOCUMENT,
|
|
ENVIRONMENT_INITIALIZER,
|
|
ErrorHandler,
|
|
INJECTOR_SCOPE,
|
|
IS_ENABLED_BLOCKING_INITIAL_NAVIGATION,
|
|
Inject,
|
|
Injectable,
|
|
InjectionToken,
|
|
Injector,
|
|
NgModule,
|
|
NgZone,
|
|
Optional,
|
|
PLATFORM_ID,
|
|
PLATFORM_INITIALIZER,
|
|
RendererFactory2,
|
|
RuntimeError,
|
|
SecurityContext,
|
|
TESTABILITY,
|
|
TESTABILITY_GETTER,
|
|
Testability,
|
|
TestabilityRegistry,
|
|
Version,
|
|
XSS_SECURITY_URL,
|
|
ZONELESS_ENABLED,
|
|
_global,
|
|
_sanitizeHtml,
|
|
_sanitizeUrl,
|
|
allowSanitizationBypassAndThrow,
|
|
bypassSanitizationTrustHtml,
|
|
bypassSanitizationTrustResourceUrl,
|
|
bypassSanitizationTrustScript,
|
|
bypassSanitizationTrustStyle,
|
|
bypassSanitizationTrustUrl,
|
|
createPlatformFactory,
|
|
formatRuntimeError,
|
|
forwardRef,
|
|
inject,
|
|
internalCreateApplication,
|
|
makeEnvironmentProviders,
|
|
platformCore,
|
|
setClassMetadata,
|
|
setDocument,
|
|
unwrapSafeValue,
|
|
withDomHydration,
|
|
withEventReplay,
|
|
withI18nSupport,
|
|
withIncrementalHydration,
|
|
ɵɵdefineInjectable,
|
|
ɵɵdefineInjector,
|
|
ɵɵdefineNgModule,
|
|
ɵɵinject
|
|
} from "./chunk-COCNRMG2.js";
|
|
import {
|
|
__spreadValues
|
|
} from "./chunk-WDMUDEB6.js";
|
|
|
|
// node_modules/@angular/platform-browser/fesm2022/browser.mjs
|
|
var BrowserDomAdapter = class _BrowserDomAdapter extends DomAdapter {
|
|
supportsDOMEvents = true;
|
|
static makeCurrent() {
|
|
setRootDomAdapter(new _BrowserDomAdapter());
|
|
}
|
|
onAndCancel(el, evt, listener, options) {
|
|
el.addEventListener(evt, listener, options);
|
|
return () => {
|
|
el.removeEventListener(evt, listener, options);
|
|
};
|
|
}
|
|
dispatchEvent(el, evt) {
|
|
el.dispatchEvent(evt);
|
|
}
|
|
remove(node) {
|
|
node.remove();
|
|
}
|
|
createElement(tagName, doc) {
|
|
doc = doc || this.getDefaultDocument();
|
|
return doc.createElement(tagName);
|
|
}
|
|
createHtmlDocument() {
|
|
return document.implementation.createHTMLDocument("fakeTitle");
|
|
}
|
|
getDefaultDocument() {
|
|
return document;
|
|
}
|
|
isElementNode(node) {
|
|
return node.nodeType === Node.ELEMENT_NODE;
|
|
}
|
|
isShadowRoot(node) {
|
|
return node instanceof DocumentFragment;
|
|
}
|
|
/** @deprecated No longer being used in Ivy code. To be removed in version 14. */
|
|
getGlobalEventTarget(doc, target) {
|
|
if (target === "window") {
|
|
return window;
|
|
}
|
|
if (target === "document") {
|
|
return doc;
|
|
}
|
|
if (target === "body") {
|
|
return doc.body;
|
|
}
|
|
return null;
|
|
}
|
|
getBaseHref(doc) {
|
|
const href = getBaseElementHref();
|
|
return href == null ? null : relativePath(href);
|
|
}
|
|
resetBaseElement() {
|
|
baseElement = null;
|
|
}
|
|
getUserAgent() {
|
|
return window.navigator.userAgent;
|
|
}
|
|
getCookie(name) {
|
|
return parseCookieValue(document.cookie, name);
|
|
}
|
|
};
|
|
var baseElement = null;
|
|
function getBaseElementHref() {
|
|
baseElement = baseElement || document.head.querySelector("base");
|
|
return baseElement ? baseElement.getAttribute("href") : null;
|
|
}
|
|
function relativePath(url) {
|
|
return new URL(url, document.baseURI).pathname;
|
|
}
|
|
var BrowserGetTestability = class {
|
|
addToWindow(registry) {
|
|
_global["getAngularTestability"] = (elem, findInAncestors = true) => {
|
|
const testability = registry.findTestabilityInTree(elem, findInAncestors);
|
|
if (testability == null) {
|
|
throw new RuntimeError(5103, (typeof ngDevMode === "undefined" || ngDevMode) && "Could not find testability for element.");
|
|
}
|
|
return testability;
|
|
};
|
|
_global["getAllAngularTestabilities"] = () => registry.getAllTestabilities();
|
|
_global["getAllAngularRootElements"] = () => registry.getAllRootElements();
|
|
const whenAllStable = (callback) => {
|
|
const testabilities = _global["getAllAngularTestabilities"]();
|
|
let count = testabilities.length;
|
|
const decrement = function() {
|
|
count--;
|
|
if (count == 0) {
|
|
callback();
|
|
}
|
|
};
|
|
testabilities.forEach((testability) => {
|
|
testability.whenStable(decrement);
|
|
});
|
|
};
|
|
if (!_global["frameworkStabilizers"]) {
|
|
_global["frameworkStabilizers"] = [];
|
|
}
|
|
_global["frameworkStabilizers"].push(whenAllStable);
|
|
}
|
|
findTestabilityInTree(registry, elem, findInAncestors) {
|
|
if (elem == null) {
|
|
return null;
|
|
}
|
|
const t = registry.getTestability(elem);
|
|
if (t != null) {
|
|
return t;
|
|
} else if (!findInAncestors) {
|
|
return null;
|
|
}
|
|
if (getDOM().isShadowRoot(elem)) {
|
|
return this.findTestabilityInTree(registry, elem.host, true);
|
|
}
|
|
return this.findTestabilityInTree(registry, elem.parentElement, true);
|
|
}
|
|
};
|
|
var BrowserXhr = class _BrowserXhr {
|
|
build() {
|
|
return new XMLHttpRequest();
|
|
}
|
|
static ɵfac = function BrowserXhr_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _BrowserXhr)();
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _BrowserXhr,
|
|
factory: _BrowserXhr.ɵfac
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserXhr, [{
|
|
type: Injectable
|
|
}], null, null);
|
|
})();
|
|
var MODIFIER_KEYS = ["alt", "control", "meta", "shift"];
|
|
var _keyMap = {
|
|
"\b": "Backspace",
|
|
" ": "Tab",
|
|
"": "Delete",
|
|
"\x1B": "Escape",
|
|
"Del": "Delete",
|
|
"Esc": "Escape",
|
|
"Left": "ArrowLeft",
|
|
"Right": "ArrowRight",
|
|
"Up": "ArrowUp",
|
|
"Down": "ArrowDown",
|
|
"Menu": "ContextMenu",
|
|
"Scroll": "ScrollLock",
|
|
"Win": "OS"
|
|
};
|
|
var MODIFIER_KEY_GETTERS = {
|
|
"alt": (event) => event.altKey,
|
|
"control": (event) => event.ctrlKey,
|
|
"meta": (event) => event.metaKey,
|
|
"shift": (event) => event.shiftKey
|
|
};
|
|
var KeyEventsPlugin = class _KeyEventsPlugin extends EventManagerPlugin {
|
|
/**
|
|
* Initializes an instance of the browser plug-in.
|
|
* @param doc The document in which key events will be detected.
|
|
*/
|
|
constructor(doc) {
|
|
super(doc);
|
|
}
|
|
/**
|
|
* Reports whether a named key event is supported.
|
|
* @param eventName The event name to query.
|
|
* @return True if the named key event is supported.
|
|
*/
|
|
supports(eventName) {
|
|
return _KeyEventsPlugin.parseEventName(eventName) != null;
|
|
}
|
|
/**
|
|
* Registers a handler for a specific element and key event.
|
|
* @param element The HTML element to receive event notifications.
|
|
* @param eventName The name of the key event to listen for.
|
|
* @param handler A function to call when the notification occurs. Receives the
|
|
* event object as an argument.
|
|
* @returns The key event that was registered.
|
|
*/
|
|
addEventListener(element, eventName, handler, options) {
|
|
const parsedEvent = _KeyEventsPlugin.parseEventName(eventName);
|
|
const outsideHandler = _KeyEventsPlugin.eventCallback(parsedEvent["fullKey"], handler, this.manager.getZone());
|
|
return this.manager.getZone().runOutsideAngular(() => {
|
|
return getDOM().onAndCancel(element, parsedEvent["domEventName"], outsideHandler, options);
|
|
});
|
|
}
|
|
/**
|
|
* Parses the user provided full keyboard event definition and normalizes it for
|
|
* later internal use. It ensures the string is all lowercase, converts special
|
|
* characters to a standard spelling, and orders all the values consistently.
|
|
*
|
|
* @param eventName The name of the key event to listen for.
|
|
* @returns an object with the full, normalized string, and the dom event name
|
|
* or null in the case when the event doesn't match a keyboard event.
|
|
*/
|
|
static parseEventName(eventName) {
|
|
const parts = eventName.toLowerCase().split(".");
|
|
const domEventName = parts.shift();
|
|
if (parts.length === 0 || !(domEventName === "keydown" || domEventName === "keyup")) {
|
|
return null;
|
|
}
|
|
const key = _KeyEventsPlugin._normalizeKey(parts.pop());
|
|
let fullKey = "";
|
|
let codeIX = parts.indexOf("code");
|
|
if (codeIX > -1) {
|
|
parts.splice(codeIX, 1);
|
|
fullKey = "code.";
|
|
}
|
|
MODIFIER_KEYS.forEach((modifierName) => {
|
|
const index = parts.indexOf(modifierName);
|
|
if (index > -1) {
|
|
parts.splice(index, 1);
|
|
fullKey += modifierName + ".";
|
|
}
|
|
});
|
|
fullKey += key;
|
|
if (parts.length != 0 || key.length === 0) {
|
|
return null;
|
|
}
|
|
const result = {};
|
|
result["domEventName"] = domEventName;
|
|
result["fullKey"] = fullKey;
|
|
return result;
|
|
}
|
|
/**
|
|
* Determines whether the actual keys pressed match the configured key code string.
|
|
* The `fullKeyCode` event is normalized in the `parseEventName` method when the
|
|
* event is attached to the DOM during the `addEventListener` call. This is unseen
|
|
* by the end user and is normalized for internal consistency and parsing.
|
|
*
|
|
* @param event The keyboard event.
|
|
* @param fullKeyCode The normalized user defined expected key event string
|
|
* @returns boolean.
|
|
*/
|
|
static matchEventFullKeyCode(event, fullKeyCode) {
|
|
let keycode = _keyMap[event.key] || event.key;
|
|
let key = "";
|
|
if (fullKeyCode.indexOf("code.") > -1) {
|
|
keycode = event.code;
|
|
key = "code.";
|
|
}
|
|
if (keycode == null || !keycode) return false;
|
|
keycode = keycode.toLowerCase();
|
|
if (keycode === " ") {
|
|
keycode = "space";
|
|
} else if (keycode === ".") {
|
|
keycode = "dot";
|
|
}
|
|
MODIFIER_KEYS.forEach((modifierName) => {
|
|
if (modifierName !== keycode) {
|
|
const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];
|
|
if (modifierGetter(event)) {
|
|
key += modifierName + ".";
|
|
}
|
|
}
|
|
});
|
|
key += keycode;
|
|
return key === fullKeyCode;
|
|
}
|
|
/**
|
|
* Configures a handler callback for a key event.
|
|
* @param fullKey The event name that combines all simultaneous keystrokes.
|
|
* @param handler The function that responds to the key event.
|
|
* @param zone The zone in which the event occurred.
|
|
* @returns A callback function.
|
|
*/
|
|
static eventCallback(fullKey, handler, zone) {
|
|
return (event) => {
|
|
if (_KeyEventsPlugin.matchEventFullKeyCode(event, fullKey)) {
|
|
zone.runGuarded(() => handler(event));
|
|
}
|
|
};
|
|
}
|
|
/** @internal */
|
|
static _normalizeKey(keyName) {
|
|
return keyName === "esc" ? "escape" : keyName;
|
|
}
|
|
static ɵfac = function KeyEventsPlugin_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _KeyEventsPlugin)(ɵɵinject(DOCUMENT));
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _KeyEventsPlugin,
|
|
factory: _KeyEventsPlugin.ɵfac
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(KeyEventsPlugin, [{
|
|
type: Injectable
|
|
}], () => [{
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}]
|
|
}], null);
|
|
})();
|
|
function bootstrapApplication(rootComponent, options, context) {
|
|
const config = __spreadValues({
|
|
rootComponent,
|
|
platformRef: context?.platformRef
|
|
}, createProvidersConfig(options));
|
|
if (false) {
|
|
return resolveComponentResources(fetch).catch((error) => {
|
|
console.error(error);
|
|
return Promise.resolve();
|
|
}).then(() => internalCreateApplication(config));
|
|
}
|
|
return internalCreateApplication(config);
|
|
}
|
|
function createApplication(options) {
|
|
return internalCreateApplication(createProvidersConfig(options));
|
|
}
|
|
function createProvidersConfig(options) {
|
|
return {
|
|
appProviders: [...BROWSER_MODULE_PROVIDERS, ...options?.providers ?? []],
|
|
platformProviders: INTERNAL_BROWSER_PLATFORM_PROVIDERS
|
|
};
|
|
}
|
|
function provideProtractorTestingSupport() {
|
|
return [...TESTABILITY_PROVIDERS];
|
|
}
|
|
function initDomAdapter() {
|
|
BrowserDomAdapter.makeCurrent();
|
|
}
|
|
function errorHandler() {
|
|
return new ErrorHandler();
|
|
}
|
|
function _document() {
|
|
setDocument(document);
|
|
return document;
|
|
}
|
|
var INTERNAL_BROWSER_PLATFORM_PROVIDERS = [{
|
|
provide: PLATFORM_ID,
|
|
useValue: PLATFORM_BROWSER_ID
|
|
}, {
|
|
provide: PLATFORM_INITIALIZER,
|
|
useValue: initDomAdapter,
|
|
multi: true
|
|
}, {
|
|
provide: DOCUMENT,
|
|
useFactory: _document
|
|
}];
|
|
var platformBrowser = createPlatformFactory(platformCore, "browser", INTERNAL_BROWSER_PLATFORM_PROVIDERS);
|
|
var BROWSER_MODULE_PROVIDERS_MARKER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "BrowserModule Providers Marker" : "");
|
|
var TESTABILITY_PROVIDERS = [{
|
|
provide: TESTABILITY_GETTER,
|
|
useClass: BrowserGetTestability
|
|
}, {
|
|
provide: TESTABILITY,
|
|
useClass: Testability,
|
|
deps: [NgZone, TestabilityRegistry, TESTABILITY_GETTER]
|
|
}, {
|
|
provide: Testability,
|
|
// Also provide as `Testability` for backwards-compatibility.
|
|
useClass: Testability,
|
|
deps: [NgZone, TestabilityRegistry, TESTABILITY_GETTER]
|
|
}];
|
|
var BROWSER_MODULE_PROVIDERS = [{
|
|
provide: INJECTOR_SCOPE,
|
|
useValue: "root"
|
|
}, {
|
|
provide: ErrorHandler,
|
|
useFactory: errorHandler
|
|
}, {
|
|
provide: EVENT_MANAGER_PLUGINS,
|
|
useClass: DomEventsPlugin,
|
|
multi: true,
|
|
deps: [DOCUMENT]
|
|
}, {
|
|
provide: EVENT_MANAGER_PLUGINS,
|
|
useClass: KeyEventsPlugin,
|
|
multi: true,
|
|
deps: [DOCUMENT]
|
|
}, DomRendererFactory2, SharedStylesHost, EventManager, {
|
|
provide: RendererFactory2,
|
|
useExisting: DomRendererFactory2
|
|
}, {
|
|
provide: XhrFactory,
|
|
useClass: BrowserXhr
|
|
}, typeof ngDevMode === "undefined" || ngDevMode ? {
|
|
provide: BROWSER_MODULE_PROVIDERS_MARKER,
|
|
useValue: true
|
|
} : []];
|
|
var BrowserModule = class _BrowserModule {
|
|
constructor() {
|
|
if (typeof ngDevMode === "undefined" || ngDevMode) {
|
|
const providersAlreadyPresent = inject(BROWSER_MODULE_PROVIDERS_MARKER, {
|
|
optional: true,
|
|
skipSelf: true
|
|
});
|
|
if (providersAlreadyPresent) {
|
|
throw new RuntimeError(5100, `Providers from the \`BrowserModule\` have already been loaded. If you need access to common directives such as NgIf and NgFor, import the \`CommonModule\` instead.`);
|
|
}
|
|
}
|
|
}
|
|
static ɵfac = function BrowserModule_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _BrowserModule)();
|
|
};
|
|
static ɵmod = ɵɵdefineNgModule({
|
|
type: _BrowserModule,
|
|
exports: [CommonModule, ApplicationModule]
|
|
});
|
|
static ɵinj = ɵɵdefineInjector({
|
|
providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
|
|
imports: [CommonModule, ApplicationModule]
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserModule, [{
|
|
type: NgModule,
|
|
args: [{
|
|
providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
|
|
exports: [CommonModule, ApplicationModule]
|
|
}]
|
|
}], () => [], null);
|
|
})();
|
|
|
|
// node_modules/@angular/platform-browser/fesm2022/platform-browser.mjs
|
|
var Meta = class _Meta {
|
|
_doc;
|
|
_dom;
|
|
constructor(_doc) {
|
|
this._doc = _doc;
|
|
this._dom = getDOM();
|
|
}
|
|
/**
|
|
* Retrieves or creates a specific `<meta>` tag element in the current HTML document.
|
|
* In searching for an existing tag, Angular attempts to match the `name` or `property` attribute
|
|
* values in the provided tag definition, and verifies that all other attribute values are equal.
|
|
* If an existing element is found, it is returned and is not modified in any way.
|
|
* @param tag The definition of a `<meta>` element to match or create.
|
|
* @param forceCreation True to create a new element without checking whether one already exists.
|
|
* @returns The existing element with the same attributes and values if found,
|
|
* the new element if no match is found, or `null` if the tag parameter is not defined.
|
|
*/
|
|
addTag(tag, forceCreation = false) {
|
|
if (!tag) return null;
|
|
return this._getOrCreateElement(tag, forceCreation);
|
|
}
|
|
/**
|
|
* Retrieves or creates a set of `<meta>` tag elements in the current HTML document.
|
|
* In searching for an existing tag, Angular attempts to match the `name` or `property` attribute
|
|
* values in the provided tag definition, and verifies that all other attribute values are equal.
|
|
* @param tags An array of tag definitions to match or create.
|
|
* @param forceCreation True to create new elements without checking whether they already exist.
|
|
* @returns The matching elements if found, or the new elements.
|
|
*/
|
|
addTags(tags, forceCreation = false) {
|
|
if (!tags) return [];
|
|
return tags.reduce((result, tag) => {
|
|
if (tag) {
|
|
result.push(this._getOrCreateElement(tag, forceCreation));
|
|
}
|
|
return result;
|
|
}, []);
|
|
}
|
|
/**
|
|
* Retrieves a `<meta>` tag element in the current HTML document.
|
|
* @param attrSelector The tag attribute and value to match against, in the format
|
|
* `"tag_attribute='value string'"`.
|
|
* @returns The matching element, if any.
|
|
*/
|
|
getTag(attrSelector) {
|
|
if (!attrSelector) return null;
|
|
return this._doc.querySelector(`meta[${attrSelector}]`) || null;
|
|
}
|
|
/**
|
|
* Retrieves a set of `<meta>` tag elements in the current HTML document.
|
|
* @param attrSelector The tag attribute and value to match against, in the format
|
|
* `"tag_attribute='value string'"`.
|
|
* @returns The matching elements, if any.
|
|
*/
|
|
getTags(attrSelector) {
|
|
if (!attrSelector) return [];
|
|
const list = this._doc.querySelectorAll(`meta[${attrSelector}]`);
|
|
return list ? [].slice.call(list) : [];
|
|
}
|
|
/**
|
|
* Modifies an existing `<meta>` tag element in the current HTML document.
|
|
* @param tag The tag description with which to replace the existing tag content.
|
|
* @param selector A tag attribute and value to match against, to identify
|
|
* an existing tag. A string in the format `"tag_attribute=`value string`"`.
|
|
* If not supplied, matches a tag with the same `name` or `property` attribute value as the
|
|
* replacement tag.
|
|
* @return The modified element.
|
|
*/
|
|
updateTag(tag, selector) {
|
|
if (!tag) return null;
|
|
selector = selector || this._parseSelector(tag);
|
|
const meta = this.getTag(selector);
|
|
if (meta) {
|
|
return this._setMetaElementAttributes(tag, meta);
|
|
}
|
|
return this._getOrCreateElement(tag, true);
|
|
}
|
|
/**
|
|
* Removes an existing `<meta>` tag element from the current HTML document.
|
|
* @param attrSelector A tag attribute and value to match against, to identify
|
|
* an existing tag. A string in the format `"tag_attribute=`value string`"`.
|
|
*/
|
|
removeTag(attrSelector) {
|
|
this.removeTagElement(this.getTag(attrSelector));
|
|
}
|
|
/**
|
|
* Removes an existing `<meta>` tag element from the current HTML document.
|
|
* @param meta The tag definition to match against to identify an existing tag.
|
|
*/
|
|
removeTagElement(meta) {
|
|
if (meta) {
|
|
this._dom.remove(meta);
|
|
}
|
|
}
|
|
_getOrCreateElement(meta, forceCreation = false) {
|
|
if (!forceCreation) {
|
|
const selector = this._parseSelector(meta);
|
|
const elem = this.getTags(selector).filter((elem2) => this._containsAttributes(meta, elem2))[0];
|
|
if (elem !== void 0) return elem;
|
|
}
|
|
const element = this._dom.createElement("meta");
|
|
this._setMetaElementAttributes(meta, element);
|
|
const head = this._doc.getElementsByTagName("head")[0];
|
|
head.appendChild(element);
|
|
return element;
|
|
}
|
|
_setMetaElementAttributes(tag, el) {
|
|
Object.keys(tag).forEach((prop) => el.setAttribute(this._getMetaKeyMap(prop), tag[prop]));
|
|
return el;
|
|
}
|
|
_parseSelector(tag) {
|
|
const attr = tag.name ? "name" : "property";
|
|
return `${attr}="${tag[attr]}"`;
|
|
}
|
|
_containsAttributes(tag, elem) {
|
|
return Object.keys(tag).every((key) => elem.getAttribute(this._getMetaKeyMap(key)) === tag[key]);
|
|
}
|
|
_getMetaKeyMap(prop) {
|
|
return META_KEYS_MAP[prop] || prop;
|
|
}
|
|
static ɵfac = function Meta_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _Meta)(ɵɵinject(DOCUMENT));
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _Meta,
|
|
factory: _Meta.ɵfac,
|
|
providedIn: "root"
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Meta, [{
|
|
type: Injectable,
|
|
args: [{
|
|
providedIn: "root"
|
|
}]
|
|
}], () => [{
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}]
|
|
}], null);
|
|
})();
|
|
var META_KEYS_MAP = {
|
|
httpEquiv: "http-equiv"
|
|
};
|
|
var Title = class _Title {
|
|
_doc;
|
|
constructor(_doc) {
|
|
this._doc = _doc;
|
|
}
|
|
/**
|
|
* Get the title of the current HTML document.
|
|
*/
|
|
getTitle() {
|
|
return this._doc.title;
|
|
}
|
|
/**
|
|
* Set the title of the current HTML document.
|
|
* @param newTitle
|
|
*/
|
|
setTitle(newTitle) {
|
|
this._doc.title = newTitle || "";
|
|
}
|
|
static ɵfac = function Title_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _Title)(ɵɵinject(DOCUMENT));
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _Title,
|
|
factory: _Title.ɵfac,
|
|
providedIn: "root"
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Title, [{
|
|
type: Injectable,
|
|
args: [{
|
|
providedIn: "root"
|
|
}]
|
|
}], () => [{
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}]
|
|
}], null);
|
|
})();
|
|
function exportNgVar(name, value) {
|
|
if (typeof COMPILED === "undefined" || !COMPILED) {
|
|
const ng = _global["ng"] = _global["ng"] || {};
|
|
ng[name] = value;
|
|
}
|
|
}
|
|
var ChangeDetectionPerfRecord = class {
|
|
msPerTick;
|
|
numTicks;
|
|
constructor(msPerTick, numTicks) {
|
|
this.msPerTick = msPerTick;
|
|
this.numTicks = numTicks;
|
|
}
|
|
};
|
|
var AngularProfiler = class {
|
|
appRef;
|
|
constructor(ref) {
|
|
this.appRef = ref.injector.get(ApplicationRef);
|
|
}
|
|
// tslint:disable:no-console
|
|
/**
|
|
* Exercises change detection in a loop and then prints the average amount of
|
|
* time in milliseconds how long a single round of change detection takes for
|
|
* the current state of the UI. It runs a minimum of 5 rounds for a minimum
|
|
* of 500 milliseconds.
|
|
*
|
|
* Optionally, a user may pass a `config` parameter containing a map of
|
|
* options. Supported options are:
|
|
*
|
|
* `record` (boolean) - causes the profiler to record a CPU profile while
|
|
* it exercises the change detector. Example:
|
|
*
|
|
* ```ts
|
|
* ng.profiler.timeChangeDetection({record: true})
|
|
* ```
|
|
*/
|
|
timeChangeDetection(config) {
|
|
const record = config && config["record"];
|
|
const profileName = "Change Detection";
|
|
if (record && "profile" in console && typeof console.profile === "function") {
|
|
console.profile(profileName);
|
|
}
|
|
const start = performance.now();
|
|
let numTicks = 0;
|
|
while (numTicks < 5 || performance.now() - start < 500) {
|
|
this.appRef.tick();
|
|
numTicks++;
|
|
}
|
|
const end = performance.now();
|
|
if (record && "profileEnd" in console && typeof console.profileEnd === "function") {
|
|
console.profileEnd(profileName);
|
|
}
|
|
const msPerTick = (end - start) / numTicks;
|
|
console.log(`ran ${numTicks} change detection cycles`);
|
|
console.log(`${msPerTick.toFixed(2)} ms per check`);
|
|
return new ChangeDetectionPerfRecord(msPerTick, numTicks);
|
|
}
|
|
};
|
|
var PROFILER_GLOBAL_NAME = "profiler";
|
|
function enableDebugTools(ref) {
|
|
exportNgVar(PROFILER_GLOBAL_NAME, new AngularProfiler(ref));
|
|
return ref;
|
|
}
|
|
function disableDebugTools() {
|
|
exportNgVar(PROFILER_GLOBAL_NAME, null);
|
|
}
|
|
var By = class {
|
|
/**
|
|
* Match all nodes.
|
|
*
|
|
* @usageNotes
|
|
* ### Example
|
|
*
|
|
* {@example platform-browser/dom/debug/ts/by/by.ts region='by_all'}
|
|
*/
|
|
static all() {
|
|
return () => true;
|
|
}
|
|
/**
|
|
* Match elements by the given CSS selector.
|
|
*
|
|
* @usageNotes
|
|
* ### Example
|
|
*
|
|
* {@example platform-browser/dom/debug/ts/by/by.ts region='by_css'}
|
|
*/
|
|
static css(selector) {
|
|
return (debugElement) => {
|
|
return debugElement.nativeElement != null ? elementMatches(debugElement.nativeElement, selector) : false;
|
|
};
|
|
}
|
|
/**
|
|
* Match nodes that have the given directive present.
|
|
*
|
|
* @usageNotes
|
|
* ### Example
|
|
*
|
|
* {@example platform-browser/dom/debug/ts/by/by.ts region='by_directive'}
|
|
*/
|
|
static directive(type) {
|
|
return (debugNode) => debugNode.providerTokens.indexOf(type) !== -1;
|
|
}
|
|
};
|
|
function elementMatches(n, selector) {
|
|
if (getDOM().isElementNode(n)) {
|
|
return n.matches && n.matches(selector) || n.msMatchesSelector && n.msMatchesSelector(selector) || n.webkitMatchesSelector && n.webkitMatchesSelector(selector);
|
|
}
|
|
return false;
|
|
}
|
|
var EVENT_NAMES = {
|
|
// pan
|
|
"pan": true,
|
|
"panstart": true,
|
|
"panmove": true,
|
|
"panend": true,
|
|
"pancancel": true,
|
|
"panleft": true,
|
|
"panright": true,
|
|
"panup": true,
|
|
"pandown": true,
|
|
// pinch
|
|
"pinch": true,
|
|
"pinchstart": true,
|
|
"pinchmove": true,
|
|
"pinchend": true,
|
|
"pinchcancel": true,
|
|
"pinchin": true,
|
|
"pinchout": true,
|
|
// press
|
|
"press": true,
|
|
"pressup": true,
|
|
// rotate
|
|
"rotate": true,
|
|
"rotatestart": true,
|
|
"rotatemove": true,
|
|
"rotateend": true,
|
|
"rotatecancel": true,
|
|
// swipe
|
|
"swipe": true,
|
|
"swipeleft": true,
|
|
"swiperight": true,
|
|
"swipeup": true,
|
|
"swipedown": true,
|
|
// tap
|
|
"tap": true,
|
|
"doubletap": true
|
|
};
|
|
var HAMMER_GESTURE_CONFIG = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "HammerGestureConfig" : "");
|
|
var HAMMER_LOADER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "HammerLoader" : "");
|
|
var HammerGestureConfig = class _HammerGestureConfig {
|
|
/**
|
|
* A set of supported event names for gestures to be used in Angular.
|
|
* Angular supports all built-in recognizers, as listed in
|
|
* [HammerJS documentation](https://hammerjs.github.io/).
|
|
*/
|
|
events = [];
|
|
/**
|
|
* Maps gesture event names to a set of configuration options
|
|
* that specify overrides to the default values for specific properties.
|
|
*
|
|
* The key is a supported event name to be configured,
|
|
* and the options object contains a set of properties, with override values
|
|
* to be applied to the named recognizer event.
|
|
* For example, to disable recognition of the rotate event, specify
|
|
* `{"rotate": {"enable": false}}`.
|
|
*
|
|
* Properties that are not present take the HammerJS default values.
|
|
* For information about which properties are supported for which events,
|
|
* and their allowed and default values, see
|
|
* [HammerJS documentation](https://hammerjs.github.io/).
|
|
*
|
|
*/
|
|
overrides = {};
|
|
/**
|
|
* Properties whose default values can be overridden for a given event.
|
|
* Different sets of properties apply to different events.
|
|
* For information about which properties are supported for which events,
|
|
* and their allowed and default values, see
|
|
* [HammerJS documentation](https://hammerjs.github.io/).
|
|
*/
|
|
options;
|
|
/**
|
|
* Creates a [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)
|
|
* and attaches it to a given HTML element.
|
|
* @param element The element that will recognize gestures.
|
|
* @returns A HammerJS event-manager object.
|
|
*/
|
|
buildHammer(element) {
|
|
const mc = new Hammer(element, this.options);
|
|
mc.get("pinch").set({
|
|
enable: true
|
|
});
|
|
mc.get("rotate").set({
|
|
enable: true
|
|
});
|
|
for (const eventName in this.overrides) {
|
|
mc.get(eventName).set(this.overrides[eventName]);
|
|
}
|
|
return mc;
|
|
}
|
|
static ɵfac = function HammerGestureConfig_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _HammerGestureConfig)();
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _HammerGestureConfig,
|
|
factory: _HammerGestureConfig.ɵfac
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGestureConfig, [{
|
|
type: Injectable
|
|
}], null, null);
|
|
})();
|
|
var HammerGesturesPlugin = class _HammerGesturesPlugin extends EventManagerPlugin {
|
|
_config;
|
|
_injector;
|
|
loader;
|
|
_loaderPromise = null;
|
|
constructor(doc, _config, _injector, loader) {
|
|
super(doc);
|
|
this._config = _config;
|
|
this._injector = _injector;
|
|
this.loader = loader;
|
|
}
|
|
supports(eventName) {
|
|
if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {
|
|
return false;
|
|
}
|
|
if (!window.Hammer && !this.loader) {
|
|
if (typeof ngDevMode === "undefined" || ngDevMode) {
|
|
const _console = this._injector.get(Console);
|
|
_console.warn(`The "${eventName}" event cannot be bound because Hammer.JS is not loaded and no custom loader has been specified.`);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
addEventListener(element, eventName, handler) {
|
|
const zone = this.manager.getZone();
|
|
eventName = eventName.toLowerCase();
|
|
if (!window.Hammer && this.loader) {
|
|
this._loaderPromise = this._loaderPromise || zone.runOutsideAngular(() => this.loader());
|
|
let cancelRegistration = false;
|
|
let deregister = () => {
|
|
cancelRegistration = true;
|
|
};
|
|
zone.runOutsideAngular(() => this._loaderPromise.then(() => {
|
|
if (!window.Hammer) {
|
|
if (typeof ngDevMode === "undefined" || ngDevMode) {
|
|
const _console = this._injector.get(Console);
|
|
_console.warn(`The custom HAMMER_LOADER completed, but Hammer.JS is not present.`);
|
|
}
|
|
deregister = () => {
|
|
};
|
|
return;
|
|
}
|
|
if (!cancelRegistration) {
|
|
deregister = this.addEventListener(element, eventName, handler);
|
|
}
|
|
}).catch(() => {
|
|
if (typeof ngDevMode === "undefined" || ngDevMode) {
|
|
const _console = this._injector.get(Console);
|
|
_console.warn(`The "${eventName}" event cannot be bound because the custom Hammer.JS loader failed.`);
|
|
}
|
|
deregister = () => {
|
|
};
|
|
}));
|
|
return () => {
|
|
deregister();
|
|
};
|
|
}
|
|
return zone.runOutsideAngular(() => {
|
|
const mc = this._config.buildHammer(element);
|
|
const callback = function(eventObj) {
|
|
zone.runGuarded(function() {
|
|
handler(eventObj);
|
|
});
|
|
};
|
|
mc.on(eventName, callback);
|
|
return () => {
|
|
mc.off(eventName, callback);
|
|
if (typeof mc.destroy === "function") {
|
|
mc.destroy();
|
|
}
|
|
};
|
|
});
|
|
}
|
|
isCustomEvent(eventName) {
|
|
return this._config.events.indexOf(eventName) > -1;
|
|
}
|
|
static ɵfac = function HammerGesturesPlugin_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _HammerGesturesPlugin)(ɵɵinject(DOCUMENT), ɵɵinject(HAMMER_GESTURE_CONFIG), ɵɵinject(Injector), ɵɵinject(HAMMER_LOADER, 8));
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _HammerGesturesPlugin,
|
|
factory: _HammerGesturesPlugin.ɵfac
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGesturesPlugin, [{
|
|
type: Injectable
|
|
}], () => [{
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}]
|
|
}, {
|
|
type: HammerGestureConfig,
|
|
decorators: [{
|
|
type: Inject,
|
|
args: [HAMMER_GESTURE_CONFIG]
|
|
}]
|
|
}, {
|
|
type: Injector
|
|
}, {
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Inject,
|
|
args: [HAMMER_LOADER]
|
|
}]
|
|
}], null);
|
|
})();
|
|
var HammerModule = class _HammerModule {
|
|
static ɵfac = function HammerModule_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _HammerModule)();
|
|
};
|
|
static ɵmod = ɵɵdefineNgModule({
|
|
type: _HammerModule
|
|
});
|
|
static ɵinj = ɵɵdefineInjector({
|
|
providers: [{
|
|
provide: EVENT_MANAGER_PLUGINS,
|
|
useClass: HammerGesturesPlugin,
|
|
multi: true,
|
|
deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Injector, [new Optional(), HAMMER_LOADER]]
|
|
}, {
|
|
provide: HAMMER_GESTURE_CONFIG,
|
|
useClass: HammerGestureConfig
|
|
}]
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerModule, [{
|
|
type: NgModule,
|
|
args: [{
|
|
providers: [{
|
|
provide: EVENT_MANAGER_PLUGINS,
|
|
useClass: HammerGesturesPlugin,
|
|
multi: true,
|
|
deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Injector, [new Optional(), HAMMER_LOADER]]
|
|
}, {
|
|
provide: HAMMER_GESTURE_CONFIG,
|
|
useClass: HammerGestureConfig
|
|
}]
|
|
}]
|
|
}], null, null);
|
|
})();
|
|
var DomSanitizer = class _DomSanitizer {
|
|
static ɵfac = function DomSanitizer_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _DomSanitizer)();
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _DomSanitizer,
|
|
factory: function DomSanitizer_Factory(__ngFactoryType__) {
|
|
let __ngConditionalFactory__ = null;
|
|
if (__ngFactoryType__) {
|
|
__ngConditionalFactory__ = new (__ngFactoryType__ || _DomSanitizer)();
|
|
} else {
|
|
__ngConditionalFactory__ = ɵɵinject(DomSanitizerImpl);
|
|
}
|
|
return __ngConditionalFactory__;
|
|
},
|
|
providedIn: "root"
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizer, [{
|
|
type: Injectable,
|
|
args: [{
|
|
providedIn: "root",
|
|
useExisting: forwardRef(() => DomSanitizerImpl)
|
|
}]
|
|
}], null, null);
|
|
})();
|
|
var DomSanitizerImpl = class _DomSanitizerImpl extends DomSanitizer {
|
|
_doc;
|
|
constructor(_doc) {
|
|
super();
|
|
this._doc = _doc;
|
|
}
|
|
sanitize(ctx, value) {
|
|
if (value == null) return null;
|
|
switch (ctx) {
|
|
case SecurityContext.NONE:
|
|
return value;
|
|
case SecurityContext.HTML:
|
|
if (allowSanitizationBypassAndThrow(
|
|
value,
|
|
"HTML"
|
|
/* BypassType.Html */
|
|
)) {
|
|
return unwrapSafeValue(value);
|
|
}
|
|
return _sanitizeHtml(this._doc, String(value)).toString();
|
|
case SecurityContext.STYLE:
|
|
if (allowSanitizationBypassAndThrow(
|
|
value,
|
|
"Style"
|
|
/* BypassType.Style */
|
|
)) {
|
|
return unwrapSafeValue(value);
|
|
}
|
|
return value;
|
|
case SecurityContext.SCRIPT:
|
|
if (allowSanitizationBypassAndThrow(
|
|
value,
|
|
"Script"
|
|
/* BypassType.Script */
|
|
)) {
|
|
return unwrapSafeValue(value);
|
|
}
|
|
throw new RuntimeError(5200, (typeof ngDevMode === "undefined" || ngDevMode) && "unsafe value used in a script context");
|
|
case SecurityContext.URL:
|
|
if (allowSanitizationBypassAndThrow(
|
|
value,
|
|
"URL"
|
|
/* BypassType.Url */
|
|
)) {
|
|
return unwrapSafeValue(value);
|
|
}
|
|
return _sanitizeUrl(String(value));
|
|
case SecurityContext.RESOURCE_URL:
|
|
if (allowSanitizationBypassAndThrow(
|
|
value,
|
|
"ResourceURL"
|
|
/* BypassType.ResourceUrl */
|
|
)) {
|
|
return unwrapSafeValue(value);
|
|
}
|
|
throw new RuntimeError(5201, (typeof ngDevMode === "undefined" || ngDevMode) && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);
|
|
default:
|
|
throw new RuntimeError(5202, (typeof ngDevMode === "undefined" || ngDevMode) && `Unexpected SecurityContext ${ctx} (see ${XSS_SECURITY_URL})`);
|
|
}
|
|
}
|
|
bypassSecurityTrustHtml(value) {
|
|
return bypassSanitizationTrustHtml(value);
|
|
}
|
|
bypassSecurityTrustStyle(value) {
|
|
return bypassSanitizationTrustStyle(value);
|
|
}
|
|
bypassSecurityTrustScript(value) {
|
|
return bypassSanitizationTrustScript(value);
|
|
}
|
|
bypassSecurityTrustUrl(value) {
|
|
return bypassSanitizationTrustUrl(value);
|
|
}
|
|
bypassSecurityTrustResourceUrl(value) {
|
|
return bypassSanitizationTrustResourceUrl(value);
|
|
}
|
|
static ɵfac = function DomSanitizerImpl_Factory(__ngFactoryType__) {
|
|
return new (__ngFactoryType__ || _DomSanitizerImpl)(ɵɵinject(DOCUMENT));
|
|
};
|
|
static ɵprov = ɵɵdefineInjectable({
|
|
token: _DomSanitizerImpl,
|
|
factory: _DomSanitizerImpl.ɵfac,
|
|
providedIn: "root"
|
|
});
|
|
};
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizerImpl, [{
|
|
type: Injectable,
|
|
args: [{
|
|
providedIn: "root"
|
|
}]
|
|
}], () => [{
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}]
|
|
}], null);
|
|
})();
|
|
var HydrationFeatureKind;
|
|
(function(HydrationFeatureKind2) {
|
|
HydrationFeatureKind2[HydrationFeatureKind2["NoHttpTransferCache"] = 0] = "NoHttpTransferCache";
|
|
HydrationFeatureKind2[HydrationFeatureKind2["HttpTransferCacheOptions"] = 1] = "HttpTransferCacheOptions";
|
|
HydrationFeatureKind2[HydrationFeatureKind2["I18nSupport"] = 2] = "I18nSupport";
|
|
HydrationFeatureKind2[HydrationFeatureKind2["EventReplay"] = 3] = "EventReplay";
|
|
HydrationFeatureKind2[HydrationFeatureKind2["IncrementalHydration"] = 4] = "IncrementalHydration";
|
|
})(HydrationFeatureKind || (HydrationFeatureKind = {}));
|
|
function hydrationFeature(ɵkind, ɵproviders = [], ɵoptions = {}) {
|
|
return {
|
|
ɵkind,
|
|
ɵproviders
|
|
};
|
|
}
|
|
function withNoHttpTransferCache() {
|
|
return hydrationFeature(HydrationFeatureKind.NoHttpTransferCache);
|
|
}
|
|
function withHttpTransferCacheOptions(options) {
|
|
return hydrationFeature(HydrationFeatureKind.HttpTransferCacheOptions, withHttpTransferCache(options));
|
|
}
|
|
function withI18nSupport2() {
|
|
return hydrationFeature(HydrationFeatureKind.I18nSupport, withI18nSupport());
|
|
}
|
|
function withEventReplay2() {
|
|
return hydrationFeature(HydrationFeatureKind.EventReplay, withEventReplay());
|
|
}
|
|
function withIncrementalHydration2() {
|
|
return hydrationFeature(HydrationFeatureKind.IncrementalHydration, withIncrementalHydration());
|
|
}
|
|
function provideZoneJsCompatibilityDetector() {
|
|
return [{
|
|
provide: ENVIRONMENT_INITIALIZER,
|
|
useValue: () => {
|
|
const ngZone = inject(NgZone);
|
|
const isZoneless = inject(ZONELESS_ENABLED);
|
|
if (!isZoneless && ngZone.constructor !== NgZone) {
|
|
const console2 = inject(Console);
|
|
const message = formatRuntimeError(-5e3, "Angular detected that hydration was enabled for an application that uses a custom or a noop Zone.js implementation. This is not yet a fully supported configuration.");
|
|
console2.warn(message);
|
|
}
|
|
},
|
|
multi: true
|
|
}];
|
|
}
|
|
function provideEnabledBlockingInitialNavigationDetector() {
|
|
return [{
|
|
provide: ENVIRONMENT_INITIALIZER,
|
|
useValue: () => {
|
|
const isEnabledBlockingInitialNavigation = inject(IS_ENABLED_BLOCKING_INITIAL_NAVIGATION, {
|
|
optional: true
|
|
});
|
|
if (isEnabledBlockingInitialNavigation) {
|
|
const console2 = inject(Console);
|
|
const message = formatRuntimeError(5001, "Configuration error: found both hydration and enabledBlocking initial navigation in the same application, which is a contradiction.");
|
|
console2.warn(message);
|
|
}
|
|
},
|
|
multi: true
|
|
}];
|
|
}
|
|
function provideClientHydration(...features) {
|
|
const providers = [];
|
|
const featuresKind = /* @__PURE__ */ new Set();
|
|
for (const {
|
|
ɵproviders,
|
|
ɵkind
|
|
} of features) {
|
|
featuresKind.add(ɵkind);
|
|
if (ɵproviders.length) {
|
|
providers.push(ɵproviders);
|
|
}
|
|
}
|
|
const hasHttpTransferCacheOptions = featuresKind.has(HydrationFeatureKind.HttpTransferCacheOptions);
|
|
if (typeof ngDevMode !== "undefined" && ngDevMode && featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) && hasHttpTransferCacheOptions) {
|
|
throw new RuntimeError(5001, "Configuration error: found both withHttpTransferCacheOptions() and withNoHttpTransferCache() in the same call to provideClientHydration(), which is a contradiction.");
|
|
}
|
|
return makeEnvironmentProviders([typeof ngDevMode !== "undefined" && ngDevMode ? provideZoneJsCompatibilityDetector() : [], typeof ngDevMode !== "undefined" && ngDevMode ? provideEnabledBlockingInitialNavigationDetector() : [], withDomHydration(), featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) || hasHttpTransferCacheOptions ? [] : withHttpTransferCache({}), providers]);
|
|
}
|
|
var VERSION = new Version("20.3.18");
|
|
|
|
export {
|
|
BrowserDomAdapter,
|
|
BrowserGetTestability,
|
|
KeyEventsPlugin,
|
|
bootstrapApplication,
|
|
createApplication,
|
|
provideProtractorTestingSupport,
|
|
platformBrowser,
|
|
BrowserModule,
|
|
Meta,
|
|
Title,
|
|
enableDebugTools,
|
|
disableDebugTools,
|
|
By,
|
|
HAMMER_GESTURE_CONFIG,
|
|
HAMMER_LOADER,
|
|
HammerGestureConfig,
|
|
HammerGesturesPlugin,
|
|
HammerModule,
|
|
DomSanitizer,
|
|
DomSanitizerImpl,
|
|
HydrationFeatureKind,
|
|
withNoHttpTransferCache,
|
|
withHttpTransferCacheOptions,
|
|
withI18nSupport2 as withI18nSupport,
|
|
withEventReplay2 as withEventReplay,
|
|
withIncrementalHydration2 as withIncrementalHydration,
|
|
provideClientHydration,
|
|
VERSION
|
|
};
|
|
/*! Bundled license information:
|
|
|
|
@angular/platform-browser/fesm2022/browser.mjs:
|
|
@angular/platform-browser/fesm2022/platform-browser.mjs:
|
|
(**
|
|
* @license Angular v20.3.18
|
|
* (c) 2010-2025 Google LLC. https://angular.dev/
|
|
* License: MIT
|
|
*)
|
|
*/
|
|
//# sourceMappingURL=chunk-OVEDGMY5.js.map
|