4441 lines
144 KiB
JavaScript
4441 lines
144 KiB
JavaScript
import {
|
||
CommonModule,
|
||
DomAdapter,
|
||
PLATFORM_BROWSER_ID,
|
||
XhrFactory,
|
||
getDOM,
|
||
isPlatformServer,
|
||
parseCookieValue,
|
||
setRootDomAdapter
|
||
} from "./chunk-7C5SFJUK.js";
|
||
import {
|
||
APP_BOOTSTRAP_LISTENER,
|
||
APP_ID,
|
||
ApplicationModule,
|
||
ApplicationRef,
|
||
CSP_NONCE,
|
||
Console,
|
||
DOCUMENT,
|
||
DestroyRef,
|
||
ENVIRONMENT_INITIALIZER,
|
||
EnvironmentInjector,
|
||
ErrorHandler,
|
||
INJECTOR_SCOPE,
|
||
Inject,
|
||
Injectable,
|
||
InjectionToken,
|
||
Injector,
|
||
NgModule,
|
||
NgZone,
|
||
Observable,
|
||
Optional,
|
||
PLATFORM_ID,
|
||
PLATFORM_INITIALIZER,
|
||
PendingTasks,
|
||
RendererFactory2,
|
||
RendererStyleFlags2,
|
||
ResourceImpl,
|
||
RuntimeError,
|
||
SecurityContext,
|
||
TESTABILITY,
|
||
TESTABILITY_GETTER,
|
||
Testability,
|
||
TestabilityRegistry,
|
||
TracingService,
|
||
TransferState,
|
||
Version,
|
||
ViewEncapsulation,
|
||
XSS_SECURITY_URL,
|
||
ZONELESS_ENABLED,
|
||
__objRest,
|
||
__spreadValues,
|
||
_global,
|
||
_sanitizeHtml,
|
||
_sanitizeUrl,
|
||
allowSanitizationBypassAndThrow,
|
||
assertInInjectionContext,
|
||
bypassSanitizationTrustHtml,
|
||
bypassSanitizationTrustResourceUrl,
|
||
bypassSanitizationTrustScript,
|
||
bypassSanitizationTrustStyle,
|
||
bypassSanitizationTrustUrl,
|
||
computed,
|
||
concatMap,
|
||
createPlatformFactory,
|
||
encapsulateResourceError,
|
||
filter,
|
||
finalize,
|
||
formatRuntimeError,
|
||
forwardRef,
|
||
from,
|
||
inject,
|
||
internalCreateApplication,
|
||
linkedSignal,
|
||
makeEnvironmentProviders,
|
||
makeStateKey,
|
||
map,
|
||
of,
|
||
performanceMarkFeature,
|
||
platformCore,
|
||
runInInjectionContext,
|
||
setClassMetadata,
|
||
setDocument,
|
||
signal,
|
||
switchMap,
|
||
tap,
|
||
truncateMiddle,
|
||
unwrapSafeValue,
|
||
withDomHydration,
|
||
withEventReplay,
|
||
withI18nSupport,
|
||
withIncrementalHydration,
|
||
ɵɵdefineInjectable,
|
||
ɵɵdefineInjector,
|
||
ɵɵdefineNgModule,
|
||
ɵɵinject
|
||
} from "./chunk-KGNT7U4K.js";
|
||
|
||
// node_modules/@angular/platform-browser/fesm2022/dom_renderer-Frqw9gM5.mjs
|
||
var EVENT_MANAGER_PLUGINS = new InjectionToken(ngDevMode ? "EventManagerPlugins" : "");
|
||
var EventManager = class _EventManager {
|
||
_zone;
|
||
_plugins;
|
||
_eventNameToPlugin = /* @__PURE__ */ new Map();
|
||
/**
|
||
* Initializes an instance of the event-manager service.
|
||
*/
|
||
constructor(plugins, _zone) {
|
||
this._zone = _zone;
|
||
plugins.forEach((plugin) => {
|
||
plugin.manager = this;
|
||
});
|
||
this._plugins = plugins.slice().reverse();
|
||
}
|
||
/**
|
||
* Registers a handler for a specific element and event.
|
||
*
|
||
* @param element The HTML element to receive event notifications.
|
||
* @param eventName The name of the event to listen for.
|
||
* @param handler A function to call when the notification occurs. Receives the
|
||
* event object as an argument.
|
||
* @param options Options that configure how the event listener is bound.
|
||
* @returns A callback function that can be used to remove the handler.
|
||
*/
|
||
addEventListener(element, eventName, handler, options) {
|
||
const plugin = this._findPluginFor(eventName);
|
||
return plugin.addEventListener(element, eventName, handler, options);
|
||
}
|
||
/**
|
||
* Retrieves the compilation zone in which event listeners are registered.
|
||
*/
|
||
getZone() {
|
||
return this._zone;
|
||
}
|
||
/** @internal */
|
||
_findPluginFor(eventName) {
|
||
let plugin = this._eventNameToPlugin.get(eventName);
|
||
if (plugin) {
|
||
return plugin;
|
||
}
|
||
const plugins = this._plugins;
|
||
plugin = plugins.find((plugin2) => plugin2.supports(eventName));
|
||
if (!plugin) {
|
||
throw new RuntimeError(5101, (typeof ngDevMode === "undefined" || ngDevMode) && `No event manager plugin found for event ${eventName}`);
|
||
}
|
||
this._eventNameToPlugin.set(eventName, plugin);
|
||
return plugin;
|
||
}
|
||
static ɵfac = function EventManager_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _EventManager)(ɵɵinject(EVENT_MANAGER_PLUGINS), ɵɵinject(NgZone));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _EventManager,
|
||
factory: _EventManager.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EventManager, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [EVENT_MANAGER_PLUGINS]
|
||
}]
|
||
}, {
|
||
type: NgZone
|
||
}], null);
|
||
})();
|
||
var EventManagerPlugin = class {
|
||
_doc;
|
||
// TODO: remove (has some usage in G3)
|
||
constructor(_doc) {
|
||
this._doc = _doc;
|
||
}
|
||
// Using non-null assertion because it's set by EventManager's constructor
|
||
manager;
|
||
};
|
||
var APP_ID_ATTRIBUTE_NAME = "ng-app-id";
|
||
function removeElements(elements) {
|
||
for (const element of elements) {
|
||
element.remove();
|
||
}
|
||
}
|
||
function createStyleElement(style, doc) {
|
||
const styleElement = doc.createElement("style");
|
||
styleElement.textContent = style;
|
||
return styleElement;
|
||
}
|
||
function addServerStyles(doc, appId, inline, external) {
|
||
const elements = doc.head?.querySelectorAll(`style[${APP_ID_ATTRIBUTE_NAME}="${appId}"],link[${APP_ID_ATTRIBUTE_NAME}="${appId}"]`);
|
||
if (elements) {
|
||
for (const styleElement of elements) {
|
||
styleElement.removeAttribute(APP_ID_ATTRIBUTE_NAME);
|
||
if (styleElement instanceof HTMLLinkElement) {
|
||
external.set(styleElement.href.slice(styleElement.href.lastIndexOf("/") + 1), {
|
||
usage: 0,
|
||
elements: [styleElement]
|
||
});
|
||
} else if (styleElement.textContent) {
|
||
inline.set(styleElement.textContent, {
|
||
usage: 0,
|
||
elements: [styleElement]
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function createLinkElement(url, doc) {
|
||
const linkElement = doc.createElement("link");
|
||
linkElement.setAttribute("rel", "stylesheet");
|
||
linkElement.setAttribute("href", url);
|
||
return linkElement;
|
||
}
|
||
var SharedStylesHost = class _SharedStylesHost {
|
||
doc;
|
||
appId;
|
||
nonce;
|
||
/**
|
||
* Provides usage information for active inline style content and associated HTML <style> elements.
|
||
* Embedded styles typically originate from the `styles` metadata of a rendered component.
|
||
*/
|
||
inline = /* @__PURE__ */ new Map();
|
||
/**
|
||
* Provides usage information for active external style URLs and the associated HTML <link> elements.
|
||
* External styles typically originate from the `ɵɵExternalStylesFeature` of a rendered component.
|
||
*/
|
||
external = /* @__PURE__ */ new Map();
|
||
/**
|
||
* Set of host DOM nodes that will have styles attached.
|
||
*/
|
||
hosts = /* @__PURE__ */ new Set();
|
||
/**
|
||
* Whether the application code is currently executing on a server.
|
||
*/
|
||
isServer;
|
||
constructor(doc, appId, nonce, platformId = {}) {
|
||
this.doc = doc;
|
||
this.appId = appId;
|
||
this.nonce = nonce;
|
||
this.isServer = isPlatformServer(platformId);
|
||
addServerStyles(doc, appId, this.inline, this.external);
|
||
this.hosts.add(doc.head);
|
||
}
|
||
/**
|
||
* Adds embedded styles to the DOM via HTML `style` elements.
|
||
* @param styles An array of style content strings.
|
||
*/
|
||
addStyles(styles, urls) {
|
||
for (const value of styles) {
|
||
this.addUsage(value, this.inline, createStyleElement);
|
||
}
|
||
urls?.forEach((value) => this.addUsage(value, this.external, createLinkElement));
|
||
}
|
||
/**
|
||
* Removes embedded styles from the DOM that were added as HTML `style` elements.
|
||
* @param styles An array of style content strings.
|
||
*/
|
||
removeStyles(styles, urls) {
|
||
for (const value of styles) {
|
||
this.removeUsage(value, this.inline);
|
||
}
|
||
urls?.forEach((value) => this.removeUsage(value, this.external));
|
||
}
|
||
addUsage(value, usages, creator) {
|
||
const record = usages.get(value);
|
||
if (record) {
|
||
if ((typeof ngDevMode === "undefined" || ngDevMode) && record.usage === 0) {
|
||
record.elements.forEach((element) => element.setAttribute("ng-style-reused", ""));
|
||
}
|
||
record.usage++;
|
||
} else {
|
||
usages.set(value, {
|
||
usage: 1,
|
||
elements: [...this.hosts].map((host) => this.addElement(host, creator(value, this.doc)))
|
||
});
|
||
}
|
||
}
|
||
removeUsage(value, usages) {
|
||
const record = usages.get(value);
|
||
if (record) {
|
||
record.usage--;
|
||
if (record.usage <= 0) {
|
||
removeElements(record.elements);
|
||
usages.delete(value);
|
||
}
|
||
}
|
||
}
|
||
ngOnDestroy() {
|
||
for (const [, {
|
||
elements
|
||
}] of [...this.inline, ...this.external]) {
|
||
removeElements(elements);
|
||
}
|
||
this.hosts.clear();
|
||
}
|
||
/**
|
||
* Adds a host node to the set of style hosts and adds all existing style usage to
|
||
* the newly added host node.
|
||
*
|
||
* This is currently only used for Shadow DOM encapsulation mode.
|
||
*/
|
||
addHost(hostNode) {
|
||
this.hosts.add(hostNode);
|
||
for (const [style, {
|
||
elements
|
||
}] of this.inline) {
|
||
elements.push(this.addElement(hostNode, createStyleElement(style, this.doc)));
|
||
}
|
||
for (const [url, {
|
||
elements
|
||
}] of this.external) {
|
||
elements.push(this.addElement(hostNode, createLinkElement(url, this.doc)));
|
||
}
|
||
}
|
||
removeHost(hostNode) {
|
||
this.hosts.delete(hostNode);
|
||
}
|
||
addElement(host, element) {
|
||
if (this.nonce) {
|
||
element.setAttribute("nonce", this.nonce);
|
||
}
|
||
if (this.isServer) {
|
||
element.setAttribute(APP_ID_ATTRIBUTE_NAME, this.appId);
|
||
}
|
||
return host.appendChild(element);
|
||
}
|
||
static ɵfac = function SharedStylesHost_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _SharedStylesHost)(ɵɵinject(DOCUMENT), ɵɵinject(APP_ID), ɵɵinject(CSP_NONCE, 8), ɵɵinject(PLATFORM_ID));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _SharedStylesHost,
|
||
factory: _SharedStylesHost.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SharedStylesHost, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: Document,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [DOCUMENT]
|
||
}]
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [APP_ID]
|
||
}]
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [CSP_NONCE]
|
||
}, {
|
||
type: Optional
|
||
}]
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [PLATFORM_ID]
|
||
}]
|
||
}], null);
|
||
})();
|
||
var NAMESPACE_URIS = {
|
||
"svg": "http://www.w3.org/2000/svg",
|
||
"xhtml": "http://www.w3.org/1999/xhtml",
|
||
"xlink": "http://www.w3.org/1999/xlink",
|
||
"xml": "http://www.w3.org/XML/1998/namespace",
|
||
"xmlns": "http://www.w3.org/2000/xmlns/",
|
||
"math": "http://www.w3.org/1998/Math/MathML"
|
||
};
|
||
var COMPONENT_REGEX = /%COMP%/g;
|
||
var SOURCEMAP_URL_REGEXP = /\/\*#\s*sourceMappingURL=(.+?)\s*\*\//;
|
||
var PROTOCOL_REGEXP = /^https?:/;
|
||
var COMPONENT_VARIABLE = "%COMP%";
|
||
var HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
|
||
var CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
|
||
var REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT = true;
|
||
var REMOVE_STYLES_ON_COMPONENT_DESTROY = new InjectionToken(ngDevMode ? "RemoveStylesOnCompDestroy" : "", {
|
||
providedIn: "root",
|
||
factory: () => REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT
|
||
});
|
||
function shimContentAttribute(componentShortId) {
|
||
return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);
|
||
}
|
||
function shimHostAttribute(componentShortId) {
|
||
return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);
|
||
}
|
||
function shimStylesContent(compId, styles) {
|
||
return styles.map((s) => s.replace(COMPONENT_REGEX, compId));
|
||
}
|
||
function addBaseHrefToCssSourceMap(baseHref, styles) {
|
||
if (!baseHref) {
|
||
return styles;
|
||
}
|
||
const absoluteBaseHrefUrl = new URL(baseHref, "http://localhost");
|
||
return styles.map((cssContent) => {
|
||
if (!cssContent.includes("sourceMappingURL=")) {
|
||
return cssContent;
|
||
}
|
||
return cssContent.replace(SOURCEMAP_URL_REGEXP, (_, sourceMapUrl) => {
|
||
if (sourceMapUrl[0] === "/" || sourceMapUrl.startsWith("data:") || PROTOCOL_REGEXP.test(sourceMapUrl)) {
|
||
return `/*# sourceMappingURL=${sourceMapUrl} */`;
|
||
}
|
||
const {
|
||
pathname: resolvedSourceMapUrl
|
||
} = new URL(sourceMapUrl, absoluteBaseHrefUrl);
|
||
return `/*# sourceMappingURL=${resolvedSourceMapUrl} */`;
|
||
});
|
||
});
|
||
}
|
||
var DomRendererFactory2 = class _DomRendererFactory2 {
|
||
eventManager;
|
||
sharedStylesHost;
|
||
appId;
|
||
removeStylesOnCompDestroy;
|
||
doc;
|
||
platformId;
|
||
ngZone;
|
||
nonce;
|
||
tracingService;
|
||
rendererByCompId = /* @__PURE__ */ new Map();
|
||
defaultRenderer;
|
||
platformIsServer;
|
||
constructor(eventManager, sharedStylesHost, appId, removeStylesOnCompDestroy, doc, platformId, ngZone, nonce = null, tracingService = null) {
|
||
this.eventManager = eventManager;
|
||
this.sharedStylesHost = sharedStylesHost;
|
||
this.appId = appId;
|
||
this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
|
||
this.doc = doc;
|
||
this.platformId = platformId;
|
||
this.ngZone = ngZone;
|
||
this.nonce = nonce;
|
||
this.tracingService = tracingService;
|
||
this.platformIsServer = false;
|
||
this.defaultRenderer = new DefaultDomRenderer2(eventManager, doc, ngZone, this.platformIsServer, this.tracingService);
|
||
}
|
||
createRenderer(element, type) {
|
||
if (!element || !type) {
|
||
return this.defaultRenderer;
|
||
}
|
||
if (false) {
|
||
type = __spreadProps(__spreadValues({}, type), {
|
||
encapsulation: ViewEncapsulation.Emulated
|
||
});
|
||
}
|
||
const renderer = this.getOrCreateRenderer(element, type);
|
||
if (renderer instanceof EmulatedEncapsulationDomRenderer2) {
|
||
renderer.applyToHost(element);
|
||
} else if (renderer instanceof NoneEncapsulationDomRenderer) {
|
||
renderer.applyStyles();
|
||
}
|
||
return renderer;
|
||
}
|
||
getOrCreateRenderer(element, type) {
|
||
const rendererByCompId = this.rendererByCompId;
|
||
let renderer = rendererByCompId.get(type.id);
|
||
if (!renderer) {
|
||
const doc = this.doc;
|
||
const ngZone = this.ngZone;
|
||
const eventManager = this.eventManager;
|
||
const sharedStylesHost = this.sharedStylesHost;
|
||
const removeStylesOnCompDestroy = this.removeStylesOnCompDestroy;
|
||
const platformIsServer = this.platformIsServer;
|
||
const tracingService = this.tracingService;
|
||
switch (type.encapsulation) {
|
||
case ViewEncapsulation.Emulated:
|
||
renderer = new EmulatedEncapsulationDomRenderer2(eventManager, sharedStylesHost, type, this.appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService);
|
||
break;
|
||
case ViewEncapsulation.ShadowDom:
|
||
return new ShadowDomRenderer(eventManager, sharedStylesHost, element, type, doc, ngZone, this.nonce, platformIsServer, tracingService);
|
||
default:
|
||
renderer = new NoneEncapsulationDomRenderer(eventManager, sharedStylesHost, type, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService);
|
||
break;
|
||
}
|
||
rendererByCompId.set(type.id, renderer);
|
||
}
|
||
return renderer;
|
||
}
|
||
ngOnDestroy() {
|
||
this.rendererByCompId.clear();
|
||
}
|
||
/**
|
||
* Used during HMR to clear any cached data about a component.
|
||
* @param componentId ID of the component that is being replaced.
|
||
*/
|
||
componentReplaced(componentId) {
|
||
this.rendererByCompId.delete(componentId);
|
||
}
|
||
static ɵfac = function DomRendererFactory2_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _DomRendererFactory2)(ɵɵinject(EventManager), ɵɵinject(SharedStylesHost), ɵɵinject(APP_ID), ɵɵinject(REMOVE_STYLES_ON_COMPONENT_DESTROY), ɵɵinject(DOCUMENT), ɵɵinject(PLATFORM_ID), ɵɵinject(NgZone), ɵɵinject(CSP_NONCE), ɵɵinject(TracingService, 8));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _DomRendererFactory2,
|
||
factory: _DomRendererFactory2.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomRendererFactory2, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: EventManager
|
||
}, {
|
||
type: SharedStylesHost
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [APP_ID]
|
||
}]
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [REMOVE_STYLES_ON_COMPONENT_DESTROY]
|
||
}]
|
||
}, {
|
||
type: Document,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [DOCUMENT]
|
||
}]
|
||
}, {
|
||
type: Object,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [PLATFORM_ID]
|
||
}]
|
||
}, {
|
||
type: NgZone
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [CSP_NONCE]
|
||
}]
|
||
}, {
|
||
type: TracingService,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [TracingService]
|
||
}, {
|
||
type: Optional
|
||
}]
|
||
}], null);
|
||
})();
|
||
var DefaultDomRenderer2 = class {
|
||
eventManager;
|
||
doc;
|
||
ngZone;
|
||
platformIsServer;
|
||
tracingService;
|
||
data = /* @__PURE__ */ Object.create(null);
|
||
/**
|
||
* By default this renderer throws when encountering synthetic properties
|
||
* This can be disabled for example by the AsyncAnimationRendererFactory
|
||
*/
|
||
throwOnSyntheticProps = true;
|
||
constructor(eventManager, doc, ngZone, platformIsServer, tracingService) {
|
||
this.eventManager = eventManager;
|
||
this.doc = doc;
|
||
this.ngZone = ngZone;
|
||
this.platformIsServer = platformIsServer;
|
||
this.tracingService = tracingService;
|
||
}
|
||
destroy() {
|
||
}
|
||
destroyNode = null;
|
||
createElement(name, namespace) {
|
||
if (namespace) {
|
||
return this.doc.createElementNS(NAMESPACE_URIS[namespace] || namespace, name);
|
||
}
|
||
return this.doc.createElement(name);
|
||
}
|
||
createComment(value) {
|
||
return this.doc.createComment(value);
|
||
}
|
||
createText(value) {
|
||
return this.doc.createTextNode(value);
|
||
}
|
||
appendChild(parent, newChild) {
|
||
const targetParent = isTemplateNode(parent) ? parent.content : parent;
|
||
targetParent.appendChild(newChild);
|
||
}
|
||
insertBefore(parent, newChild, refChild) {
|
||
if (parent) {
|
||
const targetParent = isTemplateNode(parent) ? parent.content : parent;
|
||
targetParent.insertBefore(newChild, refChild);
|
||
}
|
||
}
|
||
removeChild(_parent, oldChild) {
|
||
oldChild.remove();
|
||
}
|
||
selectRootElement(selectorOrNode, preserveContent) {
|
||
let el = typeof selectorOrNode === "string" ? this.doc.querySelector(selectorOrNode) : selectorOrNode;
|
||
if (!el) {
|
||
throw new RuntimeError(-5104, (typeof ngDevMode === "undefined" || ngDevMode) && `The selector "${selectorOrNode}" did not match any elements`);
|
||
}
|
||
if (!preserveContent) {
|
||
el.textContent = "";
|
||
}
|
||
return el;
|
||
}
|
||
parentNode(node) {
|
||
return node.parentNode;
|
||
}
|
||
nextSibling(node) {
|
||
return node.nextSibling;
|
||
}
|
||
setAttribute(el, name, value, namespace) {
|
||
if (namespace) {
|
||
name = namespace + ":" + name;
|
||
const namespaceUri = NAMESPACE_URIS[namespace];
|
||
if (namespaceUri) {
|
||
el.setAttributeNS(namespaceUri, name, value);
|
||
} else {
|
||
el.setAttribute(name, value);
|
||
}
|
||
} else {
|
||
el.setAttribute(name, value);
|
||
}
|
||
}
|
||
removeAttribute(el, name, namespace) {
|
||
if (namespace) {
|
||
const namespaceUri = NAMESPACE_URIS[namespace];
|
||
if (namespaceUri) {
|
||
el.removeAttributeNS(namespaceUri, name);
|
||
} else {
|
||
el.removeAttribute(`${namespace}:${name}`);
|
||
}
|
||
} else {
|
||
el.removeAttribute(name);
|
||
}
|
||
}
|
||
addClass(el, name) {
|
||
el.classList.add(name);
|
||
}
|
||
removeClass(el, name) {
|
||
el.classList.remove(name);
|
||
}
|
||
setStyle(el, style, value, flags) {
|
||
if (flags & (RendererStyleFlags2.DashCase | RendererStyleFlags2.Important)) {
|
||
el.style.setProperty(style, value, flags & RendererStyleFlags2.Important ? "important" : "");
|
||
} else {
|
||
el.style[style] = value;
|
||
}
|
||
}
|
||
removeStyle(el, style, flags) {
|
||
if (flags & RendererStyleFlags2.DashCase) {
|
||
el.style.removeProperty(style);
|
||
} else {
|
||
el.style[style] = "";
|
||
}
|
||
}
|
||
setProperty(el, name, value) {
|
||
if (el == null) {
|
||
return;
|
||
}
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(name, "property");
|
||
el[name] = value;
|
||
}
|
||
setValue(node, value) {
|
||
node.nodeValue = value;
|
||
}
|
||
listen(target, event, callback, options) {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(event, "listener");
|
||
if (typeof target === "string") {
|
||
target = getDOM().getGlobalEventTarget(this.doc, target);
|
||
if (!target) {
|
||
throw new RuntimeError(5102, (typeof ngDevMode === "undefined" || ngDevMode) && `Unsupported event target ${target} for event ${event}`);
|
||
}
|
||
}
|
||
let wrappedCallback = this.decoratePreventDefault(callback);
|
||
if (this.tracingService?.wrapEventListener) {
|
||
wrappedCallback = this.tracingService.wrapEventListener(target, event, wrappedCallback);
|
||
}
|
||
return this.eventManager.addEventListener(target, event, wrappedCallback, options);
|
||
}
|
||
decoratePreventDefault(eventHandler) {
|
||
return (event) => {
|
||
if (event === "__ngUnwrap__") {
|
||
return eventHandler;
|
||
}
|
||
const allowDefaultBehavior = false ? this.ngZone.runGuarded(() => eventHandler(event)) : eventHandler(event);
|
||
if (allowDefaultBehavior === false) {
|
||
event.preventDefault();
|
||
}
|
||
return void 0;
|
||
};
|
||
}
|
||
};
|
||
var AT_CHARCODE = (() => "@".charCodeAt(0))();
|
||
function checkNoSyntheticProp(name, nameKind) {
|
||
if (name.charCodeAt(0) === AT_CHARCODE) {
|
||
throw new RuntimeError(5105, `Unexpected synthetic ${nameKind} ${name} found. Please make sure that:
|
||
- Make sure \`provideAnimationsAsync()\`, \`provideAnimations()\` or \`provideNoopAnimations()\` call was added to a list of providers used to bootstrap an application.
|
||
- There is a corresponding animation configuration named \`${name}\` defined in the \`animations\` field of the \`@Component\` decorator (see https://angular.dev/api/core/Component#animations).`);
|
||
}
|
||
}
|
||
function isTemplateNode(node) {
|
||
return node.tagName === "TEMPLATE" && node.content !== void 0;
|
||
}
|
||
var ShadowDomRenderer = class extends DefaultDomRenderer2 {
|
||
sharedStylesHost;
|
||
hostEl;
|
||
shadowRoot;
|
||
constructor(eventManager, sharedStylesHost, hostEl, component, doc, ngZone, nonce, platformIsServer, tracingService) {
|
||
super(eventManager, doc, ngZone, platformIsServer, tracingService);
|
||
this.sharedStylesHost = sharedStylesHost;
|
||
this.hostEl = hostEl;
|
||
this.shadowRoot = hostEl.attachShadow({
|
||
mode: "open"
|
||
});
|
||
this.sharedStylesHost.addHost(this.shadowRoot);
|
||
let styles = component.styles;
|
||
if (ngDevMode) {
|
||
const baseHref = getDOM().getBaseHref(doc) ?? "";
|
||
styles = addBaseHrefToCssSourceMap(baseHref, styles);
|
||
}
|
||
styles = shimStylesContent(component.id, styles);
|
||
for (const style of styles) {
|
||
const styleEl = document.createElement("style");
|
||
if (nonce) {
|
||
styleEl.setAttribute("nonce", nonce);
|
||
}
|
||
styleEl.textContent = style;
|
||
this.shadowRoot.appendChild(styleEl);
|
||
}
|
||
const styleUrls = component.getExternalStyles?.();
|
||
if (styleUrls) {
|
||
for (const styleUrl of styleUrls) {
|
||
const linkEl = createLinkElement(styleUrl, doc);
|
||
if (nonce) {
|
||
linkEl.setAttribute("nonce", nonce);
|
||
}
|
||
this.shadowRoot.appendChild(linkEl);
|
||
}
|
||
}
|
||
}
|
||
nodeOrShadowRoot(node) {
|
||
return node === this.hostEl ? this.shadowRoot : node;
|
||
}
|
||
appendChild(parent, newChild) {
|
||
return super.appendChild(this.nodeOrShadowRoot(parent), newChild);
|
||
}
|
||
insertBefore(parent, newChild, refChild) {
|
||
return super.insertBefore(this.nodeOrShadowRoot(parent), newChild, refChild);
|
||
}
|
||
removeChild(_parent, oldChild) {
|
||
return super.removeChild(null, oldChild);
|
||
}
|
||
parentNode(node) {
|
||
return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));
|
||
}
|
||
destroy() {
|
||
this.sharedStylesHost.removeHost(this.shadowRoot);
|
||
}
|
||
};
|
||
var NoneEncapsulationDomRenderer = class extends DefaultDomRenderer2 {
|
||
sharedStylesHost;
|
||
removeStylesOnCompDestroy;
|
||
styles;
|
||
styleUrls;
|
||
constructor(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService, compId) {
|
||
super(eventManager, doc, ngZone, platformIsServer, tracingService);
|
||
this.sharedStylesHost = sharedStylesHost;
|
||
this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
|
||
let styles = component.styles;
|
||
if (ngDevMode) {
|
||
const baseHref = getDOM().getBaseHref(doc) ?? "";
|
||
styles = addBaseHrefToCssSourceMap(baseHref, styles);
|
||
}
|
||
this.styles = compId ? shimStylesContent(compId, styles) : styles;
|
||
this.styleUrls = component.getExternalStyles?.(compId);
|
||
}
|
||
applyStyles() {
|
||
this.sharedStylesHost.addStyles(this.styles, this.styleUrls);
|
||
}
|
||
destroy() {
|
||
if (!this.removeStylesOnCompDestroy) {
|
||
return;
|
||
}
|
||
this.sharedStylesHost.removeStyles(this.styles, this.styleUrls);
|
||
}
|
||
};
|
||
var EmulatedEncapsulationDomRenderer2 = class extends NoneEncapsulationDomRenderer {
|
||
contentAttr;
|
||
hostAttr;
|
||
constructor(eventManager, sharedStylesHost, component, appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService) {
|
||
const compId = appId + "-" + component.id;
|
||
super(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService, compId);
|
||
this.contentAttr = shimContentAttribute(compId);
|
||
this.hostAttr = shimHostAttribute(compId);
|
||
}
|
||
applyToHost(element) {
|
||
this.applyStyles();
|
||
this.setAttribute(element, this.hostAttr, "");
|
||
}
|
||
createElement(parent, name) {
|
||
const el = super.createElement(parent, name);
|
||
super.setAttribute(el, this.contentAttr, "");
|
||
return el;
|
||
}
|
||
};
|
||
|
||
// node_modules/@angular/platform-browser/fesm2022/browser-DKgH74dt.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 DomEventsPlugin = class _DomEventsPlugin extends EventManagerPlugin {
|
||
constructor(doc) {
|
||
super(doc);
|
||
}
|
||
// This plugin should come last in the list of plugins, because it accepts all
|
||
// events.
|
||
supports(eventName) {
|
||
return true;
|
||
}
|
||
addEventListener(element, eventName, handler, options) {
|
||
element.addEventListener(eventName, handler, options);
|
||
return () => this.removeEventListener(element, eventName, handler, options);
|
||
}
|
||
removeEventListener(target, eventName, callback, options) {
|
||
return target.removeEventListener(eventName, callback, options);
|
||
}
|
||
static ɵfac = function DomEventsPlugin_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _DomEventsPlugin)(ɵɵinject(DOCUMENT));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _DomEventsPlugin,
|
||
factory: _DomEventsPlugin.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomEventsPlugin, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [DOCUMENT]
|
||
}]
|
||
}], 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) {
|
||
return internalCreateApplication(__spreadValues({
|
||
rootComponent
|
||
}, createProvidersConfig(options)));
|
||
}
|
||
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/common/fesm2022/module-CBsxN_3E.mjs
|
||
var HttpHandler = class {
|
||
};
|
||
var HttpBackend = class {
|
||
};
|
||
var HttpHeaders = class _HttpHeaders {
|
||
/**
|
||
* Internal map of lowercase header names to values.
|
||
*/
|
||
headers;
|
||
/**
|
||
* Internal map of lowercased header names to the normalized
|
||
* form of the name (the form seen first).
|
||
*/
|
||
normalizedNames = /* @__PURE__ */ new Map();
|
||
/**
|
||
* Complete the lazy initialization of this object (needed before reading).
|
||
*/
|
||
lazyInit;
|
||
/**
|
||
* Queued updates to be materialized the next initialization.
|
||
*/
|
||
lazyUpdate = null;
|
||
/** Constructs a new HTTP header object with the given values.*/
|
||
constructor(headers) {
|
||
if (!headers) {
|
||
this.headers = /* @__PURE__ */ new Map();
|
||
} else if (typeof headers === "string") {
|
||
this.lazyInit = () => {
|
||
this.headers = /* @__PURE__ */ new Map();
|
||
headers.split("\n").forEach((line) => {
|
||
const index = line.indexOf(":");
|
||
if (index > 0) {
|
||
const name = line.slice(0, index);
|
||
const value = line.slice(index + 1).trim();
|
||
this.addHeaderEntry(name, value);
|
||
}
|
||
});
|
||
};
|
||
} else if (typeof Headers !== "undefined" && headers instanceof Headers) {
|
||
this.headers = /* @__PURE__ */ new Map();
|
||
headers.forEach((value, name) => {
|
||
this.addHeaderEntry(name, value);
|
||
});
|
||
} else {
|
||
this.lazyInit = () => {
|
||
if (typeof ngDevMode === "undefined" || ngDevMode) {
|
||
assertValidHeaders(headers);
|
||
}
|
||
this.headers = /* @__PURE__ */ new Map();
|
||
Object.entries(headers).forEach(([name, values]) => {
|
||
this.setHeaderEntries(name, values);
|
||
});
|
||
};
|
||
}
|
||
}
|
||
/**
|
||
* Checks for existence of a given header.
|
||
*
|
||
* @param name The header name to check for existence.
|
||
*
|
||
* @returns True if the header exists, false otherwise.
|
||
*/
|
||
has(name) {
|
||
this.init();
|
||
return this.headers.has(name.toLowerCase());
|
||
}
|
||
/**
|
||
* Retrieves the first value of a given header.
|
||
*
|
||
* @param name The header name.
|
||
*
|
||
* @returns The value string if the header exists, null otherwise
|
||
*/
|
||
get(name) {
|
||
this.init();
|
||
const values = this.headers.get(name.toLowerCase());
|
||
return values && values.length > 0 ? values[0] : null;
|
||
}
|
||
/**
|
||
* Retrieves the names of the headers.
|
||
*
|
||
* @returns A list of header names.
|
||
*/
|
||
keys() {
|
||
this.init();
|
||
return Array.from(this.normalizedNames.values());
|
||
}
|
||
/**
|
||
* Retrieves a list of values for a given header.
|
||
*
|
||
* @param name The header name from which to retrieve values.
|
||
*
|
||
* @returns A string of values if the header exists, null otherwise.
|
||
*/
|
||
getAll(name) {
|
||
this.init();
|
||
return this.headers.get(name.toLowerCase()) || null;
|
||
}
|
||
/**
|
||
* Appends a new value to the existing set of values for a header
|
||
* and returns them in a clone of the original instance.
|
||
*
|
||
* @param name The header name for which to append the values.
|
||
* @param value The value to append.
|
||
*
|
||
* @returns A clone of the HTTP headers object with the value appended to the given header.
|
||
*/
|
||
append(name, value) {
|
||
return this.clone({
|
||
name,
|
||
value,
|
||
op: "a"
|
||
});
|
||
}
|
||
/**
|
||
* Sets or modifies a value for a given header in a clone of the original instance.
|
||
* If the header already exists, its value is replaced with the given value
|
||
* in the returned object.
|
||
*
|
||
* @param name The header name.
|
||
* @param value The value or values to set or override for the given header.
|
||
*
|
||
* @returns A clone of the HTTP headers object with the newly set header value.
|
||
*/
|
||
set(name, value) {
|
||
return this.clone({
|
||
name,
|
||
value,
|
||
op: "s"
|
||
});
|
||
}
|
||
/**
|
||
* Deletes values for a given header in a clone of the original instance.
|
||
*
|
||
* @param name The header name.
|
||
* @param value The value or values to delete for the given header.
|
||
*
|
||
* @returns A clone of the HTTP headers object with the given value deleted.
|
||
*/
|
||
delete(name, value) {
|
||
return this.clone({
|
||
name,
|
||
value,
|
||
op: "d"
|
||
});
|
||
}
|
||
maybeSetNormalizedName(name, lcName) {
|
||
if (!this.normalizedNames.has(lcName)) {
|
||
this.normalizedNames.set(lcName, name);
|
||
}
|
||
}
|
||
init() {
|
||
if (!!this.lazyInit) {
|
||
if (this.lazyInit instanceof _HttpHeaders) {
|
||
this.copyFrom(this.lazyInit);
|
||
} else {
|
||
this.lazyInit();
|
||
}
|
||
this.lazyInit = null;
|
||
if (!!this.lazyUpdate) {
|
||
this.lazyUpdate.forEach((update) => this.applyUpdate(update));
|
||
this.lazyUpdate = null;
|
||
}
|
||
}
|
||
}
|
||
copyFrom(other) {
|
||
other.init();
|
||
Array.from(other.headers.keys()).forEach((key) => {
|
||
this.headers.set(key, other.headers.get(key));
|
||
this.normalizedNames.set(key, other.normalizedNames.get(key));
|
||
});
|
||
}
|
||
clone(update) {
|
||
const clone = new _HttpHeaders();
|
||
clone.lazyInit = !!this.lazyInit && this.lazyInit instanceof _HttpHeaders ? this.lazyInit : this;
|
||
clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);
|
||
return clone;
|
||
}
|
||
applyUpdate(update) {
|
||
const key = update.name.toLowerCase();
|
||
switch (update.op) {
|
||
case "a":
|
||
case "s":
|
||
let value = update.value;
|
||
if (typeof value === "string") {
|
||
value = [value];
|
||
}
|
||
if (value.length === 0) {
|
||
return;
|
||
}
|
||
this.maybeSetNormalizedName(update.name, key);
|
||
const base = (update.op === "a" ? this.headers.get(key) : void 0) || [];
|
||
base.push(...value);
|
||
this.headers.set(key, base);
|
||
break;
|
||
case "d":
|
||
const toDelete = update.value;
|
||
if (!toDelete) {
|
||
this.headers.delete(key);
|
||
this.normalizedNames.delete(key);
|
||
} else {
|
||
let existing = this.headers.get(key);
|
||
if (!existing) {
|
||
return;
|
||
}
|
||
existing = existing.filter((value2) => toDelete.indexOf(value2) === -1);
|
||
if (existing.length === 0) {
|
||
this.headers.delete(key);
|
||
this.normalizedNames.delete(key);
|
||
} else {
|
||
this.headers.set(key, existing);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
addHeaderEntry(name, value) {
|
||
const key = name.toLowerCase();
|
||
this.maybeSetNormalizedName(name, key);
|
||
if (this.headers.has(key)) {
|
||
this.headers.get(key).push(value);
|
||
} else {
|
||
this.headers.set(key, [value]);
|
||
}
|
||
}
|
||
setHeaderEntries(name, values) {
|
||
const headerValues = (Array.isArray(values) ? values : [values]).map((value) => value.toString());
|
||
const key = name.toLowerCase();
|
||
this.headers.set(key, headerValues);
|
||
this.maybeSetNormalizedName(name, key);
|
||
}
|
||
/**
|
||
* @internal
|
||
*/
|
||
forEach(fn) {
|
||
this.init();
|
||
Array.from(this.normalizedNames.keys()).forEach((key) => fn(this.normalizedNames.get(key), this.headers.get(key)));
|
||
}
|
||
};
|
||
function assertValidHeaders(headers) {
|
||
for (const [key, value] of Object.entries(headers)) {
|
||
if (!(typeof value === "string" || typeof value === "number") && !Array.isArray(value)) {
|
||
throw new Error(`Unexpected value of the \`${key}\` header provided. Expecting either a string, a number or an array, but got: \`${value}\`.`);
|
||
}
|
||
}
|
||
}
|
||
var HttpUrlEncodingCodec = class {
|
||
/**
|
||
* Encodes a key name for a URL parameter or query-string.
|
||
* @param key The key name.
|
||
* @returns The encoded key name.
|
||
*/
|
||
encodeKey(key) {
|
||
return standardEncoding(key);
|
||
}
|
||
/**
|
||
* Encodes the value of a URL parameter or query-string.
|
||
* @param value The value.
|
||
* @returns The encoded value.
|
||
*/
|
||
encodeValue(value) {
|
||
return standardEncoding(value);
|
||
}
|
||
/**
|
||
* Decodes an encoded URL parameter or query-string key.
|
||
* @param key The encoded key name.
|
||
* @returns The decoded key name.
|
||
*/
|
||
decodeKey(key) {
|
||
return decodeURIComponent(key);
|
||
}
|
||
/**
|
||
* Decodes an encoded URL parameter or query-string value.
|
||
* @param value The encoded value.
|
||
* @returns The decoded value.
|
||
*/
|
||
decodeValue(value) {
|
||
return decodeURIComponent(value);
|
||
}
|
||
};
|
||
function paramParser(rawParams, codec) {
|
||
const map2 = /* @__PURE__ */ new Map();
|
||
if (rawParams.length > 0) {
|
||
const params = rawParams.replace(/^\?/, "").split("&");
|
||
params.forEach((param) => {
|
||
const eqIdx = param.indexOf("=");
|
||
const [key, val] = eqIdx == -1 ? [codec.decodeKey(param), ""] : [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))];
|
||
const list = map2.get(key) || [];
|
||
list.push(val);
|
||
map2.set(key, list);
|
||
});
|
||
}
|
||
return map2;
|
||
}
|
||
var STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
|
||
var STANDARD_ENCODING_REPLACEMENTS = {
|
||
"40": "@",
|
||
"3A": ":",
|
||
"24": "$",
|
||
"2C": ",",
|
||
"3B": ";",
|
||
"3D": "=",
|
||
"3F": "?",
|
||
"2F": "/"
|
||
};
|
||
function standardEncoding(v) {
|
||
return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, (s, t) => STANDARD_ENCODING_REPLACEMENTS[t] ?? s);
|
||
}
|
||
function valueToString(value) {
|
||
return `${value}`;
|
||
}
|
||
var HttpParams = class _HttpParams {
|
||
map;
|
||
encoder;
|
||
updates = null;
|
||
cloneFrom = null;
|
||
constructor(options = {}) {
|
||
this.encoder = options.encoder || new HttpUrlEncodingCodec();
|
||
if (options.fromString) {
|
||
if (options.fromObject) {
|
||
throw new RuntimeError(2805, ngDevMode && "Cannot specify both fromString and fromObject.");
|
||
}
|
||
this.map = paramParser(options.fromString, this.encoder);
|
||
} else if (!!options.fromObject) {
|
||
this.map = /* @__PURE__ */ new Map();
|
||
Object.keys(options.fromObject).forEach((key) => {
|
||
const value = options.fromObject[key];
|
||
const values = Array.isArray(value) ? value.map(valueToString) : [valueToString(value)];
|
||
this.map.set(key, values);
|
||
});
|
||
} else {
|
||
this.map = null;
|
||
}
|
||
}
|
||
/**
|
||
* Reports whether the body includes one or more values for a given parameter.
|
||
* @param param The parameter name.
|
||
* @returns True if the parameter has one or more values,
|
||
* false if it has no value or is not present.
|
||
*/
|
||
has(param) {
|
||
this.init();
|
||
return this.map.has(param);
|
||
}
|
||
/**
|
||
* Retrieves the first value for a parameter.
|
||
* @param param The parameter name.
|
||
* @returns The first value of the given parameter,
|
||
* or `null` if the parameter is not present.
|
||
*/
|
||
get(param) {
|
||
this.init();
|
||
const res = this.map.get(param);
|
||
return !!res ? res[0] : null;
|
||
}
|
||
/**
|
||
* Retrieves all values for a parameter.
|
||
* @param param The parameter name.
|
||
* @returns All values in a string array,
|
||
* or `null` if the parameter not present.
|
||
*/
|
||
getAll(param) {
|
||
this.init();
|
||
return this.map.get(param) || null;
|
||
}
|
||
/**
|
||
* Retrieves all the parameters for this body.
|
||
* @returns The parameter names in a string array.
|
||
*/
|
||
keys() {
|
||
this.init();
|
||
return Array.from(this.map.keys());
|
||
}
|
||
/**
|
||
* Appends a new value to existing values for a parameter.
|
||
* @param param The parameter name.
|
||
* @param value The new value to add.
|
||
* @return A new body with the appended value.
|
||
*/
|
||
append(param, value) {
|
||
return this.clone({
|
||
param,
|
||
value,
|
||
op: "a"
|
||
});
|
||
}
|
||
/**
|
||
* Constructs a new body with appended values for the given parameter name.
|
||
* @param params parameters and values
|
||
* @return A new body with the new value.
|
||
*/
|
||
appendAll(params) {
|
||
const updates = [];
|
||
Object.keys(params).forEach((param) => {
|
||
const value = params[param];
|
||
if (Array.isArray(value)) {
|
||
value.forEach((_value) => {
|
||
updates.push({
|
||
param,
|
||
value: _value,
|
||
op: "a"
|
||
});
|
||
});
|
||
} else {
|
||
updates.push({
|
||
param,
|
||
value,
|
||
op: "a"
|
||
});
|
||
}
|
||
});
|
||
return this.clone(updates);
|
||
}
|
||
/**
|
||
* Replaces the value for a parameter.
|
||
* @param param The parameter name.
|
||
* @param value The new value.
|
||
* @return A new body with the new value.
|
||
*/
|
||
set(param, value) {
|
||
return this.clone({
|
||
param,
|
||
value,
|
||
op: "s"
|
||
});
|
||
}
|
||
/**
|
||
* Removes a given value or all values from a parameter.
|
||
* @param param The parameter name.
|
||
* @param value The value to remove, if provided.
|
||
* @return A new body with the given value removed, or with all values
|
||
* removed if no value is specified.
|
||
*/
|
||
delete(param, value) {
|
||
return this.clone({
|
||
param,
|
||
value,
|
||
op: "d"
|
||
});
|
||
}
|
||
/**
|
||
* Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
|
||
* separated by `&`s.
|
||
*/
|
||
toString() {
|
||
this.init();
|
||
return this.keys().map((key) => {
|
||
const eKey = this.encoder.encodeKey(key);
|
||
return this.map.get(key).map((value) => eKey + "=" + this.encoder.encodeValue(value)).join("&");
|
||
}).filter((param) => param !== "").join("&");
|
||
}
|
||
clone(update) {
|
||
const clone = new _HttpParams({
|
||
encoder: this.encoder
|
||
});
|
||
clone.cloneFrom = this.cloneFrom || this;
|
||
clone.updates = (this.updates || []).concat(update);
|
||
return clone;
|
||
}
|
||
init() {
|
||
if (this.map === null) {
|
||
this.map = /* @__PURE__ */ new Map();
|
||
}
|
||
if (this.cloneFrom !== null) {
|
||
this.cloneFrom.init();
|
||
this.cloneFrom.keys().forEach((key) => this.map.set(key, this.cloneFrom.map.get(key)));
|
||
this.updates.forEach((update) => {
|
||
switch (update.op) {
|
||
case "a":
|
||
case "s":
|
||
const base = (update.op === "a" ? this.map.get(update.param) : void 0) || [];
|
||
base.push(valueToString(update.value));
|
||
this.map.set(update.param, base);
|
||
break;
|
||
case "d":
|
||
if (update.value !== void 0) {
|
||
let base2 = this.map.get(update.param) || [];
|
||
const idx = base2.indexOf(valueToString(update.value));
|
||
if (idx !== -1) {
|
||
base2.splice(idx, 1);
|
||
}
|
||
if (base2.length > 0) {
|
||
this.map.set(update.param, base2);
|
||
} else {
|
||
this.map.delete(update.param);
|
||
}
|
||
} else {
|
||
this.map.delete(update.param);
|
||
break;
|
||
}
|
||
}
|
||
});
|
||
this.cloneFrom = this.updates = null;
|
||
}
|
||
}
|
||
};
|
||
var HttpContext = class {
|
||
map = /* @__PURE__ */ new Map();
|
||
/**
|
||
* Store a value in the context. If a value is already present it will be overwritten.
|
||
*
|
||
* @param token The reference to an instance of `HttpContextToken`.
|
||
* @param value The value to store.
|
||
*
|
||
* @returns A reference to itself for easy chaining.
|
||
*/
|
||
set(token, value) {
|
||
this.map.set(token, value);
|
||
return this;
|
||
}
|
||
/**
|
||
* Retrieve the value associated with the given token.
|
||
*
|
||
* @param token The reference to an instance of `HttpContextToken`.
|
||
*
|
||
* @returns The stored value or default if one is defined.
|
||
*/
|
||
get(token) {
|
||
if (!this.map.has(token)) {
|
||
this.map.set(token, token.defaultValue());
|
||
}
|
||
return this.map.get(token);
|
||
}
|
||
/**
|
||
* Delete the value associated with the given token.
|
||
*
|
||
* @param token The reference to an instance of `HttpContextToken`.
|
||
*
|
||
* @returns A reference to itself for easy chaining.
|
||
*/
|
||
delete(token) {
|
||
this.map.delete(token);
|
||
return this;
|
||
}
|
||
/**
|
||
* Checks for existence of a given token.
|
||
*
|
||
* @param token The reference to an instance of `HttpContextToken`.
|
||
*
|
||
* @returns True if the token exists, false otherwise.
|
||
*/
|
||
has(token) {
|
||
return this.map.has(token);
|
||
}
|
||
/**
|
||
* @returns a list of tokens currently stored in the context.
|
||
*/
|
||
keys() {
|
||
return this.map.keys();
|
||
}
|
||
};
|
||
function mightHaveBody(method) {
|
||
switch (method) {
|
||
case "DELETE":
|
||
case "GET":
|
||
case "HEAD":
|
||
case "OPTIONS":
|
||
case "JSONP":
|
||
return false;
|
||
default:
|
||
return true;
|
||
}
|
||
}
|
||
function isArrayBuffer(value) {
|
||
return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer;
|
||
}
|
||
function isBlob(value) {
|
||
return typeof Blob !== "undefined" && value instanceof Blob;
|
||
}
|
||
function isFormData(value) {
|
||
return typeof FormData !== "undefined" && value instanceof FormData;
|
||
}
|
||
function isUrlSearchParams(value) {
|
||
return typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams;
|
||
}
|
||
var CONTENT_TYPE_HEADER = "Content-Type";
|
||
var ACCEPT_HEADER = "Accept";
|
||
var X_REQUEST_URL_HEADER = "X-Request-URL";
|
||
var TEXT_CONTENT_TYPE = "text/plain";
|
||
var JSON_CONTENT_TYPE = "application/json";
|
||
var ACCEPT_HEADER_VALUE = `${JSON_CONTENT_TYPE}, ${TEXT_CONTENT_TYPE}, */*`;
|
||
var HttpRequest = class _HttpRequest {
|
||
url;
|
||
/**
|
||
* The request body, or `null` if one isn't set.
|
||
*
|
||
* Bodies are not enforced to be immutable, as they can include a reference to any
|
||
* user-defined data type. However, interceptors should take care to preserve
|
||
* idempotence by treating them as such.
|
||
*/
|
||
body = null;
|
||
/**
|
||
* Outgoing headers for this request.
|
||
*/
|
||
headers;
|
||
/**
|
||
* Shared and mutable context that can be used by interceptors
|
||
*/
|
||
context;
|
||
/**
|
||
* Whether this request should be made in a way that exposes progress events.
|
||
*
|
||
* Progress events are expensive (change detection runs on each event) and so
|
||
* they should only be requested if the consumer intends to monitor them.
|
||
*
|
||
* Note: The `FetchBackend` doesn't support progress report on uploads.
|
||
*/
|
||
reportProgress = false;
|
||
/**
|
||
* Whether this request should be sent with outgoing credentials (cookies).
|
||
*/
|
||
withCredentials = false;
|
||
/**
|
||
* When using the fetch implementation and set to `true`, the browser will not abort the associated request if the page that initiated it is unloaded before the request is complete.
|
||
*/
|
||
keepalive = false;
|
||
/**
|
||
* The expected response type of the server.
|
||
*
|
||
* This is used to parse the response appropriately before returning it to
|
||
* the requestee.
|
||
*/
|
||
responseType = "json";
|
||
/**
|
||
* The outgoing HTTP request method.
|
||
*/
|
||
method;
|
||
/**
|
||
* Outgoing URL parameters.
|
||
*
|
||
* To pass a string representation of HTTP parameters in the URL-query-string format,
|
||
* the `HttpParamsOptions`' `fromString` may be used. For example:
|
||
*
|
||
* ```ts
|
||
* new HttpParams({fromString: 'angular=awesome'})
|
||
* ```
|
||
*/
|
||
params;
|
||
/**
|
||
* The outgoing URL with all URL parameters set.
|
||
*/
|
||
urlWithParams;
|
||
/**
|
||
* The HttpTransferCache option for the request
|
||
*/
|
||
transferCache;
|
||
constructor(method, url, third, fourth) {
|
||
this.url = url;
|
||
this.method = method.toUpperCase();
|
||
let options;
|
||
if (mightHaveBody(this.method) || !!fourth) {
|
||
this.body = third !== void 0 ? third : null;
|
||
options = fourth;
|
||
} else {
|
||
options = third;
|
||
}
|
||
if (options) {
|
||
this.reportProgress = !!options.reportProgress;
|
||
this.withCredentials = !!options.withCredentials;
|
||
this.keepalive = !!options.keepalive;
|
||
if (!!options.responseType) {
|
||
this.responseType = options.responseType;
|
||
}
|
||
if (!!options.headers) {
|
||
this.headers = options.headers;
|
||
}
|
||
if (!!options.context) {
|
||
this.context = options.context;
|
||
}
|
||
if (!!options.params) {
|
||
this.params = options.params;
|
||
}
|
||
this.transferCache = options.transferCache;
|
||
}
|
||
this.headers ??= new HttpHeaders();
|
||
this.context ??= new HttpContext();
|
||
if (!this.params) {
|
||
this.params = new HttpParams();
|
||
this.urlWithParams = url;
|
||
} else {
|
||
const params = this.params.toString();
|
||
if (params.length === 0) {
|
||
this.urlWithParams = url;
|
||
} else {
|
||
const qIdx = url.indexOf("?");
|
||
const sep = qIdx === -1 ? "?" : qIdx < url.length - 1 ? "&" : "";
|
||
this.urlWithParams = url + sep + params;
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* Transform the free-form body into a serialized format suitable for
|
||
* transmission to the server.
|
||
*/
|
||
serializeBody() {
|
||
if (this.body === null) {
|
||
return null;
|
||
}
|
||
if (typeof this.body === "string" || isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) || isUrlSearchParams(this.body)) {
|
||
return this.body;
|
||
}
|
||
if (this.body instanceof HttpParams) {
|
||
return this.body.toString();
|
||
}
|
||
if (typeof this.body === "object" || typeof this.body === "boolean" || Array.isArray(this.body)) {
|
||
return JSON.stringify(this.body);
|
||
}
|
||
return this.body.toString();
|
||
}
|
||
/**
|
||
* Examine the body and attempt to infer an appropriate MIME type
|
||
* for it.
|
||
*
|
||
* If no such type can be inferred, this method will return `null`.
|
||
*/
|
||
detectContentTypeHeader() {
|
||
if (this.body === null) {
|
||
return null;
|
||
}
|
||
if (isFormData(this.body)) {
|
||
return null;
|
||
}
|
||
if (isBlob(this.body)) {
|
||
return this.body.type || null;
|
||
}
|
||
if (isArrayBuffer(this.body)) {
|
||
return null;
|
||
}
|
||
if (typeof this.body === "string") {
|
||
return TEXT_CONTENT_TYPE;
|
||
}
|
||
if (this.body instanceof HttpParams) {
|
||
return "application/x-www-form-urlencoded;charset=UTF-8";
|
||
}
|
||
if (typeof this.body === "object" || typeof this.body === "number" || typeof this.body === "boolean") {
|
||
return JSON_CONTENT_TYPE;
|
||
}
|
||
return null;
|
||
}
|
||
clone(update = {}) {
|
||
const method = update.method || this.method;
|
||
const url = update.url || this.url;
|
||
const responseType = update.responseType || this.responseType;
|
||
const keepalive = update.keepalive ?? this.keepalive;
|
||
const transferCache = update.transferCache ?? this.transferCache;
|
||
const body = update.body !== void 0 ? update.body : this.body;
|
||
const withCredentials = update.withCredentials ?? this.withCredentials;
|
||
const reportProgress = update.reportProgress ?? this.reportProgress;
|
||
let headers = update.headers || this.headers;
|
||
let params = update.params || this.params;
|
||
const context = update.context ?? this.context;
|
||
if (update.setHeaders !== void 0) {
|
||
headers = Object.keys(update.setHeaders).reduce((headers2, name) => headers2.set(name, update.setHeaders[name]), headers);
|
||
}
|
||
if (update.setParams) {
|
||
params = Object.keys(update.setParams).reduce((params2, param) => params2.set(param, update.setParams[param]), params);
|
||
}
|
||
return new _HttpRequest(method, url, body, {
|
||
params,
|
||
headers,
|
||
context,
|
||
reportProgress,
|
||
responseType,
|
||
withCredentials,
|
||
transferCache,
|
||
keepalive
|
||
});
|
||
}
|
||
};
|
||
var HttpEventType;
|
||
(function(HttpEventType2) {
|
||
HttpEventType2[HttpEventType2["Sent"] = 0] = "Sent";
|
||
HttpEventType2[HttpEventType2["UploadProgress"] = 1] = "UploadProgress";
|
||
HttpEventType2[HttpEventType2["ResponseHeader"] = 2] = "ResponseHeader";
|
||
HttpEventType2[HttpEventType2["DownloadProgress"] = 3] = "DownloadProgress";
|
||
HttpEventType2[HttpEventType2["Response"] = 4] = "Response";
|
||
HttpEventType2[HttpEventType2["User"] = 5] = "User";
|
||
})(HttpEventType || (HttpEventType = {}));
|
||
var HttpResponseBase = class {
|
||
/**
|
||
* All response headers.
|
||
*/
|
||
headers;
|
||
/**
|
||
* Response status code.
|
||
*/
|
||
status;
|
||
/**
|
||
* Textual description of response status code, defaults to OK.
|
||
*
|
||
* Do not depend on this.
|
||
*/
|
||
statusText;
|
||
/**
|
||
* URL of the resource retrieved, or null if not available.
|
||
*/
|
||
url;
|
||
/**
|
||
* Whether the status code falls in the 2xx range.
|
||
*/
|
||
ok;
|
||
/**
|
||
* Type of the response, narrowed to either the full response or the header.
|
||
*/
|
||
type;
|
||
/**
|
||
* Super-constructor for all responses.
|
||
*
|
||
* The single parameter accepted is an initialization hash. Any properties
|
||
* of the response passed there will override the default values.
|
||
*/
|
||
constructor(init, defaultStatus = 200, defaultStatusText = "OK") {
|
||
this.headers = init.headers || new HttpHeaders();
|
||
this.status = init.status !== void 0 ? init.status : defaultStatus;
|
||
this.statusText = init.statusText || defaultStatusText;
|
||
this.url = init.url || null;
|
||
this.ok = this.status >= 200 && this.status < 300;
|
||
}
|
||
};
|
||
var HttpHeaderResponse = class _HttpHeaderResponse extends HttpResponseBase {
|
||
/**
|
||
* Create a new `HttpHeaderResponse` with the given parameters.
|
||
*/
|
||
constructor(init = {}) {
|
||
super(init);
|
||
}
|
||
type = HttpEventType.ResponseHeader;
|
||
/**
|
||
* Copy this `HttpHeaderResponse`, overriding its contents with the
|
||
* given parameter hash.
|
||
*/
|
||
clone(update = {}) {
|
||
return new _HttpHeaderResponse({
|
||
headers: update.headers || this.headers,
|
||
status: update.status !== void 0 ? update.status : this.status,
|
||
statusText: update.statusText || this.statusText,
|
||
url: update.url || this.url || void 0
|
||
});
|
||
}
|
||
};
|
||
var HttpResponse = class _HttpResponse extends HttpResponseBase {
|
||
/**
|
||
* The response body, or `null` if one was not returned.
|
||
*/
|
||
body;
|
||
/**
|
||
* Construct a new `HttpResponse`.
|
||
*/
|
||
constructor(init = {}) {
|
||
super(init);
|
||
this.body = init.body !== void 0 ? init.body : null;
|
||
}
|
||
type = HttpEventType.Response;
|
||
clone(update = {}) {
|
||
return new _HttpResponse({
|
||
body: update.body !== void 0 ? update.body : this.body,
|
||
headers: update.headers || this.headers,
|
||
status: update.status !== void 0 ? update.status : this.status,
|
||
statusText: update.statusText || this.statusText,
|
||
url: update.url || this.url || void 0
|
||
});
|
||
}
|
||
};
|
||
var HttpErrorResponse = class extends HttpResponseBase {
|
||
name = "HttpErrorResponse";
|
||
message;
|
||
error;
|
||
/**
|
||
* Errors are never okay, even when the status code is in the 2xx success range.
|
||
*/
|
||
ok = false;
|
||
constructor(init) {
|
||
super(init, 0, "Unknown Error");
|
||
if (this.status >= 200 && this.status < 300) {
|
||
this.message = `Http failure during parsing for ${init.url || "(unknown url)"}`;
|
||
} else {
|
||
this.message = `Http failure response for ${init.url || "(unknown url)"}: ${init.status} ${init.statusText}`;
|
||
}
|
||
this.error = init.error || null;
|
||
}
|
||
};
|
||
var HTTP_STATUS_CODE_OK = 200;
|
||
var HTTP_STATUS_CODE_NO_CONTENT = 204;
|
||
var HttpStatusCode;
|
||
(function(HttpStatusCode2) {
|
||
HttpStatusCode2[HttpStatusCode2["Continue"] = 100] = "Continue";
|
||
HttpStatusCode2[HttpStatusCode2["SwitchingProtocols"] = 101] = "SwitchingProtocols";
|
||
HttpStatusCode2[HttpStatusCode2["Processing"] = 102] = "Processing";
|
||
HttpStatusCode2[HttpStatusCode2["EarlyHints"] = 103] = "EarlyHints";
|
||
HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
|
||
HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
|
||
HttpStatusCode2[HttpStatusCode2["Accepted"] = 202] = "Accepted";
|
||
HttpStatusCode2[HttpStatusCode2["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
|
||
HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
|
||
HttpStatusCode2[HttpStatusCode2["ResetContent"] = 205] = "ResetContent";
|
||
HttpStatusCode2[HttpStatusCode2["PartialContent"] = 206] = "PartialContent";
|
||
HttpStatusCode2[HttpStatusCode2["MultiStatus"] = 207] = "MultiStatus";
|
||
HttpStatusCode2[HttpStatusCode2["AlreadyReported"] = 208] = "AlreadyReported";
|
||
HttpStatusCode2[HttpStatusCode2["ImUsed"] = 226] = "ImUsed";
|
||
HttpStatusCode2[HttpStatusCode2["MultipleChoices"] = 300] = "MultipleChoices";
|
||
HttpStatusCode2[HttpStatusCode2["MovedPermanently"] = 301] = "MovedPermanently";
|
||
HttpStatusCode2[HttpStatusCode2["Found"] = 302] = "Found";
|
||
HttpStatusCode2[HttpStatusCode2["SeeOther"] = 303] = "SeeOther";
|
||
HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
|
||
HttpStatusCode2[HttpStatusCode2["UseProxy"] = 305] = "UseProxy";
|
||
HttpStatusCode2[HttpStatusCode2["Unused"] = 306] = "Unused";
|
||
HttpStatusCode2[HttpStatusCode2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
|
||
HttpStatusCode2[HttpStatusCode2["PermanentRedirect"] = 308] = "PermanentRedirect";
|
||
HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
|
||
HttpStatusCode2[HttpStatusCode2["Unauthorized"] = 401] = "Unauthorized";
|
||
HttpStatusCode2[HttpStatusCode2["PaymentRequired"] = 402] = "PaymentRequired";
|
||
HttpStatusCode2[HttpStatusCode2["Forbidden"] = 403] = "Forbidden";
|
||
HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
|
||
HttpStatusCode2[HttpStatusCode2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
|
||
HttpStatusCode2[HttpStatusCode2["NotAcceptable"] = 406] = "NotAcceptable";
|
||
HttpStatusCode2[HttpStatusCode2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
|
||
HttpStatusCode2[HttpStatusCode2["RequestTimeout"] = 408] = "RequestTimeout";
|
||
HttpStatusCode2[HttpStatusCode2["Conflict"] = 409] = "Conflict";
|
||
HttpStatusCode2[HttpStatusCode2["Gone"] = 410] = "Gone";
|
||
HttpStatusCode2[HttpStatusCode2["LengthRequired"] = 411] = "LengthRequired";
|
||
HttpStatusCode2[HttpStatusCode2["PreconditionFailed"] = 412] = "PreconditionFailed";
|
||
HttpStatusCode2[HttpStatusCode2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
|
||
HttpStatusCode2[HttpStatusCode2["UriTooLong"] = 414] = "UriTooLong";
|
||
HttpStatusCode2[HttpStatusCode2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
|
||
HttpStatusCode2[HttpStatusCode2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
|
||
HttpStatusCode2[HttpStatusCode2["ExpectationFailed"] = 417] = "ExpectationFailed";
|
||
HttpStatusCode2[HttpStatusCode2["ImATeapot"] = 418] = "ImATeapot";
|
||
HttpStatusCode2[HttpStatusCode2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
|
||
HttpStatusCode2[HttpStatusCode2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
|
||
HttpStatusCode2[HttpStatusCode2["Locked"] = 423] = "Locked";
|
||
HttpStatusCode2[HttpStatusCode2["FailedDependency"] = 424] = "FailedDependency";
|
||
HttpStatusCode2[HttpStatusCode2["TooEarly"] = 425] = "TooEarly";
|
||
HttpStatusCode2[HttpStatusCode2["UpgradeRequired"] = 426] = "UpgradeRequired";
|
||
HttpStatusCode2[HttpStatusCode2["PreconditionRequired"] = 428] = "PreconditionRequired";
|
||
HttpStatusCode2[HttpStatusCode2["TooManyRequests"] = 429] = "TooManyRequests";
|
||
HttpStatusCode2[HttpStatusCode2["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
|
||
HttpStatusCode2[HttpStatusCode2["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
|
||
HttpStatusCode2[HttpStatusCode2["InternalServerError"] = 500] = "InternalServerError";
|
||
HttpStatusCode2[HttpStatusCode2["NotImplemented"] = 501] = "NotImplemented";
|
||
HttpStatusCode2[HttpStatusCode2["BadGateway"] = 502] = "BadGateway";
|
||
HttpStatusCode2[HttpStatusCode2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
|
||
HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
|
||
HttpStatusCode2[HttpStatusCode2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
|
||
HttpStatusCode2[HttpStatusCode2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
|
||
HttpStatusCode2[HttpStatusCode2["InsufficientStorage"] = 507] = "InsufficientStorage";
|
||
HttpStatusCode2[HttpStatusCode2["LoopDetected"] = 508] = "LoopDetected";
|
||
HttpStatusCode2[HttpStatusCode2["NotExtended"] = 510] = "NotExtended";
|
||
HttpStatusCode2[HttpStatusCode2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
|
||
})(HttpStatusCode || (HttpStatusCode = {}));
|
||
function addBody(options, body) {
|
||
return {
|
||
body,
|
||
headers: options.headers,
|
||
context: options.context,
|
||
observe: options.observe,
|
||
params: options.params,
|
||
reportProgress: options.reportProgress,
|
||
responseType: options.responseType,
|
||
withCredentials: options.withCredentials,
|
||
transferCache: options.transferCache,
|
||
keepalive: options.keepalive
|
||
};
|
||
}
|
||
var HttpClient = class _HttpClient {
|
||
handler;
|
||
constructor(handler) {
|
||
this.handler = handler;
|
||
}
|
||
/**
|
||
* Constructs an observable for a generic HTTP request that, when subscribed,
|
||
* fires the request through the chain of registered interceptors and on to the
|
||
* server.
|
||
*
|
||
* You can pass an `HttpRequest` directly as the only parameter. In this case,
|
||
* the call returns an observable of the raw `HttpEvent` stream.
|
||
*
|
||
* Alternatively you can pass an HTTP method as the first parameter,
|
||
* a URL string as the second, and an options hash containing the request body as the third.
|
||
* See `addBody()`. In this case, the specified `responseType` and `observe` options determine the
|
||
* type of returned observable.
|
||
* * The `responseType` value determines how a successful response body is parsed.
|
||
* * If `responseType` is the default `json`, you can pass a type interface for the resulting
|
||
* object as a type parameter to the call.
|
||
*
|
||
* The `observe` value determines the return type, according to what you are interested in
|
||
* observing.
|
||
* * An `observe` value of events returns an observable of the raw `HttpEvent` stream, including
|
||
* progress events by default.
|
||
* * An `observe` value of response returns an observable of `HttpResponse<T>`,
|
||
* where the `T` parameter depends on the `responseType` and any optionally provided type
|
||
* parameter.
|
||
* * An `observe` value of body returns an observable of `<T>` with the same `T` body type.
|
||
*
|
||
*/
|
||
request(first, url, options = {}) {
|
||
let req;
|
||
if (first instanceof HttpRequest) {
|
||
req = first;
|
||
} else {
|
||
let headers = void 0;
|
||
if (options.headers instanceof HttpHeaders) {
|
||
headers = options.headers;
|
||
} else {
|
||
headers = new HttpHeaders(options.headers);
|
||
}
|
||
let params = void 0;
|
||
if (!!options.params) {
|
||
if (options.params instanceof HttpParams) {
|
||
params = options.params;
|
||
} else {
|
||
params = new HttpParams({
|
||
fromObject: options.params
|
||
});
|
||
}
|
||
}
|
||
req = new HttpRequest(first, url, options.body !== void 0 ? options.body : null, {
|
||
headers,
|
||
context: options.context,
|
||
params,
|
||
reportProgress: options.reportProgress,
|
||
// By default, JSON is assumed to be returned for all calls.
|
||
responseType: options.responseType || "json",
|
||
withCredentials: options.withCredentials,
|
||
transferCache: options.transferCache,
|
||
keepalive: options.keepalive
|
||
});
|
||
}
|
||
const events$ = of(req).pipe(concatMap((req2) => this.handler.handle(req2)));
|
||
if (first instanceof HttpRequest || options.observe === "events") {
|
||
return events$;
|
||
}
|
||
const res$ = events$.pipe(filter((event) => event instanceof HttpResponse));
|
||
switch (options.observe || "body") {
|
||
case "body":
|
||
switch (req.responseType) {
|
||
case "arraybuffer":
|
||
return res$.pipe(map((res) => {
|
||
if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
|
||
throw new RuntimeError(2806, ngDevMode && "Response is not an ArrayBuffer.");
|
||
}
|
||
return res.body;
|
||
}));
|
||
case "blob":
|
||
return res$.pipe(map((res) => {
|
||
if (res.body !== null && !(res.body instanceof Blob)) {
|
||
throw new RuntimeError(2807, ngDevMode && "Response is not a Blob.");
|
||
}
|
||
return res.body;
|
||
}));
|
||
case "text":
|
||
return res$.pipe(map((res) => {
|
||
if (res.body !== null && typeof res.body !== "string") {
|
||
throw new RuntimeError(2808, ngDevMode && "Response is not a string.");
|
||
}
|
||
return res.body;
|
||
}));
|
||
case "json":
|
||
default:
|
||
return res$.pipe(map((res) => res.body));
|
||
}
|
||
case "response":
|
||
return res$;
|
||
default:
|
||
throw new RuntimeError(2809, ngDevMode && `Unreachable: unhandled observe type ${options.observe}}`);
|
||
}
|
||
}
|
||
/**
|
||
* Constructs an observable that, when subscribed, causes the configured
|
||
* `DELETE` request to execute on the server. See the individual overloads for
|
||
* details on the return type.
|
||
*
|
||
* @param url The endpoint URL.
|
||
* @param options The HTTP options to send with the request.
|
||
*
|
||
*/
|
||
delete(url, options = {}) {
|
||
return this.request("DELETE", url, options);
|
||
}
|
||
/**
|
||
* Constructs an observable that, when subscribed, causes the configured
|
||
* `GET` request to execute on the server. See the individual overloads for
|
||
* details on the return type.
|
||
*/
|
||
get(url, options = {}) {
|
||
return this.request("GET", url, options);
|
||
}
|
||
/**
|
||
* Constructs an observable that, when subscribed, causes the configured
|
||
* `HEAD` request to execute on the server. The `HEAD` method returns
|
||
* meta information about the resource without transferring the
|
||
* resource itself. See the individual overloads for
|
||
* details on the return type.
|
||
*/
|
||
head(url, options = {}) {
|
||
return this.request("HEAD", url, options);
|
||
}
|
||
/**
|
||
* Constructs an `Observable` that, when subscribed, causes a request with the special method
|
||
* `JSONP` to be dispatched via the interceptor pipeline.
|
||
* The [JSONP pattern](https://en.wikipedia.org/wiki/JSONP) works around limitations of certain
|
||
* API endpoints that don't support newer,
|
||
* and preferable [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) protocol.
|
||
* JSONP treats the endpoint API as a JavaScript file and tricks the browser to process the
|
||
* requests even if the API endpoint is not located on the same domain (origin) as the client-side
|
||
* application making the request.
|
||
* The endpoint API must support JSONP callback for JSONP requests to work.
|
||
* The resource API returns the JSON response wrapped in a callback function.
|
||
* You can pass the callback function name as one of the query parameters.
|
||
* Note that JSONP requests can only be used with `GET` requests.
|
||
*
|
||
* @param url The resource URL.
|
||
* @param callbackParam The callback function name.
|
||
*
|
||
*/
|
||
jsonp(url, callbackParam) {
|
||
return this.request("JSONP", url, {
|
||
params: new HttpParams().append(callbackParam, "JSONP_CALLBACK"),
|
||
observe: "body",
|
||
responseType: "json"
|
||
});
|
||
}
|
||
/**
|
||
* Constructs an `Observable` that, when subscribed, causes the configured
|
||
* `OPTIONS` request to execute on the server. This method allows the client
|
||
* to determine the supported HTTP methods and other capabilities of an endpoint,
|
||
* without implying a resource action. See the individual overloads for
|
||
* details on the return type.
|
||
*/
|
||
options(url, options = {}) {
|
||
return this.request("OPTIONS", url, options);
|
||
}
|
||
/**
|
||
* Constructs an observable that, when subscribed, causes the configured
|
||
* `PATCH` request to execute on the server. See the individual overloads for
|
||
* details on the return type.
|
||
*/
|
||
patch(url, body, options = {}) {
|
||
return this.request("PATCH", url, addBody(options, body));
|
||
}
|
||
/**
|
||
* Constructs an observable that, when subscribed, causes the configured
|
||
* `POST` request to execute on the server. The server responds with the location of
|
||
* the replaced resource. See the individual overloads for
|
||
* details on the return type.
|
||
*/
|
||
post(url, body, options = {}) {
|
||
return this.request("POST", url, addBody(options, body));
|
||
}
|
||
/**
|
||
* Constructs an observable that, when subscribed, causes the configured
|
||
* `PUT` request to execute on the server. The `PUT` method replaces an existing resource
|
||
* with a new set of values.
|
||
* See the individual overloads for details on the return type.
|
||
*/
|
||
put(url, body, options = {}) {
|
||
return this.request("PUT", url, addBody(options, body));
|
||
}
|
||
static ɵfac = function HttpClient_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpClient)(ɵɵinject(HttpHandler));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _HttpClient,
|
||
factory: _HttpClient.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClient, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: HttpHandler
|
||
}], null);
|
||
})();
|
||
var XSSI_PREFIX$1 = /^\)\]\}',?\n/;
|
||
function getResponseUrl$1(response) {
|
||
if (response.url) {
|
||
return response.url;
|
||
}
|
||
const xRequestUrl = X_REQUEST_URL_HEADER.toLocaleLowerCase();
|
||
return response.headers.get(xRequestUrl);
|
||
}
|
||
var FETCH_BACKEND = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "FETCH_BACKEND" : "");
|
||
var FetchBackend = class _FetchBackend {
|
||
// We use an arrow function to always reference the current global implementation of `fetch`.
|
||
// This is helpful for cases when the global `fetch` implementation is modified by external code,
|
||
// see https://github.com/angular/angular/issues/57527.
|
||
fetchImpl = inject(FetchFactory, {
|
||
optional: true
|
||
})?.fetch ?? ((...args) => globalThis.fetch(...args));
|
||
ngZone = inject(NgZone);
|
||
destroyRef = inject(DestroyRef);
|
||
destroyed = false;
|
||
constructor() {
|
||
this.destroyRef.onDestroy(() => {
|
||
this.destroyed = true;
|
||
});
|
||
}
|
||
handle(request) {
|
||
return new Observable((observer) => {
|
||
const aborter = new AbortController();
|
||
this.doRequest(request, aborter.signal, observer).then(noop, (error) => observer.error(new HttpErrorResponse({
|
||
error
|
||
})));
|
||
return () => aborter.abort();
|
||
});
|
||
}
|
||
async doRequest(request, signal2, observer) {
|
||
const init = this.createRequestInit(request);
|
||
let response;
|
||
try {
|
||
const fetchPromise = this.ngZone.runOutsideAngular(() => this.fetchImpl(request.urlWithParams, __spreadValues({
|
||
signal: signal2
|
||
}, init)));
|
||
silenceSuperfluousUnhandledPromiseRejection(fetchPromise);
|
||
observer.next({
|
||
type: HttpEventType.Sent
|
||
});
|
||
response = await fetchPromise;
|
||
} catch (error) {
|
||
observer.error(new HttpErrorResponse({
|
||
error,
|
||
status: error.status ?? 0,
|
||
statusText: error.statusText,
|
||
url: request.urlWithParams,
|
||
headers: error.headers
|
||
}));
|
||
return;
|
||
}
|
||
const headers = new HttpHeaders(response.headers);
|
||
const statusText = response.statusText;
|
||
const url = getResponseUrl$1(response) ?? request.urlWithParams;
|
||
let status = response.status;
|
||
let body = null;
|
||
if (request.reportProgress) {
|
||
observer.next(new HttpHeaderResponse({
|
||
headers,
|
||
status,
|
||
statusText,
|
||
url
|
||
}));
|
||
}
|
||
if (response.body) {
|
||
const contentLength = response.headers.get("content-length");
|
||
const chunks = [];
|
||
const reader = response.body.getReader();
|
||
let receivedLength = 0;
|
||
let decoder;
|
||
let partialText;
|
||
const reqZone = typeof Zone !== "undefined" && Zone.current;
|
||
let canceled = false;
|
||
await this.ngZone.runOutsideAngular(async () => {
|
||
while (true) {
|
||
if (this.destroyed) {
|
||
await reader.cancel();
|
||
canceled = true;
|
||
break;
|
||
}
|
||
const {
|
||
done,
|
||
value
|
||
} = await reader.read();
|
||
if (done) {
|
||
break;
|
||
}
|
||
chunks.push(value);
|
||
receivedLength += value.length;
|
||
if (request.reportProgress) {
|
||
partialText = request.responseType === "text" ? (partialText ?? "") + (decoder ??= new TextDecoder()).decode(value, {
|
||
stream: true
|
||
}) : void 0;
|
||
const reportProgress = () => observer.next({
|
||
type: HttpEventType.DownloadProgress,
|
||
total: contentLength ? +contentLength : void 0,
|
||
loaded: receivedLength,
|
||
partialText
|
||
});
|
||
reqZone ? reqZone.run(reportProgress) : reportProgress();
|
||
}
|
||
}
|
||
});
|
||
if (canceled) {
|
||
observer.complete();
|
||
return;
|
||
}
|
||
const chunksAll = this.concatChunks(chunks, receivedLength);
|
||
try {
|
||
const contentType = response.headers.get(CONTENT_TYPE_HEADER) ?? "";
|
||
body = this.parseBody(request, chunksAll, contentType);
|
||
} catch (error) {
|
||
observer.error(new HttpErrorResponse({
|
||
error,
|
||
headers: new HttpHeaders(response.headers),
|
||
status: response.status,
|
||
statusText: response.statusText,
|
||
url: getResponseUrl$1(response) ?? request.urlWithParams
|
||
}));
|
||
return;
|
||
}
|
||
}
|
||
if (status === 0) {
|
||
status = body ? HTTP_STATUS_CODE_OK : 0;
|
||
}
|
||
const ok = status >= 200 && status < 300;
|
||
if (ok) {
|
||
observer.next(new HttpResponse({
|
||
body,
|
||
headers,
|
||
status,
|
||
statusText,
|
||
url
|
||
}));
|
||
observer.complete();
|
||
} else {
|
||
observer.error(new HttpErrorResponse({
|
||
error: body,
|
||
headers,
|
||
status,
|
||
statusText,
|
||
url
|
||
}));
|
||
}
|
||
}
|
||
parseBody(request, binContent, contentType) {
|
||
switch (request.responseType) {
|
||
case "json":
|
||
const text = new TextDecoder().decode(binContent).replace(XSSI_PREFIX$1, "");
|
||
return text === "" ? null : JSON.parse(text);
|
||
case "text":
|
||
return new TextDecoder().decode(binContent);
|
||
case "blob":
|
||
return new Blob([binContent], {
|
||
type: contentType
|
||
});
|
||
case "arraybuffer":
|
||
return binContent.buffer;
|
||
}
|
||
}
|
||
createRequestInit(req) {
|
||
const headers = {};
|
||
const credentials = req.withCredentials ? "include" : void 0;
|
||
req.headers.forEach((name, values) => headers[name] = values.join(","));
|
||
if (!req.headers.has(ACCEPT_HEADER)) {
|
||
headers[ACCEPT_HEADER] = ACCEPT_HEADER_VALUE;
|
||
}
|
||
if (!req.headers.has(CONTENT_TYPE_HEADER)) {
|
||
const detectedType = req.detectContentTypeHeader();
|
||
if (detectedType !== null) {
|
||
headers[CONTENT_TYPE_HEADER] = detectedType;
|
||
}
|
||
}
|
||
return {
|
||
body: req.serializeBody(),
|
||
method: req.method,
|
||
headers,
|
||
credentials,
|
||
keepalive: req.keepalive
|
||
};
|
||
}
|
||
concatChunks(chunks, totalLength) {
|
||
const chunksAll = new Uint8Array(totalLength);
|
||
let position = 0;
|
||
for (const chunk of chunks) {
|
||
chunksAll.set(chunk, position);
|
||
position += chunk.length;
|
||
}
|
||
return chunksAll;
|
||
}
|
||
static ɵfac = function FetchBackend_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _FetchBackend)();
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _FetchBackend,
|
||
factory: _FetchBackend.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FetchBackend, [{
|
||
type: Injectable
|
||
}], () => [], null);
|
||
})();
|
||
var FetchFactory = class {
|
||
};
|
||
function noop() {
|
||
}
|
||
function silenceSuperfluousUnhandledPromiseRejection(promise) {
|
||
promise.then(noop, noop);
|
||
}
|
||
function interceptorChainEndFn(req, finalHandlerFn) {
|
||
return finalHandlerFn(req);
|
||
}
|
||
function adaptLegacyInterceptorToChain(chainTailFn, interceptor) {
|
||
return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {
|
||
handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)
|
||
});
|
||
}
|
||
function chainedInterceptorFn(chainTailFn, interceptorFn, injector) {
|
||
return (initialRequest, finalHandlerFn) => runInInjectionContext(injector, () => interceptorFn(initialRequest, (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)));
|
||
}
|
||
var HTTP_INTERCEPTORS = new InjectionToken(ngDevMode ? "HTTP_INTERCEPTORS" : "");
|
||
var HTTP_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? "HTTP_INTERCEPTOR_FNS" : "");
|
||
var HTTP_ROOT_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? "HTTP_ROOT_INTERCEPTOR_FNS" : "");
|
||
var REQUESTS_CONTRIBUTE_TO_STABILITY = new InjectionToken(ngDevMode ? "REQUESTS_CONTRIBUTE_TO_STABILITY" : "", {
|
||
providedIn: "root",
|
||
factory: () => true
|
||
});
|
||
function legacyInterceptorFnFactory() {
|
||
let chain = null;
|
||
return (req, handler) => {
|
||
if (chain === null) {
|
||
const interceptors = inject(HTTP_INTERCEPTORS, {
|
||
optional: true
|
||
}) ?? [];
|
||
chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);
|
||
}
|
||
const pendingTasks = inject(PendingTasks);
|
||
const contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);
|
||
if (contributeToStability) {
|
||
const removeTask = pendingTasks.add();
|
||
return chain(req, handler).pipe(finalize(removeTask));
|
||
} else {
|
||
return chain(req, handler);
|
||
}
|
||
};
|
||
}
|
||
var fetchBackendWarningDisplayed = false;
|
||
var HttpInterceptorHandler = class _HttpInterceptorHandler extends HttpHandler {
|
||
backend;
|
||
injector;
|
||
chain = null;
|
||
pendingTasks = inject(PendingTasks);
|
||
contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);
|
||
constructor(backend, injector) {
|
||
super();
|
||
this.backend = backend;
|
||
this.injector = injector;
|
||
if ((typeof ngDevMode === "undefined" || ngDevMode) && !fetchBackendWarningDisplayed) {
|
||
const isTestingBackend = this.backend.isTestingBackend;
|
||
if (false) {
|
||
fetchBackendWarningDisplayed = true;
|
||
injector.get(Console).warn(formatRuntimeError(2801, "Angular detected that `HttpClient` is not configured to use `fetch` APIs. It's strongly recommended to enable `fetch` for applications that use Server-Side Rendering for better performance and compatibility. To enable `fetch`, add the `withFetch()` to the `provideHttpClient()` call at the root of the application."));
|
||
}
|
||
}
|
||
}
|
||
handle(initialRequest) {
|
||
if (this.chain === null) {
|
||
const dedupedInterceptorFns = Array.from(/* @__PURE__ */ new Set([...this.injector.get(HTTP_INTERCEPTOR_FNS), ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, [])]));
|
||
this.chain = dedupedInterceptorFns.reduceRight((nextSequencedFn, interceptorFn) => chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector), interceptorChainEndFn);
|
||
}
|
||
if (this.contributeToStability) {
|
||
const removeTask = this.pendingTasks.add();
|
||
return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest)).pipe(finalize(removeTask));
|
||
} else {
|
||
return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest));
|
||
}
|
||
}
|
||
static ɵfac = function HttpInterceptorHandler_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpInterceptorHandler)(ɵɵinject(HttpBackend), ɵɵinject(EnvironmentInjector));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _HttpInterceptorHandler,
|
||
factory: _HttpInterceptorHandler.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpInterceptorHandler, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: HttpBackend
|
||
}, {
|
||
type: EnvironmentInjector
|
||
}], null);
|
||
})();
|
||
var nextRequestId = 0;
|
||
var foreignDocument;
|
||
var JSONP_ERR_NO_CALLBACK = "JSONP injected script did not invoke callback.";
|
||
var JSONP_ERR_WRONG_METHOD = "JSONP requests must use JSONP request method.";
|
||
var JSONP_ERR_WRONG_RESPONSE_TYPE = "JSONP requests must use Json response type.";
|
||
var JSONP_ERR_HEADERS_NOT_SUPPORTED = "JSONP requests do not support headers.";
|
||
var JsonpCallbackContext = class {
|
||
};
|
||
function jsonpCallbackContext() {
|
||
if (typeof window === "object") {
|
||
return window;
|
||
}
|
||
return {};
|
||
}
|
||
var JsonpClientBackend = class _JsonpClientBackend {
|
||
callbackMap;
|
||
document;
|
||
/**
|
||
* A resolved promise that can be used to schedule microtasks in the event handlers.
|
||
*/
|
||
resolvedPromise = Promise.resolve();
|
||
constructor(callbackMap, document2) {
|
||
this.callbackMap = callbackMap;
|
||
this.document = document2;
|
||
}
|
||
/**
|
||
* Get the name of the next callback method, by incrementing the global `nextRequestId`.
|
||
*/
|
||
nextCallback() {
|
||
return `ng_jsonp_callback_${nextRequestId++}`;
|
||
}
|
||
/**
|
||
* Processes a JSONP request and returns an event stream of the results.
|
||
* @param req The request object.
|
||
* @returns An observable of the response events.
|
||
*
|
||
*/
|
||
handle(req) {
|
||
if (req.method !== "JSONP") {
|
||
throw new RuntimeError(2810, ngDevMode && JSONP_ERR_WRONG_METHOD);
|
||
} else if (req.responseType !== "json") {
|
||
throw new RuntimeError(2811, ngDevMode && JSONP_ERR_WRONG_RESPONSE_TYPE);
|
||
}
|
||
if (req.headers.keys().length > 0) {
|
||
throw new RuntimeError(2812, ngDevMode && JSONP_ERR_HEADERS_NOT_SUPPORTED);
|
||
}
|
||
return new Observable((observer) => {
|
||
const callback = this.nextCallback();
|
||
const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);
|
||
const node = this.document.createElement("script");
|
||
node.src = url;
|
||
let body = null;
|
||
let finished = false;
|
||
this.callbackMap[callback] = (data) => {
|
||
delete this.callbackMap[callback];
|
||
body = data;
|
||
finished = true;
|
||
};
|
||
const cleanup = () => {
|
||
node.removeEventListener("load", onLoad);
|
||
node.removeEventListener("error", onError);
|
||
node.remove();
|
||
delete this.callbackMap[callback];
|
||
};
|
||
const onLoad = () => {
|
||
this.resolvedPromise.then(() => {
|
||
cleanup();
|
||
if (!finished) {
|
||
observer.error(new HttpErrorResponse({
|
||
url,
|
||
status: 0,
|
||
statusText: "JSONP Error",
|
||
error: new Error(JSONP_ERR_NO_CALLBACK)
|
||
}));
|
||
return;
|
||
}
|
||
observer.next(new HttpResponse({
|
||
body,
|
||
status: HTTP_STATUS_CODE_OK,
|
||
statusText: "OK",
|
||
url
|
||
}));
|
||
observer.complete();
|
||
});
|
||
};
|
||
const onError = (error) => {
|
||
cleanup();
|
||
observer.error(new HttpErrorResponse({
|
||
error,
|
||
status: 0,
|
||
statusText: "JSONP Error",
|
||
url
|
||
}));
|
||
};
|
||
node.addEventListener("load", onLoad);
|
||
node.addEventListener("error", onError);
|
||
this.document.body.appendChild(node);
|
||
observer.next({
|
||
type: HttpEventType.Sent
|
||
});
|
||
return () => {
|
||
if (!finished) {
|
||
this.removeListeners(node);
|
||
}
|
||
cleanup();
|
||
};
|
||
});
|
||
}
|
||
removeListeners(script) {
|
||
foreignDocument ??= this.document.implementation.createHTMLDocument();
|
||
foreignDocument.adoptNode(script);
|
||
}
|
||
static ɵfac = function JsonpClientBackend_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _JsonpClientBackend)(ɵɵinject(JsonpCallbackContext), ɵɵinject(DOCUMENT));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _JsonpClientBackend,
|
||
factory: _JsonpClientBackend.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonpClientBackend, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: JsonpCallbackContext
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [DOCUMENT]
|
||
}]
|
||
}], null);
|
||
})();
|
||
function jsonpInterceptorFn(req, next) {
|
||
if (req.method === "JSONP") {
|
||
return inject(JsonpClientBackend).handle(req);
|
||
}
|
||
return next(req);
|
||
}
|
||
var JsonpInterceptor = class _JsonpInterceptor {
|
||
injector;
|
||
constructor(injector) {
|
||
this.injector = injector;
|
||
}
|
||
/**
|
||
* Identifies and handles a given JSONP request.
|
||
* @param initialRequest The outgoing request object to handle.
|
||
* @param next The next interceptor in the chain, or the backend
|
||
* if no interceptors remain in the chain.
|
||
* @returns An observable of the event stream.
|
||
*/
|
||
intercept(initialRequest, next) {
|
||
return runInInjectionContext(this.injector, () => jsonpInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
|
||
}
|
||
static ɵfac = function JsonpInterceptor_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _JsonpInterceptor)(ɵɵinject(EnvironmentInjector));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _JsonpInterceptor,
|
||
factory: _JsonpInterceptor.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonpInterceptor, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: EnvironmentInjector
|
||
}], null);
|
||
})();
|
||
var XSSI_PREFIX = /^\)\]\}',?\n/;
|
||
var X_REQUEST_URL_REGEXP = RegExp(`^${X_REQUEST_URL_HEADER}:`, "m");
|
||
function getResponseUrl(xhr) {
|
||
if ("responseURL" in xhr && xhr.responseURL) {
|
||
return xhr.responseURL;
|
||
}
|
||
if (X_REQUEST_URL_REGEXP.test(xhr.getAllResponseHeaders())) {
|
||
return xhr.getResponseHeader(X_REQUEST_URL_HEADER);
|
||
}
|
||
return null;
|
||
}
|
||
var HttpXhrBackend = class _HttpXhrBackend {
|
||
xhrFactory;
|
||
constructor(xhrFactory) {
|
||
this.xhrFactory = xhrFactory;
|
||
}
|
||
/**
|
||
* Processes a request and returns a stream of response events.
|
||
* @param req The request object.
|
||
* @returns An observable of the response events.
|
||
*/
|
||
handle(req) {
|
||
if (req.method === "JSONP") {
|
||
throw new RuntimeError(-2800, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot make a JSONP request without JSONP support. To fix the problem, either add the \`withJsonpSupport()\` call (if \`provideHttpClient()\` is used) or import the \`HttpClientJsonpModule\` in the root NgModule.`);
|
||
}
|
||
if (req.keepalive && ngDevMode) {
|
||
console.warn(formatRuntimeError(2813, `Angular detected that a \`HttpClient\` request with the \`keepalive\` option was sent using XHR, which does not support it. To use the \`keepalive\` option, enable Fetch API support by passing \`withFetch()\` as an argument to \`provideHttpClient()\`.`));
|
||
}
|
||
const xhrFactory = this.xhrFactory;
|
||
const source = xhrFactory.ɵloadImpl ? from(xhrFactory.ɵloadImpl()) : of(null);
|
||
return source.pipe(switchMap(() => {
|
||
return new Observable((observer) => {
|
||
const xhr = xhrFactory.build();
|
||
xhr.open(req.method, req.urlWithParams);
|
||
if (req.withCredentials) {
|
||
xhr.withCredentials = true;
|
||
}
|
||
req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(",")));
|
||
if (!req.headers.has(ACCEPT_HEADER)) {
|
||
xhr.setRequestHeader(ACCEPT_HEADER, ACCEPT_HEADER_VALUE);
|
||
}
|
||
if (!req.headers.has(CONTENT_TYPE_HEADER)) {
|
||
const detectedType = req.detectContentTypeHeader();
|
||
if (detectedType !== null) {
|
||
xhr.setRequestHeader(CONTENT_TYPE_HEADER, detectedType);
|
||
}
|
||
}
|
||
if (req.responseType) {
|
||
const responseType = req.responseType.toLowerCase();
|
||
xhr.responseType = responseType !== "json" ? responseType : "text";
|
||
}
|
||
const reqBody = req.serializeBody();
|
||
let headerResponse = null;
|
||
const partialFromXhr = () => {
|
||
if (headerResponse !== null) {
|
||
return headerResponse;
|
||
}
|
||
const statusText = xhr.statusText || "OK";
|
||
const headers = new HttpHeaders(xhr.getAllResponseHeaders());
|
||
const url = getResponseUrl(xhr) || req.url;
|
||
headerResponse = new HttpHeaderResponse({
|
||
headers,
|
||
status: xhr.status,
|
||
statusText,
|
||
url
|
||
});
|
||
return headerResponse;
|
||
};
|
||
const onLoad = () => {
|
||
let {
|
||
headers,
|
||
status,
|
||
statusText,
|
||
url
|
||
} = partialFromXhr();
|
||
let body = null;
|
||
if (status !== HTTP_STATUS_CODE_NO_CONTENT) {
|
||
body = typeof xhr.response === "undefined" ? xhr.responseText : xhr.response;
|
||
}
|
||
if (status === 0) {
|
||
status = !!body ? HTTP_STATUS_CODE_OK : 0;
|
||
}
|
||
let ok = status >= 200 && status < 300;
|
||
if (req.responseType === "json" && typeof body === "string") {
|
||
const originalBody = body;
|
||
body = body.replace(XSSI_PREFIX, "");
|
||
try {
|
||
body = body !== "" ? JSON.parse(body) : null;
|
||
} catch (error) {
|
||
body = originalBody;
|
||
if (ok) {
|
||
ok = false;
|
||
body = {
|
||
error,
|
||
text: body
|
||
};
|
||
}
|
||
}
|
||
}
|
||
if (ok) {
|
||
observer.next(new HttpResponse({
|
||
body,
|
||
headers,
|
||
status,
|
||
statusText,
|
||
url: url || void 0
|
||
}));
|
||
observer.complete();
|
||
} else {
|
||
observer.error(new HttpErrorResponse({
|
||
// The error in this case is the response body (error from the server).
|
||
error: body,
|
||
headers,
|
||
status,
|
||
statusText,
|
||
url: url || void 0
|
||
}));
|
||
}
|
||
};
|
||
const onError = (error) => {
|
||
const {
|
||
url
|
||
} = partialFromXhr();
|
||
const res = new HttpErrorResponse({
|
||
error,
|
||
status: xhr.status || 0,
|
||
statusText: xhr.statusText || "Unknown Error",
|
||
url: url || void 0
|
||
});
|
||
observer.error(res);
|
||
};
|
||
let sentHeaders = false;
|
||
const onDownProgress = (event) => {
|
||
if (!sentHeaders) {
|
||
observer.next(partialFromXhr());
|
||
sentHeaders = true;
|
||
}
|
||
let progressEvent = {
|
||
type: HttpEventType.DownloadProgress,
|
||
loaded: event.loaded
|
||
};
|
||
if (event.lengthComputable) {
|
||
progressEvent.total = event.total;
|
||
}
|
||
if (req.responseType === "text" && !!xhr.responseText) {
|
||
progressEvent.partialText = xhr.responseText;
|
||
}
|
||
observer.next(progressEvent);
|
||
};
|
||
const onUpProgress = (event) => {
|
||
let progress = {
|
||
type: HttpEventType.UploadProgress,
|
||
loaded: event.loaded
|
||
};
|
||
if (event.lengthComputable) {
|
||
progress.total = event.total;
|
||
}
|
||
observer.next(progress);
|
||
};
|
||
xhr.addEventListener("load", onLoad);
|
||
xhr.addEventListener("error", onError);
|
||
xhr.addEventListener("timeout", onError);
|
||
xhr.addEventListener("abort", onError);
|
||
if (req.reportProgress) {
|
||
xhr.addEventListener("progress", onDownProgress);
|
||
if (reqBody !== null && xhr.upload) {
|
||
xhr.upload.addEventListener("progress", onUpProgress);
|
||
}
|
||
}
|
||
xhr.send(reqBody);
|
||
observer.next({
|
||
type: HttpEventType.Sent
|
||
});
|
||
return () => {
|
||
xhr.removeEventListener("error", onError);
|
||
xhr.removeEventListener("abort", onError);
|
||
xhr.removeEventListener("load", onLoad);
|
||
xhr.removeEventListener("timeout", onError);
|
||
if (req.reportProgress) {
|
||
xhr.removeEventListener("progress", onDownProgress);
|
||
if (reqBody !== null && xhr.upload) {
|
||
xhr.upload.removeEventListener("progress", onUpProgress);
|
||
}
|
||
}
|
||
if (xhr.readyState !== xhr.DONE) {
|
||
xhr.abort();
|
||
}
|
||
};
|
||
});
|
||
}));
|
||
}
|
||
static ɵfac = function HttpXhrBackend_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpXhrBackend)(ɵɵinject(XhrFactory));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _HttpXhrBackend,
|
||
factory: _HttpXhrBackend.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXhrBackend, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: XhrFactory
|
||
}], null);
|
||
})();
|
||
var XSRF_ENABLED = new InjectionToken(ngDevMode ? "XSRF_ENABLED" : "");
|
||
var XSRF_DEFAULT_COOKIE_NAME = "XSRF-TOKEN";
|
||
var XSRF_COOKIE_NAME = new InjectionToken(ngDevMode ? "XSRF_COOKIE_NAME" : "", {
|
||
providedIn: "root",
|
||
factory: () => XSRF_DEFAULT_COOKIE_NAME
|
||
});
|
||
var XSRF_DEFAULT_HEADER_NAME = "X-XSRF-TOKEN";
|
||
var XSRF_HEADER_NAME = new InjectionToken(ngDevMode ? "XSRF_HEADER_NAME" : "", {
|
||
providedIn: "root",
|
||
factory: () => XSRF_DEFAULT_HEADER_NAME
|
||
});
|
||
var HttpXsrfTokenExtractor = class {
|
||
};
|
||
var HttpXsrfCookieExtractor = class _HttpXsrfCookieExtractor {
|
||
doc;
|
||
cookieName;
|
||
lastCookieString = "";
|
||
lastToken = null;
|
||
/**
|
||
* @internal for testing
|
||
*/
|
||
parseCount = 0;
|
||
constructor(doc, cookieName) {
|
||
this.doc = doc;
|
||
this.cookieName = cookieName;
|
||
}
|
||
getToken() {
|
||
if (false) {
|
||
return null;
|
||
}
|
||
const cookieString = this.doc.cookie || "";
|
||
if (cookieString !== this.lastCookieString) {
|
||
this.parseCount++;
|
||
this.lastToken = parseCookieValue(cookieString, this.cookieName);
|
||
this.lastCookieString = cookieString;
|
||
}
|
||
return this.lastToken;
|
||
}
|
||
static ɵfac = function HttpXsrfCookieExtractor_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpXsrfCookieExtractor)(ɵɵinject(DOCUMENT), ɵɵinject(XSRF_COOKIE_NAME));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _HttpXsrfCookieExtractor,
|
||
factory: _HttpXsrfCookieExtractor.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXsrfCookieExtractor, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [DOCUMENT]
|
||
}]
|
||
}, {
|
||
type: void 0,
|
||
decorators: [{
|
||
type: Inject,
|
||
args: [XSRF_COOKIE_NAME]
|
||
}]
|
||
}], null);
|
||
})();
|
||
function xsrfInterceptorFn(req, next) {
|
||
const lcUrl = req.url.toLowerCase();
|
||
if (!inject(XSRF_ENABLED) || req.method === "GET" || req.method === "HEAD" || lcUrl.startsWith("http://") || lcUrl.startsWith("https://")) {
|
||
return next(req);
|
||
}
|
||
const token = inject(HttpXsrfTokenExtractor).getToken();
|
||
const headerName = inject(XSRF_HEADER_NAME);
|
||
if (token != null && !req.headers.has(headerName)) {
|
||
req = req.clone({
|
||
headers: req.headers.set(headerName, token)
|
||
});
|
||
}
|
||
return next(req);
|
||
}
|
||
var HttpXsrfInterceptor = class _HttpXsrfInterceptor {
|
||
injector;
|
||
constructor(injector) {
|
||
this.injector = injector;
|
||
}
|
||
intercept(initialRequest, next) {
|
||
return runInInjectionContext(this.injector, () => xsrfInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
|
||
}
|
||
static ɵfac = function HttpXsrfInterceptor_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpXsrfInterceptor)(ɵɵinject(EnvironmentInjector));
|
||
};
|
||
static ɵprov = ɵɵdefineInjectable({
|
||
token: _HttpXsrfInterceptor,
|
||
factory: _HttpXsrfInterceptor.ɵfac
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXsrfInterceptor, [{
|
||
type: Injectable
|
||
}], () => [{
|
||
type: EnvironmentInjector
|
||
}], null);
|
||
})();
|
||
var HttpFeatureKind;
|
||
(function(HttpFeatureKind2) {
|
||
HttpFeatureKind2[HttpFeatureKind2["Interceptors"] = 0] = "Interceptors";
|
||
HttpFeatureKind2[HttpFeatureKind2["LegacyInterceptors"] = 1] = "LegacyInterceptors";
|
||
HttpFeatureKind2[HttpFeatureKind2["CustomXsrfConfiguration"] = 2] = "CustomXsrfConfiguration";
|
||
HttpFeatureKind2[HttpFeatureKind2["NoXsrfProtection"] = 3] = "NoXsrfProtection";
|
||
HttpFeatureKind2[HttpFeatureKind2["JsonpSupport"] = 4] = "JsonpSupport";
|
||
HttpFeatureKind2[HttpFeatureKind2["RequestsMadeViaParent"] = 5] = "RequestsMadeViaParent";
|
||
HttpFeatureKind2[HttpFeatureKind2["Fetch"] = 6] = "Fetch";
|
||
})(HttpFeatureKind || (HttpFeatureKind = {}));
|
||
function makeHttpFeature(kind, providers) {
|
||
return {
|
||
ɵkind: kind,
|
||
ɵproviders: providers
|
||
};
|
||
}
|
||
function provideHttpClient(...features) {
|
||
if (ngDevMode) {
|
||
const featureKinds = new Set(features.map((f) => f.ɵkind));
|
||
if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) && featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {
|
||
throw new Error(ngDevMode ? `Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.` : "");
|
||
}
|
||
}
|
||
const providers = [HttpClient, HttpXhrBackend, HttpInterceptorHandler, {
|
||
provide: HttpHandler,
|
||
useExisting: HttpInterceptorHandler
|
||
}, {
|
||
provide: HttpBackend,
|
||
useFactory: () => {
|
||
return inject(FETCH_BACKEND, {
|
||
optional: true
|
||
}) ?? inject(HttpXhrBackend);
|
||
}
|
||
}, {
|
||
provide: HTTP_INTERCEPTOR_FNS,
|
||
useValue: xsrfInterceptorFn,
|
||
multi: true
|
||
}, {
|
||
provide: XSRF_ENABLED,
|
||
useValue: true
|
||
}, {
|
||
provide: HttpXsrfTokenExtractor,
|
||
useClass: HttpXsrfCookieExtractor
|
||
}];
|
||
for (const feature of features) {
|
||
providers.push(...feature.ɵproviders);
|
||
}
|
||
return makeEnvironmentProviders(providers);
|
||
}
|
||
var LEGACY_INTERCEPTOR_FN = new InjectionToken(ngDevMode ? "LEGACY_INTERCEPTOR_FN" : "");
|
||
function withInterceptorsFromDi() {
|
||
return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [{
|
||
provide: LEGACY_INTERCEPTOR_FN,
|
||
useFactory: legacyInterceptorFnFactory
|
||
}, {
|
||
provide: HTTP_INTERCEPTOR_FNS,
|
||
useExisting: LEGACY_INTERCEPTOR_FN,
|
||
multi: true
|
||
}]);
|
||
}
|
||
function withXsrfConfiguration({
|
||
cookieName,
|
||
headerName
|
||
}) {
|
||
const providers = [];
|
||
if (cookieName !== void 0) {
|
||
providers.push({
|
||
provide: XSRF_COOKIE_NAME,
|
||
useValue: cookieName
|
||
});
|
||
}
|
||
if (headerName !== void 0) {
|
||
providers.push({
|
||
provide: XSRF_HEADER_NAME,
|
||
useValue: headerName
|
||
});
|
||
}
|
||
return makeHttpFeature(HttpFeatureKind.CustomXsrfConfiguration, providers);
|
||
}
|
||
function withNoXsrfProtection() {
|
||
return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [{
|
||
provide: XSRF_ENABLED,
|
||
useValue: false
|
||
}]);
|
||
}
|
||
function withJsonpSupport() {
|
||
return makeHttpFeature(HttpFeatureKind.JsonpSupport, [JsonpClientBackend, {
|
||
provide: JsonpCallbackContext,
|
||
useFactory: jsonpCallbackContext
|
||
}, {
|
||
provide: HTTP_INTERCEPTOR_FNS,
|
||
useValue: jsonpInterceptorFn,
|
||
multi: true
|
||
}]);
|
||
}
|
||
var HttpClientXsrfModule = class _HttpClientXsrfModule {
|
||
/**
|
||
* Disable the default XSRF protection.
|
||
*/
|
||
static disable() {
|
||
return {
|
||
ngModule: _HttpClientXsrfModule,
|
||
providers: [withNoXsrfProtection().ɵproviders]
|
||
};
|
||
}
|
||
/**
|
||
* Configure XSRF protection.
|
||
* @param options An object that can specify either or both
|
||
* cookie name or header name.
|
||
* - Cookie name default is `XSRF-TOKEN`.
|
||
* - Header name default is `X-XSRF-TOKEN`.
|
||
*
|
||
*/
|
||
static withOptions(options = {}) {
|
||
return {
|
||
ngModule: _HttpClientXsrfModule,
|
||
providers: withXsrfConfiguration(options).ɵproviders
|
||
};
|
||
}
|
||
static ɵfac = function HttpClientXsrfModule_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpClientXsrfModule)();
|
||
};
|
||
static ɵmod = ɵɵdefineNgModule({
|
||
type: _HttpClientXsrfModule
|
||
});
|
||
static ɵinj = ɵɵdefineInjector({
|
||
providers: [HttpXsrfInterceptor, {
|
||
provide: HTTP_INTERCEPTORS,
|
||
useExisting: HttpXsrfInterceptor,
|
||
multi: true
|
||
}, {
|
||
provide: HttpXsrfTokenExtractor,
|
||
useClass: HttpXsrfCookieExtractor
|
||
}, withXsrfConfiguration({
|
||
cookieName: XSRF_DEFAULT_COOKIE_NAME,
|
||
headerName: XSRF_DEFAULT_HEADER_NAME
|
||
}).ɵproviders, {
|
||
provide: XSRF_ENABLED,
|
||
useValue: true
|
||
}]
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientXsrfModule, [{
|
||
type: NgModule,
|
||
args: [{
|
||
providers: [HttpXsrfInterceptor, {
|
||
provide: HTTP_INTERCEPTORS,
|
||
useExisting: HttpXsrfInterceptor,
|
||
multi: true
|
||
}, {
|
||
provide: HttpXsrfTokenExtractor,
|
||
useClass: HttpXsrfCookieExtractor
|
||
}, withXsrfConfiguration({
|
||
cookieName: XSRF_DEFAULT_COOKIE_NAME,
|
||
headerName: XSRF_DEFAULT_HEADER_NAME
|
||
}).ɵproviders, {
|
||
provide: XSRF_ENABLED,
|
||
useValue: true
|
||
}]
|
||
}]
|
||
}], null, null);
|
||
})();
|
||
var HttpClientModule = class _HttpClientModule {
|
||
static ɵfac = function HttpClientModule_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpClientModule)();
|
||
};
|
||
static ɵmod = ɵɵdefineNgModule({
|
||
type: _HttpClientModule
|
||
});
|
||
static ɵinj = ɵɵdefineInjector({
|
||
providers: [provideHttpClient(withInterceptorsFromDi())]
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientModule, [{
|
||
type: NgModule,
|
||
args: [{
|
||
/**
|
||
* Configures the dependency injector where it is imported
|
||
* with supporting services for HTTP communications.
|
||
*/
|
||
providers: [provideHttpClient(withInterceptorsFromDi())]
|
||
}]
|
||
}], null, null);
|
||
})();
|
||
var HttpClientJsonpModule = class _HttpClientJsonpModule {
|
||
static ɵfac = function HttpClientJsonpModule_Factory(__ngFactoryType__) {
|
||
return new (__ngFactoryType__ || _HttpClientJsonpModule)();
|
||
};
|
||
static ɵmod = ɵɵdefineNgModule({
|
||
type: _HttpClientJsonpModule
|
||
});
|
||
static ɵinj = ɵɵdefineInjector({
|
||
providers: [withJsonpSupport().ɵproviders]
|
||
});
|
||
};
|
||
(() => {
|
||
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientJsonpModule, [{
|
||
type: NgModule,
|
||
args: [{
|
||
providers: [withJsonpSupport().ɵproviders]
|
||
}]
|
||
}], null, null);
|
||
})();
|
||
|
||
// node_modules/@angular/common/fesm2022/http.mjs
|
||
var httpResource = (() => {
|
||
const jsonFn = makeHttpResourceFn("json");
|
||
jsonFn.arrayBuffer = makeHttpResourceFn("arraybuffer");
|
||
jsonFn.blob = makeHttpResourceFn("blob");
|
||
jsonFn.text = makeHttpResourceFn("text");
|
||
return jsonFn;
|
||
})();
|
||
function makeHttpResourceFn(responseType) {
|
||
return function httpResource2(request, options) {
|
||
if (ngDevMode && !options?.injector) {
|
||
assertInInjectionContext(httpResource2);
|
||
}
|
||
const injector = options?.injector ?? inject(Injector);
|
||
return new HttpResourceImpl(injector, () => normalizeRequest(request, responseType), options?.defaultValue, options?.parse, options?.equal);
|
||
};
|
||
}
|
||
function normalizeRequest(request, responseType) {
|
||
let unwrappedRequest = typeof request === "function" ? request() : request;
|
||
if (unwrappedRequest === void 0) {
|
||
return void 0;
|
||
} else if (typeof unwrappedRequest === "string") {
|
||
unwrappedRequest = { url: unwrappedRequest };
|
||
}
|
||
const headers = unwrappedRequest.headers instanceof HttpHeaders ? unwrappedRequest.headers : new HttpHeaders(unwrappedRequest.headers);
|
||
const params = unwrappedRequest.params instanceof HttpParams ? unwrappedRequest.params : new HttpParams({ fromObject: unwrappedRequest.params });
|
||
return new HttpRequest(unwrappedRequest.method ?? "GET", unwrappedRequest.url, unwrappedRequest.body ?? null, {
|
||
headers,
|
||
params,
|
||
reportProgress: unwrappedRequest.reportProgress,
|
||
withCredentials: unwrappedRequest.withCredentials,
|
||
responseType,
|
||
context: unwrappedRequest.context,
|
||
transferCache: unwrappedRequest.transferCache
|
||
});
|
||
}
|
||
var HttpResourceImpl = class extends ResourceImpl {
|
||
client;
|
||
_headers = linkedSignal({
|
||
source: this.extRequest,
|
||
computation: () => void 0
|
||
});
|
||
_progress = linkedSignal({
|
||
source: this.extRequest,
|
||
computation: () => void 0
|
||
});
|
||
_statusCode = linkedSignal({
|
||
source: this.extRequest,
|
||
computation: () => void 0
|
||
});
|
||
headers = computed(() => this.status() === "resolved" || this.status() === "error" ? this._headers() : void 0);
|
||
progress = this._progress.asReadonly();
|
||
statusCode = this._statusCode.asReadonly();
|
||
constructor(injector, request, defaultValue, parse, equal) {
|
||
super(request, ({ params: request2, abortSignal }) => {
|
||
let sub;
|
||
const onAbort = () => sub.unsubscribe();
|
||
abortSignal.addEventListener("abort", onAbort);
|
||
const stream = signal({ value: void 0 });
|
||
let resolve;
|
||
const promise = new Promise((r) => resolve = r);
|
||
const send = (value) => {
|
||
stream.set(value);
|
||
resolve?.(stream);
|
||
resolve = void 0;
|
||
};
|
||
sub = this.client.request(request2).subscribe({
|
||
next: (event) => {
|
||
switch (event.type) {
|
||
case HttpEventType.Response:
|
||
this._headers.set(event.headers);
|
||
this._statusCode.set(event.status);
|
||
try {
|
||
send({ value: parse ? parse(event.body) : event.body });
|
||
} catch (error) {
|
||
send({ error: encapsulateResourceError(error) });
|
||
}
|
||
break;
|
||
case HttpEventType.DownloadProgress:
|
||
this._progress.set(event);
|
||
break;
|
||
}
|
||
},
|
||
error: (error) => {
|
||
if (error instanceof HttpErrorResponse) {
|
||
this._headers.set(error.headers);
|
||
this._statusCode.set(error.status);
|
||
}
|
||
send({ error });
|
||
abortSignal.removeEventListener("abort", onAbort);
|
||
},
|
||
complete: () => {
|
||
if (resolve) {
|
||
send({
|
||
error: new RuntimeError(991, ngDevMode && "Resource completed before producing a value")
|
||
});
|
||
}
|
||
abortSignal.removeEventListener("abort", onAbort);
|
||
}
|
||
});
|
||
return promise;
|
||
}, defaultValue, equal, injector);
|
||
this.client = injector.get(HttpClient);
|
||
}
|
||
};
|
||
var HTTP_TRANSFER_CACHE_ORIGIN_MAP = new InjectionToken(ngDevMode ? "HTTP_TRANSFER_CACHE_ORIGIN_MAP" : "");
|
||
var BODY = "b";
|
||
var HEADERS = "h";
|
||
var STATUS = "s";
|
||
var STATUS_TEXT = "st";
|
||
var REQ_URL = "u";
|
||
var RESPONSE_TYPE = "rt";
|
||
var CACHE_OPTIONS = new InjectionToken(ngDevMode ? "HTTP_TRANSFER_STATE_CACHE_OPTIONS" : "");
|
||
var ALLOWED_METHODS = ["GET", "HEAD"];
|
||
function transferCacheInterceptorFn(req, next) {
|
||
const _a = inject(CACHE_OPTIONS), { isCacheActive } = _a, globalOptions = __objRest(_a, ["isCacheActive"]);
|
||
const { transferCache: requestOptions, method: requestMethod } = req;
|
||
if (!isCacheActive || requestOptions === false || // POST requests are allowed either globally or at request level
|
||
requestMethod === "POST" && !globalOptions.includePostRequests && !requestOptions || requestMethod !== "POST" && !ALLOWED_METHODS.includes(requestMethod) || // Do not cache request that require authorization when includeRequestsWithAuthHeaders is falsey
|
||
!globalOptions.includeRequestsWithAuthHeaders && hasAuthHeaders(req) || globalOptions.filter?.(req) === false) {
|
||
return next(req);
|
||
}
|
||
const transferState = inject(TransferState);
|
||
const originMap = inject(HTTP_TRANSFER_CACHE_ORIGIN_MAP, {
|
||
optional: true
|
||
});
|
||
if (originMap) {
|
||
throw new RuntimeError(2803, ngDevMode && "Angular detected that the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token is configured and present in the client side code. Please ensure that this token is only provided in the server code of the application.");
|
||
}
|
||
const requestUrl = false ? mapRequestOriginUrl(req.url, originMap) : req.url;
|
||
const storeKey = makeCacheKey(req, requestUrl);
|
||
const response = transferState.get(storeKey, null);
|
||
let headersToInclude = globalOptions.includeHeaders;
|
||
if (typeof requestOptions === "object" && requestOptions.includeHeaders) {
|
||
headersToInclude = requestOptions.includeHeaders;
|
||
}
|
||
if (response) {
|
||
const { [BODY]: undecodedBody, [RESPONSE_TYPE]: responseType, [HEADERS]: httpHeaders, [STATUS]: status, [STATUS_TEXT]: statusText, [REQ_URL]: url } = response;
|
||
let body = undecodedBody;
|
||
switch (responseType) {
|
||
case "arraybuffer":
|
||
body = new TextEncoder().encode(undecodedBody).buffer;
|
||
break;
|
||
case "blob":
|
||
body = new Blob([undecodedBody]);
|
||
break;
|
||
}
|
||
let headers = new HttpHeaders(httpHeaders);
|
||
if (typeof ngDevMode === "undefined" || ngDevMode) {
|
||
headers = appendMissingHeadersDetection(req.url, headers, headersToInclude ?? []);
|
||
}
|
||
return of(new HttpResponse({
|
||
body,
|
||
headers,
|
||
status,
|
||
statusText,
|
||
url
|
||
}));
|
||
}
|
||
return next(req).pipe(tap((event) => {
|
||
if (event instanceof HttpResponse && true && false) {
|
||
transferState.set(storeKey, {
|
||
[BODY]: event.body,
|
||
[HEADERS]: getFilteredHeaders(event.headers, headersToInclude),
|
||
[STATUS]: event.status,
|
||
[STATUS_TEXT]: event.statusText,
|
||
[REQ_URL]: requestUrl,
|
||
[RESPONSE_TYPE]: req.responseType
|
||
});
|
||
}
|
||
}));
|
||
}
|
||
function hasAuthHeaders(req) {
|
||
return req.headers.has("authorization") || req.headers.has("proxy-authorization");
|
||
}
|
||
function sortAndConcatParams(params) {
|
||
return [...params.keys()].sort().map((k) => `${k}=${params.getAll(k)}`).join("&");
|
||
}
|
||
function makeCacheKey(request, mappedRequestUrl) {
|
||
const { params, method, responseType } = request;
|
||
const encodedParams = sortAndConcatParams(params);
|
||
let serializedBody = request.serializeBody();
|
||
if (serializedBody instanceof URLSearchParams) {
|
||
serializedBody = sortAndConcatParams(serializedBody);
|
||
} else if (typeof serializedBody !== "string") {
|
||
serializedBody = "";
|
||
}
|
||
const key = [method, responseType, mappedRequestUrl, serializedBody, encodedParams].join("|");
|
||
const hash = generateHash(key);
|
||
return makeStateKey(hash);
|
||
}
|
||
function generateHash(value) {
|
||
let hash = 0;
|
||
for (const char of value) {
|
||
hash = Math.imul(31, hash) + char.charCodeAt(0) << 0;
|
||
}
|
||
hash += 2147483647 + 1;
|
||
return hash.toString();
|
||
}
|
||
function withHttpTransferCache(cacheOptions) {
|
||
return [
|
||
{
|
||
provide: CACHE_OPTIONS,
|
||
useFactory: () => {
|
||
performanceMarkFeature("NgHttpTransferCache");
|
||
return __spreadValues({ isCacheActive: true }, cacheOptions);
|
||
}
|
||
},
|
||
{
|
||
provide: HTTP_ROOT_INTERCEPTOR_FNS,
|
||
useValue: transferCacheInterceptorFn,
|
||
multi: true
|
||
},
|
||
{
|
||
provide: APP_BOOTSTRAP_LISTENER,
|
||
multi: true,
|
||
useFactory: () => {
|
||
const appRef = inject(ApplicationRef);
|
||
const cacheState = inject(CACHE_OPTIONS);
|
||
return () => {
|
||
appRef.whenStable().then(() => {
|
||
cacheState.isCacheActive = false;
|
||
});
|
||
};
|
||
}
|
||
}
|
||
];
|
||
}
|
||
function appendMissingHeadersDetection(url, headers, headersToInclude) {
|
||
const warningProduced = /* @__PURE__ */ new Set();
|
||
return new Proxy(headers, {
|
||
get(target, prop) {
|
||
const value = Reflect.get(target, prop);
|
||
const methods = /* @__PURE__ */ new Set(["get", "has", "getAll"]);
|
||
if (typeof value !== "function" || !methods.has(prop)) {
|
||
return value;
|
||
}
|
||
return (headerName) => {
|
||
const key = (prop + ":" + headerName).toLowerCase();
|
||
if (!headersToInclude.includes(headerName) && !warningProduced.has(key)) {
|
||
warningProduced.add(key);
|
||
const truncatedUrl = truncateMiddle(url);
|
||
console.warn(formatRuntimeError(2802, `Angular detected that the \`${headerName}\` header is accessed, but the value of the header was not transferred from the server to the client by the HttpTransferCache. To include the value of the \`${headerName}\` header for the \`${truncatedUrl}\` request, use the \`includeHeaders\` list. The \`includeHeaders\` can be defined either on a request level by adding the \`transferCache\` parameter, or on an application level by adding the \`httpCacheTransfer.includeHeaders\` argument to the \`provideClientHydration()\` call. `));
|
||
}
|
||
return value.apply(target, [headerName]);
|
||
};
|
||
}
|
||
});
|
||
}
|
||
|
||
// 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 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 Error("Configuration error: found both withHttpTransferCacheOptions() and withNoHttpTransferCache() in the same call to provideClientHydration(), which is a contradiction.");
|
||
}
|
||
return makeEnvironmentProviders([typeof ngDevMode !== "undefined" && ngDevMode ? provideZoneJsCompatibilityDetector() : [], withDomHydration(), featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) || hasHttpTransferCacheOptions ? [] : withHttpTransferCache({}), providers]);
|
||
}
|
||
var VERSION = new Version("20.0.4");
|
||
|
||
export {
|
||
EVENT_MANAGER_PLUGINS,
|
||
EventManager,
|
||
EventManagerPlugin,
|
||
SharedStylesHost,
|
||
REMOVE_STYLES_ON_COMPONENT_DESTROY,
|
||
DomRendererFactory2,
|
||
BrowserDomAdapter,
|
||
BrowserGetTestability,
|
||
DomEventsPlugin,
|
||
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/dom_renderer-Frqw9gM5.mjs:
|
||
@angular/platform-browser/fesm2022/browser-DKgH74dt.mjs:
|
||
@angular/common/fesm2022/module-CBsxN_3E.mjs:
|
||
@angular/common/fesm2022/http.mjs:
|
||
@angular/platform-browser/fesm2022/platform-browser.mjs:
|
||
(**
|
||
* @license Angular v20.0.4
|
||
* (c) 2010-2025 Google LLC. https://angular.io/
|
||
* License: MIT
|
||
*)
|
||
*/
|
||
//# sourceMappingURL=chunk-ZDUTSKCY.js.map
|