https://db.kaznuvhi.edu.kz/@fs/var/www/prod/.angular/cache/19.2.15…/vite/deps/chunk-DP5BB6VF.js?v=54538e92

79// node_modules/@angular/platform-browser/fesm2022/dom_renderer-DGKzginR.mjs
80var EVENT_MANAGER_PLUGINS = new InjectionToken(ngDevMode ? "EventManagerPlugins" : "");
81var EventManager = class _EventManager {
82  _zone;
83  _plugins;
84  _eventNameToPlugin = /* @__PURE__ */ new Map();
85  /**
86   * Initializes an instance of the event-manager service.
87   */
88  constructor(plugins, _zone) {
89    this._zone = _zone;
90    plugins.forEach((plugin) => {
91      plugin.manager = this;
92    });
93    this._plugins = plugins.slice().reverse();
94  }
95  /**
96   * Registers a handler for a specific element and event.
97   *
98   * @param element The HTML element to receive event notifications.
99   * @param eventName The name of the event to listen for.
100   * @param handler A function to call when the notification occurs. Receives the
101   * event object as an argument.
102   * @param options Options that configure how the event listener is bound.
103   * @returns  A callback function that can be used to remove the handler.
104   */
105  addEventListener(element, eventName, handler, options) {
106    const plugin = this._findPluginFor(eventName);
107    return plugin.addEventListener(element, eventName, handler, options);
108  }
109  /**
110   * Retrieves the compilation zone in which event listeners are registered.
111   */
112  getZone() {
113    return this._zone;
114  }
115  /** @internal */
116  _findPluginFor(eventName) {
117    let plugin = this._eventNameToPlugin.get(eventName);
118    if (plugin) {
119      return plugin;
120    }
121    const plugins = this._plugins;
122    plugin = plugins.find((plugin2) => plugin2.supports(eventName));
123    if (!plugin) {
124      throw new RuntimeError(5101, (typeof ngDevMode === "undefined" || ngDevMode) && `No event manager plugin found for event ${eventName}`);
125    }
126    this._eventNameToPlugin.set(eventName, plugin);
127    return plugin;
128  }
129  static ɵfac = function EventManager_Factory(__ngFactoryType__) {
130    return new (__ngFactoryType__ || _EventManager)(ɵɵinject(EVENT_MANAGER_PLUGINS), ɵɵinject(NgZone));
131  };
132  static ɵprov = ɵɵdefineInjectable({
133    token: _EventManager,
134    factory: _EventManager.ɵfac
135  });
136};
137(() => {
138  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EventManager, [{
139    type: Injectable
140  }], () => [{
141    type: void 0,
142    decorators: [{
143      type: Inject,
144      args: [EVENT_MANAGER_PLUGINS]
145    }]
146  }, {
147    type: NgZone
148  }], null);
149})();
150var EventManagerPlugin = class {
151  _doc;
152  // TODO: remove (has some usage in G3)
153  constructor(_doc) {
154    this._doc = _doc;
155  }
156  // Using non-null assertion because it's set by EventManager's constructor
157  manager;
158};
159var APP_ID_ATTRIBUTE_NAME = "ng-app-id";
160function removeElements(elements) {
161  for (const element of elements) {
162    element.remove();
163  }
164}
165function createStyleElement(style, doc) {
166  const styleElement = doc.createElement("style");
167  styleElement.textContent = style;
168  return styleElement;
169}
170function addServerStyles(doc, appId, inline, external) {
171  const elements = doc.head?.querySelectorAll(`style[${APP_ID_ATTRIBUTE_NAME}="${appId}"],link[${APP_ID_ATTRIBUTE_NAME}="${appId}"]`);
172  if (elements) {
173    for (const styleElement of elements) {
174      styleElement.removeAttribute(APP_ID_ATTRIBUTE_NAME);
175      if (styleElement instanceof HTMLLinkElement) {
176        external.set(styleElement.href.slice(styleElement.href.lastIndexOf("/") + 1), {
177          usage: 0,
178          elements: [styleElement]
179        });
180      } else if (styleElement.textContent) {
181        inline.set(styleElement.textContent, {
182          usage: 0,
183          elements: [styleElement]
184        });
185      }
186    }
187  }
188}
189function createLinkElement(url, doc) {
190  const linkElement = doc.createElement("link");
191  linkElement.setAttribute("rel", "stylesheet");
192  linkElement.setAttribute("href", url);
193  return linkElement;
194}
195var SharedStylesHost = class _SharedStylesHost {
196  doc;
197  appId;
198  nonce;
199  /**
200   * Provides usage information for active inline style content and associated HTML <style> elements.
201   * Embedded styles typically originate from the `styles` metadata of a rendered component.
202   */
203  inline = /* @__PURE__ */ new Map();
204  /**
205   * Provides usage information for active external style URLs and the associated HTML <link> elements.
206   * External styles typically originate from the `ɵɵExternalStylesFeature` of a rendered component.
207   */
208  external = /* @__PURE__ */ new Map();
209  /**
210   * Set of host DOM nodes that will have styles attached.
211   */
212  hosts = /* @__PURE__ */ new Set();
213  /**
214   * Whether the application code is currently executing on a server.
215   */
216  isServer;
217  constructor(doc, appId, nonce, platformId = {}) {
218    this.doc = doc;
219    this.appId = appId;
220    this.nonce = nonce;
221    this.isServer = isPlatformServer(platformId);
222    addServerStyles(doc, appId, this.inline, this.external);
223    this.hosts.add(doc.head);
224  }
225  /**
226   * Adds embedded styles to the DOM via HTML `style` elements.
227   * @param styles An array of style content strings.
228   */
229  addStyles(styles, urls) {
230    for (const value of styles) {
231      this.addUsage(value, this.inline, createStyleElement);
232    }
233    urls?.forEach((value) => this.addUsage(value, this.external, createLinkElement));
234  }
235  /**
236   * Removes embedded styles from the DOM that were added as HTML `style` elements.
237   * @param styles An array of style content strings.
238   */
239  removeStyles(styles, urls) {
240    for (const value of styles) {
241      this.removeUsage(value, this.inline);
242    }
243    urls?.forEach((value) => this.removeUsage(value, this.external));
244  }
245  addUsage(value, usages, creator) {
246    const record = usages.get(value);
247    if (record) {
248      if ((typeof ngDevMode === "undefined" || ngDevMode) && record.usage === 0) {
249        record.elements.forEach((element) => element.setAttribute("ng-style-reused", ""));
250      }
251      record.usage++;
252    } else {
253      usages.set(value, {
254        usage: 1,
255        elements: [...this.hosts].map((host) => this.addElement(host, creator(value, this.doc)))
256      });
257    }
258  }
259  removeUsage(value, usages) {
260    const record = usages.get(value);
261    if (record) {
262      record.usage--;
263      if (record.usage <= 0) {
264        removeElements(record.elements);
265        usages.delete(value);
266      }
267    }
268  }
269  ngOnDestroy() {
270    for (const [, {
271      elements
272    }] of [...this.inline, ...this.external]) {
273      removeElements(elements);
274    }
275    this.hosts.clear();
276  }
277  /**
278   * Adds a host node to the set of style hosts and adds all existing style usage to
279   * the newly added host node.
280   *
281   * This is currently only used for Shadow DOM encapsulation mode.
282   */
283  addHost(hostNode) {
284    this.hosts.add(hostNode);
285    for (const [style, {
286      elements
287    }] of this.inline) {
288      elements.push(this.addElement(hostNode, createStyleElement(style, this.doc)));
289    }
290    for (const [url, {
291      elements
292    }] of this.external) {
293      elements.push(this.addElement(hostNode, createLinkElement(url, this.doc)));
294    }
295  }
296  removeHost(hostNode) {
297    this.hosts.delete(hostNode);
298  }
299  addElement(host, element) {
300    if (this.nonce) {
301      element.setAttribute("nonce", this.nonce);
302    }
303    if (this.isServer) {
304      element.setAttribute(APP_ID_ATTRIBUTE_NAME, this.appId);
305    }
306    return host.appendChild(element);
307  }
308  static ɵfac = function SharedStylesHost_Factory(__ngFactoryType__) {
309    return new (__ngFactoryType__ || _SharedStylesHost)(ɵɵinject(DOCUMENT), ɵɵinject(APP_ID), ɵɵinject(CSP_NONCE, 8), ɵɵinject(PLATFORM_ID));
310  };
311  static ɵprov = ɵɵdefineInjectable({
312    token: _SharedStylesHost,
313    factory: _SharedStylesHost.ɵfac
314  });
315};
316(() => {
317  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SharedStylesHost, [{
318    type: Injectable
319  }], () => [{
320    type: Document,
321    decorators: [{
322      type: Inject,
323      args: [DOCUMENT]
324    }]
325  }, {
326    type: void 0,
327    decorators: [{
328      type: Inject,
329      args: [APP_ID]
330    }]
331  }, {
332    type: void 0,
333    decorators: [{
334      type: Inject,
335      args: [CSP_NONCE]
336    }, {
337      type: Optional
338    }]
339  }, {
340    type: void 0,
341    decorators: [{
342      type: Inject,
343      args: [PLATFORM_ID]
344    }]
345  }], null);
346})();
347var NAMESPACE_URIS = {
348  "svg": "http://www.w3.org/2000/svg",
349  "xhtml": "http://www.w3.org/1999/xhtml",
350  "xlink": "http://www.w3.org/1999/xlink",
351  "xml": "http://www.w3.org/XML/1998/namespace",
352  "xmlns": "http://www.w3.org/2000/xmlns/",
353  "math": "http://www.w3.org/1998/Math/MathML"
354};
355var COMPONENT_REGEX = /%COMP%/g;
356var SOURCEMAP_URL_REGEXP = /\/\*#\s*sourceMappingURL=(.+?)\s*\*\//;
357var PROTOCOL_REGEXP = /^https?:/;
358var COMPONENT_VARIABLE = "%COMP%";
359var HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
360var CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
361var REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT = true;
362var REMOVE_STYLES_ON_COMPONENT_DESTROY = new InjectionToken(ngDevMode ? "RemoveStylesOnCompDestroy" : "", {
363  providedIn: "root",
364  factory: () => REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT
365});
366function shimContentAttribute(componentShortId) {
367  return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);
368}
369function shimHostAttribute(componentShortId) {
370  return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);
371}
372function shimStylesContent(compId, styles) {
373  return styles.map((s) => s.replace(COMPONENT_REGEX, compId));
374}
375function addBaseHrefToCssSourceMap(baseHref, styles) {
376  if (!baseHref) {
377    return styles;
378  }
379  const absoluteBaseHrefUrl = new URL(baseHref, "http://localhost");
380  return styles.map((cssContent) => {
381    if (!cssContent.includes("sourceMappingURL=")) {
382      return cssContent;
383    }
384    return cssContent.replace(SOURCEMAP_URL_REGEXP, (_, sourceMapUrl) => {
385      if (sourceMapUrl[0] === "/" || sourceMapUrl.startsWith("data:") || PROTOCOL_REGEXP.test(sourceMapUrl)) {
386        return `/*# sourceMappingURL=${sourceMapUrl} */`;
387      }
388      const {
389        pathname: resolvedSourceMapUrl
390      } = new URL(sourceMapUrl, absoluteBaseHrefUrl);
391      return `/*# sourceMappingURL=${resolvedSourceMapUrl} */`;
392    });
393  });
394}
395var DomRendererFactory2 = class _DomRendererFactory2 {
396  eventManager;
397  sharedStylesHost;
398  appId;
399  removeStylesOnCompDestroy;
400  doc;
401  platformId;
402  ngZone;
403  nonce;
404  tracingService;
405  rendererByCompId = /* @__PURE__ */ new Map();
406  defaultRenderer;
407  platformIsServer;
408  constructor(eventManager, sharedStylesHost, appId, removeStylesOnCompDestroy, doc, platformId, ngZone, nonce = null, tracingService = null) {
409    this.eventManager = eventManager;
410    this.sharedStylesHost = sharedStylesHost;
411    this.appId = appId;
412    this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
413    this.doc = doc;
414    this.platformId = platformId;
415    this.ngZone = ngZone;
416    this.nonce = nonce;
417    this.tracingService = tracingService;
418    this.platformIsServer = isPlatformServer(platformId);
419    this.defaultRenderer = new DefaultDomRenderer2(eventManager, doc, ngZone, this.platformIsServer, this.tracingService);
420  }
421  createRenderer(element, type) {
422    if (!element || !type) {
423      return this.defaultRenderer;
424    }
425    if (this.platformIsServer && type.encapsulation === ViewEncapsulation.ShadowDom) {
426      type = __spreadProps(__spreadValues({}, type), {
427        encapsulation: ViewEncapsulation.Emulated
428      });
429    }
430    const renderer = this.getOrCreateRenderer(element, type);
431    if (renderer instanceof EmulatedEncapsulationDomRenderer2) {
432      renderer.applyToHost(element);
433    } else if (renderer instanceof NoneEncapsulationDomRenderer) {
434      renderer.applyStyles();
435    }
436    return renderer;
437  }
438  getOrCreateRenderer(element, type) {
439    const rendererByCompId = this.rendererByCompId;
440    let renderer = rendererByCompId.get(type.id);
441    if (!renderer) {
442      const doc = this.doc;
443      const ngZone = this.ngZone;
444      const eventManager = this.eventManager;
445      const sharedStylesHost = this.sharedStylesHost;
446      const removeStylesOnCompDestroy = this.removeStylesOnCompDestroy;
447      const platformIsServer = this.platformIsServer;
448      const tracingService = this.tracingService;
449      switch (type.encapsulation) {
450        case ViewEncapsulation.Emulated:
451          renderer = new EmulatedEncapsulationDomRenderer2(eventManager, sharedStylesHost, type, this.appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService);
452          break;
453        case ViewEncapsulation.ShadowDom:
454          return new ShadowDomRenderer(eventManager, sharedStylesHost, element, type, doc, ngZone, this.nonce, platformIsServer, tracingService);
455        default:
456          renderer = new NoneEncapsulationDomRenderer(eventManager, sharedStylesHost, type, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService);
457          break;
458      }
459      rendererByCompId.set(type.id, renderer);
460    }
461    return renderer;
462  }
463  ngOnDestroy() {
464    this.rendererByCompId.clear();
465  }
466  /**
467   * Used during HMR to clear any cached data about a component.
468   * @param componentId ID of the component that is being replaced.
469   */
470  componentReplaced(componentId) {
471    this.rendererByCompId.delete(componentId);
472  }
473  static ɵfac = function DomRendererFactory2_Factory(__ngFactoryType__) {
474    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));
475  };
476  static ɵprov = ɵɵdefineInjectable({
477    token: _DomRendererFactory2,
478    factory: _DomRendererFactory2.ɵfac
479  });
480};
481(() => {
482  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomRendererFactory2, [{
483    type: Injectable
484  }], () => [{
485    type: EventManager
486  }, {
487    type: SharedStylesHost
488  }, {
489    type: void 0,
490    decorators: [{
491      type: Inject,
492      args: [APP_ID]
493    }]
494  }, {
495    type: void 0,
496    decorators: [{
497      type: Inject,
498      args: [REMOVE_STYLES_ON_COMPONENT_DESTROY]
499    }]
500  }, {
501    type: Document,
502    decorators: [{
503      type: Inject,
504      args: [DOCUMENT]
505    }]
506  }, {
507    type: Object,
508    decorators: [{
509      type: Inject,
510      args: [PLATFORM_ID]
511    }]
512  }, {
513    type: NgZone
514  }, {
515    type: void 0,
516    decorators: [{
517      type: Inject,
518      args: [CSP_NONCE]
519    }]
520  }, {
521    type: TracingService,
522    decorators: [{
523      type: Inject,
524      args: [TracingService]
525    }, {
526      type: Optional
527    }]
528  }], null);
529})();
530var DefaultDomRenderer2 = class {
531  eventManager;
532  doc;
533  ngZone;
534  platformIsServer;
535  tracingService;
536  data = /* @__PURE__ */ Object.create(null);
537  /**
538   * By default this renderer throws when encountering synthetic properties
539   * This can be disabled for example by the AsyncAnimationRendererFactory
540   */
541  throwOnSyntheticProps = true;
542  constructor(eventManager, doc, ngZone, platformIsServer, tracingService) {
543    this.eventManager = eventManager;
544    this.doc = doc;
545    this.ngZone = ngZone;
546    this.platformIsServer = platformIsServer;
547    this.tracingService = tracingService;
548  }
549  destroy() {
550  }
551  destroyNode = null;
552  createElement(name, namespace) {
553    if (namespace) {
554      return this.doc.createElementNS(NAMESPACE_URIS[namespace] || namespace, name);
555    }
556    return this.doc.createElement(name);
557  }
558  createComment(value) {
559    return this.doc.createComment(value);
560  }
561  createText(value) {
562    return this.doc.createTextNode(value);
563  }
564  appendChild(parent, newChild) {
565    const targetParent = isTemplateNode(parent) ? parent.content : parent;
566    targetParent.appendChild(newChild);
567  }
568  insertBefore(parent, newChild, refChild) {
569    if (parent) {
570      const targetParent = isTemplateNode(parent) ? parent.content : parent;
571      targetParent.insertBefore(newChild, refChild);
572    }
573  }
574  removeChild(_parent, oldChild) {
575    oldChild.remove();
576  }
577  selectRootElement(selectorOrNode, preserveContent) {
578    let el = typeof selectorOrNode === "string" ? this.doc.querySelector(selectorOrNode) : selectorOrNode;
579    if (!el) {
580      throw new RuntimeError(-5104, (typeof ngDevMode === "undefined" || ngDevMode) && `The selector "${selectorOrNode}" did not match any elements`);
581    }
582    if (!preserveContent) {
583      el.textContent = "";
584    }
585    return el;
586  }
587  parentNode(node) {
588    return node.parentNode;
589  }
590  nextSibling(node) {
591    return node.nextSibling;
592  }
593  setAttribute(el, name, value, namespace) {
594    if (namespace) {
595      name = namespace + ":" + name;
596      const namespaceUri = NAMESPACE_URIS[namespace];
597      if (namespaceUri) {
598        el.setAttributeNS(namespaceUri, name, value);
599      } else {
600        el.setAttribute(name, value);
601      }
602    } else {
603      el.setAttribute(name, value);
604    }
605  }
606  removeAttribute(el, name, namespace) {
607    if (namespace) {
608      const namespaceUri = NAMESPACE_URIS[namespace];
609      if (namespaceUri) {
610        el.removeAttributeNS(namespaceUri, name);
611      } else {
612        el.removeAttribute(`${namespace}:${name}`);
613      }
614    } else {
615      el.removeAttribute(name);
616    }
617  }
618  addClass(el, name) {
619    el.classList.add(name);
620  }
621  removeClass(el, name) {
622    el.classList.remove(name);
623  }
624  setStyle(el, style, value, flags) {
625    if (flags & (RendererStyleFlags2.DashCase | RendererStyleFlags2.Important)) {
626      el.style.setProperty(style, value, flags & RendererStyleFlags2.Important ? "important" : "");
627    } else {
628      el.style[style] = value;
629    }
630  }
631  removeStyle(el, style, flags) {
632    if (flags & RendererStyleFlags2.DashCase) {
633      el.style.removeProperty(style);
634    } else {
635      el.style[style] = "";
636    }
637  }
638  setProperty(el, name, value) {
639    if (el == null) {
640      return;
641    }
642    (typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(name, "property");
643    el[name] = value;
644  }
645  setValue(node, value) {
646    node.nodeValue = value;
647  }
648  listen(target, event, callback, options) {
649    (typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(event, "listener");
650    if (typeof target === "string") {
651      target = getDOM().getGlobalEventTarget(this.doc, target);
652      if (!target) {
653        throw new RuntimeError(5102, (typeof ngDevMode === "undefined" || ngDevMode) && `Unsupported event target ${target} for event ${event}`);
654      }
655    }
656    let wrappedCallback = this.decoratePreventDefault(callback);
657    if (this.tracingService?.wrapEventListener) {
658      wrappedCallback = this.tracingService.wrapEventListener(target, event, wrappedCallback);
659    }
660    return this.eventManager.addEventListener(target, event, wrappedCallback, options);
661  }
662  decoratePreventDefault(eventHandler) {
663    return (event) => {
664      if (event === "__ngUnwrap__") {
665        return eventHandler;
666      }
667      const allowDefaultBehavior = this.platformIsServer ? this.ngZone.runGuarded(() => eventHandler(event)) : eventHandler(event);
668      if (allowDefaultBehavior === false) {
669        event.preventDefault();
670      }
671      return void 0;
672    };
673  }
674};
675var AT_CHARCODE = (() => "@".charCodeAt(0))();
676function checkNoSyntheticProp(name, nameKind) {
677  if (name.charCodeAt(0) === AT_CHARCODE) {
678    throw new RuntimeError(5105, `Unexpected synthetic ${nameKind} ${name} found. Please make sure that:
679  - Make sure \`provideAnimationsAsync()\`, \`provideAnimations()\` or \`provideNoopAnimations()\` call was added to a list of providers used to bootstrap an application.
680  - 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).`);
681  }
682}
683function isTemplateNode(node) {
684  return node.tagName === "TEMPLATE" && node.content !== void 0;
685}
686var ShadowDomRenderer = class extends DefaultDomRenderer2 {
687  sharedStylesHost;
688  hostEl;
689  shadowRoot;
690  constructor(eventManager, sharedStylesHost, hostEl, component, doc, ngZone, nonce, platformIsServer, tracingService) {
691    super(eventManager, doc, ngZone, platformIsServer, tracingService);
692    this.sharedStylesHost = sharedStylesHost;
693    this.hostEl = hostEl;
694    this.shadowRoot = hostEl.attachShadow({
695      mode: "open"
696    });
697    this.sharedStylesHost.addHost(this.shadowRoot);
698    let styles = component.styles;
699    if (ngDevMode) {
700      const baseHref = getDOM().getBaseHref(doc) ?? "";
701      styles = addBaseHrefToCssSourceMap(baseHref, styles);
702    }
703    styles = shimStylesContent(component.id, styles);
704    for (const style of styles) {
705      const styleEl = document.createElement("style");
706      if (nonce) {
707        styleEl.setAttribute("nonce", nonce);
708      }
709      styleEl.textContent = style;
710      this.shadowRoot.appendChild(styleEl);
711    }
712    const styleUrls = component.getExternalStyles?.();
713    if (styleUrls) {
714      for (const styleUrl of styleUrls) {
715        const linkEl = createLinkElement(styleUrl, doc);
716        if (nonce) {
717          linkEl.setAttribute("nonce", nonce);
718        }
719        this.shadowRoot.appendChild(linkEl);
720      }
721    }
722  }
723  nodeOrShadowRoot(node) {
724    return node === this.hostEl ? this.shadowRoot : node;
725  }
726  appendChild(parent, newChild) {
727    return super.appendChild(this.nodeOrShadowRoot(parent), newChild);
728  }
729  insertBefore(parent, newChild, refChild) {
730    return super.insertBefore(this.nodeOrShadowRoot(parent), newChild, refChild);
731  }
732  removeChild(_parent, oldChild) {
733    return super.removeChild(null, oldChild);
734  }
735  parentNode(node) {
736    return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));
737  }
738  destroy() {
739    this.sharedStylesHost.removeHost(this.shadowRoot);
740  }
741};
742var NoneEncapsulationDomRenderer = class extends DefaultDomRenderer2 {
743  sharedStylesHost;
744  removeStylesOnCompDestroy;
745  styles;
746  styleUrls;
747  constructor(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService, compId) {
748    super(eventManager, doc, ngZone, platformIsServer, tracingService);
749    this.sharedStylesHost = sharedStylesHost;
750    this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
751    let styles = component.styles;
752    if (ngDevMode) {
753      const baseHref = getDOM().getBaseHref(doc) ?? "";
754      styles = addBaseHrefToCssSourceMap(baseHref, styles);
755    }
756    this.styles = compId ? shimStylesContent(compId, styles) : styles;
757    this.styleUrls = component.getExternalStyles?.(compId);
758  }
759  applyStyles() {
760    this.sharedStylesHost.addStyles(this.styles, this.styleUrls);
761  }
762  destroy() {
763    if (!this.removeStylesOnCompDestroy) {
764      return;
765    }
766    this.sharedStylesHost.removeStyles(this.styles, this.styleUrls);
767  }
768};
769var EmulatedEncapsulationDomRenderer2 = class extends NoneEncapsulationDomRenderer {
770  contentAttr;
771  hostAttr;
772  constructor(eventManager, sharedStylesHost, component, appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService) {
773    const compId = appId + "-" + component.id;
774    super(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, tracingService, compId);
775    this.contentAttr = shimContentAttribute(compId);
776    this.hostAttr = shimHostAttribute(compId);
777  }
778  applyToHost(element) {
779    this.applyStyles();
780    this.setAttribute(element, this.hostAttr, "");
781  }
782  createElement(parent, name) {
783    const el = super.createElement(parent, name);
784    super.setAttribute(el, this.contentAttr, "");
785    return el;
786  }
787};
788

789// node_modules/@angular/platform-browser/fesm2022/browser-D-u-fknz.mjs
790var BrowserDomAdapter = class _BrowserDomAdapter extends DomAdapter {
791  supportsDOMEvents = true;
792  static makeCurrent() {
793    setRootDomAdapter(new _BrowserDomAdapter());
794  }
795  onAndCancel(el, evt, listener, options) {
796    el.addEventListener(evt, listener, options);
797    return () => {
798      el.removeEventListener(evt, listener, options);
799    };
800  }
801  dispatchEvent(el, evt) {
802    el.dispatchEvent(evt);
803  }
804  remove(node) {
805    node.remove();
806  }
807  createElement(tagName, doc) {
808    doc = doc || this.getDefaultDocument();
809    return doc.createElement(tagName);
810  }
811  createHtmlDocument() {
812    return document.implementation.createHTMLDocument("fakeTitle");
813  }
814  getDefaultDocument() {
815    return document;
816  }
817  isElementNode(node) {
818    return node.nodeType === Node.ELEMENT_NODE;
819  }
820  isShadowRoot(node) {
821    return node instanceof DocumentFragment;
822  }
823  /** @deprecated No longer being used in Ivy code. To be removed in version 14. */
824  getGlobalEventTarget(doc, target) {
825    if (target === "window") {
826      return window;
827    }
828    if (target === "document") {
829      return doc;
830    }
831    if (target === "body") {
832      return doc.body;
833    }
834    return null;
835  }
836  getBaseHref(doc) {
837    const href = getBaseElementHref();
838    return href == null ? null : relativePath(href);
839  }
840  resetBaseElement() {
841    baseElement = null;
842  }
843  getUserAgent() {
844    return window.navigator.userAgent;
845  }
846  getCookie(name) {
847    return parseCookieValue(document.cookie, name);
848  }
849};
850var baseElement = null;
851function getBaseElementHref() {
852  baseElement = baseElement || document.head.querySelector("base");
853  return baseElement ? baseElement.getAttribute("href") : null;
854}
855function relativePath(url) {
856  return new URL(url, document.baseURI).pathname;
857}
858var BrowserGetTestability = class {
859  addToWindow(registry) {
860    _global["getAngularTestability"] = (elem, findInAncestors = true) => {
861      const testability = registry.findTestabilityInTree(elem, findInAncestors);
862      if (testability == null) {
863        throw new RuntimeError(5103, (typeof ngDevMode === "undefined" || ngDevMode) && "Could not find testability for element.");
864      }
865      return testability;
866    };
867    _global["getAllAngularTestabilities"] = () => registry.getAllTestabilities();
868    _global["getAllAngularRootElements"] = () => registry.getAllRootElements();
869    const whenAllStable = (callback) => {
870      const testabilities = _global["getAllAngularTestabilities"]();
871      let count = testabilities.length;
872      const decrement = function() {
873        count--;
874        if (count == 0) {
875          callback();
876        }
877      };
878      testabilities.forEach((testability) => {
879        testability.whenStable(decrement);
880      });
881    };
882    if (!_global["frameworkStabilizers"]) {
883      _global["frameworkStabilizers"] = [];
884    }
885    _global["frameworkStabilizers"].push(whenAllStable);
886  }
887  findTestabilityInTree(registry, elem, findInAncestors) {
888    if (elem == null) {
889      return null;
890    }
891    const t = registry.getTestability(elem);
892    if (t != null) {
893      return t;
894    } else if (!findInAncestors) {
895      return null;
896    }
897    if (getDOM().isShadowRoot(elem)) {
898      return this.findTestabilityInTree(registry, elem.host, true);
899    }
900    return this.findTestabilityInTree(registry, elem.parentElement, true);
901  }
902};
903var BrowserXhr = class _BrowserXhr {
904  build() {
905    return new XMLHttpRequest();
906  }
907  static ɵfac = function BrowserXhr_Factory(__ngFactoryType__) {
908    return new (__ngFactoryType__ || _BrowserXhr)();
909  };
910  static ɵprov = ɵɵdefineInjectable({
911    token: _BrowserXhr,
912    factory: _BrowserXhr.ɵfac
913  });
914};
915(() => {
916  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserXhr, [{
917    type: Injectable
918  }], null, null);
919})();
920var DomEventsPlugin = class _DomEventsPlugin extends EventManagerPlugin {
921  constructor(doc) {
922    super(doc);
923  }
924  // This plugin should come last in the list of plugins, because it accepts all
925  // events.
926  supports(eventName) {
927    return true;
928  }
929  addEventListener(element, eventName, handler, options) {
930    element.addEventListener(eventName, handler, options);
931    return () => this.removeEventListener(element, eventName, handler, options);
932  }
933  removeEventListener(target, eventName, callback, options) {
934    return target.removeEventListener(eventName, callback, options);
935  }
936  static ɵfac = function DomEventsPlugin_Factory(__ngFactoryType__) {
937    return new (__ngFactoryType__ || _DomEventsPlugin)(ɵɵinject(DOCUMENT));
938  };
939  static ɵprov = ɵɵdefineInjectable({
940    token: _DomEventsPlugin,
941    factory: _DomEventsPlugin.ɵfac
942  });
943};
944(() => {
945  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomEventsPlugin, [{
946    type: Injectable
947  }], () => [{
948    type: void 0,
949    decorators: [{
950      type: Inject,
951      args: [DOCUMENT]
952    }]
953  }], null);
954})();
955var MODIFIER_KEYS = ["alt", "control", "meta", "shift"];
956var _keyMap = {
957  "\b": "Backspace",
958  "	": "Tab",
959  "�": "Delete",
960  "\x1B": "Escape",
961  "Del": "Delete",
962  "Esc": "Escape",
963  "Left": "ArrowLeft",
964  "Right": "ArrowRight",
965  "Up": "ArrowUp",
966  "Down": "ArrowDown",
967  "Menu": "ContextMenu",
968  "Scroll": "ScrollLock",
969  "Win": "OS"
970};
971var MODIFIER_KEY_GETTERS = {
972  "alt": (event) => event.altKey,
973  "control": (event) => event.ctrlKey,
974  "meta": (event) => event.metaKey,
975  "shift": (event) => event.shiftKey
976};
977var KeyEventsPlugin = class _KeyEventsPlugin extends EventManagerPlugin {
978  /**
979   * Initializes an instance of the browser plug-in.
980   * @param doc The document in which key events will be detected.
981   */
982  constructor(doc) {
983    super(doc);
984  }
985  /**
986   * Reports whether a named key event is supported.
987   * @param eventName The event name to query.
988   * @return True if the named key event is supported.
989   */
990  supports(eventName) {
991    return _KeyEventsPlugin.parseEventName(eventName) != null;
992  }
993  /**
994   * Registers a handler for a specific element and key event.
995   * @param element The HTML element to receive event notifications.
996   * @param eventName The name of the key event to listen for.
997   * @param handler A function to call when the notification occurs. Receives the
998   * event object as an argument.
999   * @returns The key event that was registered.
1000   */
1001  addEventListener(element, eventName, handler, options) {
1002    const parsedEvent = _KeyEventsPlugin.parseEventName(eventName);
1003    const outsideHandler = _KeyEventsPlugin.eventCallback(parsedEvent["fullKey"], handler, this.manager.getZone());
1004    return this.manager.getZone().runOutsideAngular(() => {
1005      return getDOM().onAndCancel(element, parsedEvent["domEventName"], outsideHandler, options);
1006    });
1007  }
1008  /**
1009   * Parses the user provided full keyboard event definition and normalizes it for
1010   * later internal use. It ensures the string is all lowercase, converts special
1011   * characters to a standard spelling, and orders all the values consistently.
1012   *
1013   * @param eventName The name of the key event to listen for.
1014   * @returns an object with the full, normalized string, and the dom event name
1015   * or null in the case when the event doesn't match a keyboard event.
1016   */
1017  static parseEventName(eventName) {
1018    const parts = eventName.toLowerCase().split(".");
1019    const domEventName = parts.shift();
1020    if (parts.length === 0 || !(domEventName === "keydown" || domEventName === "keyup")) {
1021      return null;
1022    }
1023    const key = _KeyEventsPlugin._normalizeKey(parts.pop());
1024    let fullKey = "";
1025    let codeIX = parts.indexOf("code");
1026    if (codeIX > -1) {
1027      parts.splice(codeIX, 1);
1028      fullKey = "code.";
1029    }
1030    MODIFIER_KEYS.forEach((modifierName) => {
1031      const index = parts.indexOf(modifierName);
1032      if (index > -1) {
1033        parts.splice(index, 1);
1034        fullKey += modifierName + ".";
1035      }
1036    });
1037    fullKey += key;
1038    if (parts.length != 0 || key.length === 0) {
1039      return null;
1040    }
1041    const result = {};
1042    result["domEventName"] = domEventName;
1043    result["fullKey"] = fullKey;
1044    return result;
1045  }
1046  /**
1047   * Determines whether the actual keys pressed match the configured key code string.
1048   * The `fullKeyCode` event is normalized in the `parseEventName` method when the
1049   * event is attached to the DOM during the `addEventListener` call. This is unseen
1050   * by the end user and is normalized for internal consistency and parsing.
1051   *
1052   * @param event The keyboard event.
1053   * @param fullKeyCode The normalized user defined expected key event string
1054   * @returns boolean.
1055   */
1056  static matchEventFullKeyCode(event, fullKeyCode) {
1057    let keycode = _keyMap[event.key] || event.key;
1058    let key = "";
1059    if (fullKeyCode.indexOf("code.") > -1) {
1060      keycode = event.code;
1061      key = "code.";
1062    }
1063    if (keycode == null || !keycode) return false;
1064    keycode = keycode.toLowerCase();
1065    if (keycode === " ") {
1066      keycode = "space";
1067    } else if (keycode === ".") {
1068      keycode = "dot";
1069    }
1070    MODIFIER_KEYS.forEach((modifierName) => {
1071      if (modifierName !== keycode) {
1072        const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];
1073        if (modifierGetter(event)) {
1074          key += modifierName + ".";
1075        }
1076      }
1077    });
1078    key += keycode;
1079    return key === fullKeyCode;
1080  }
1081  /**
1082   * Configures a handler callback for a key event.
1083   * @param fullKey The event name that combines all simultaneous keystrokes.
1084   * @param handler The function that responds to the key event.
1085   * @param zone The zone in which the event occurred.
1086   * @returns A callback function.
1087   */
1088  static eventCallback(fullKey, handler, zone) {
1089    return (event) => {
1090      if (_KeyEventsPlugin.matchEventFullKeyCode(event, fullKey)) {
1091        zone.runGuarded(() => handler(event));
1092      }
1093    };
1094  }
1095  /** @internal */
1096  static _normalizeKey(keyName) {
1097    return keyName === "esc" ? "escape" : keyName;
1098  }
1099  static ɵfac = function KeyEventsPlugin_Factory(__ngFactoryType__) {
1100    return new (__ngFactoryType__ || _KeyEventsPlugin)(ɵɵinject(DOCUMENT));
1101  };
1102  static ɵprov = ɵɵdefineInjectable({
1103    token: _KeyEventsPlugin,
1104    factory: _KeyEventsPlugin.ɵfac
1105  });
1106};
1107(() => {
1108  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(KeyEventsPlugin, [{
1109    type: Injectable
1110  }], () => [{
1111    type: void 0,
1112    decorators: [{
1113      type: Inject,
1114      args: [DOCUMENT]
1115    }]
1116  }], null);
1117})();
1118function bootstrapApplication(rootComponent, options) {
1119  return internalCreateApplication(__spreadValues({
1120    rootComponent
1121  }, createProvidersConfig(options)));
1122}
1123function createApplication(options) {
1124  return internalCreateApplication(createProvidersConfig(options));
1125}
1126function createProvidersConfig(options) {
1127  return {
1128    appProviders: [...BROWSER_MODULE_PROVIDERS, ...options?.providers ?? []],
1129    platformProviders: INTERNAL_BROWSER_PLATFORM_PROVIDERS
1130  };
1131}
1132function provideProtractorTestingSupport() {
1133  return [...TESTABILITY_PROVIDERS];
1134}
1135function initDomAdapter() {
1136  BrowserDomAdapter.makeCurrent();
1137}
1138function errorHandler() {
1139  return new ErrorHandler();
1140}
1141function _document() {
1142  setDocument(document);
1143  return document;
1144}
1145var INTERNAL_BROWSER_PLATFORM_PROVIDERS = [{
1146  provide: PLATFORM_ID,
1147  useValue: PLATFORM_BROWSER_ID
1148}, {
1149  provide: PLATFORM_INITIALIZER,
1150  useValue: initDomAdapter,
1151  multi: true
1152}, {
1153  provide: DOCUMENT,
1154  useFactory: _document
1155}];
1156var platformBrowser = createPlatformFactory(platformCore, "browser", INTERNAL_BROWSER_PLATFORM_PROVIDERS);
1157var BROWSER_MODULE_PROVIDERS_MARKER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "BrowserModule Providers Marker" : "");
1158var TESTABILITY_PROVIDERS = [{
1159  provide: TESTABILITY_GETTER,
1160  useClass: BrowserGetTestability
1161}, {
1162  provide: TESTABILITY,
1163  useClass: Testability,
1164  deps: [NgZone, TestabilityRegistry, TESTABILITY_GETTER]
1165}, {
1166  provide: Testability,
1167  // Also provide as `Testability` for backwards-compatibility.
1168  useClass: Testability,
1169  deps: [NgZone, TestabilityRegistry, TESTABILITY_GETTER]
1170}];
1171var BROWSER_MODULE_PROVIDERS = [{
1172  provide: INJECTOR_SCOPE,
1173  useValue: "root"
1174}, {
1175  provide: ErrorHandler,
1176  useFactory: errorHandler
1177}, {
1178  provide: EVENT_MANAGER_PLUGINS,
1179  useClass: DomEventsPlugin,
1180  multi: true,
1181  deps: [DOCUMENT]
1182}, {
1183  provide: EVENT_MANAGER_PLUGINS,
1184  useClass: KeyEventsPlugin,
1185  multi: true,
1186  deps: [DOCUMENT]
1187}, DomRendererFactory2, SharedStylesHost, EventManager, {
1188  provide: RendererFactory2,
1189  useExisting: DomRendererFactory2
1190}, {
1191  provide: XhrFactory,
1192  useClass: BrowserXhr
1193}, typeof ngDevMode === "undefined" || ngDevMode ? {
1194  provide: BROWSER_MODULE_PROVIDERS_MARKER,
1195  useValue: true
1196} : []];
1197var BrowserModule = class _BrowserModule {
1198  constructor() {
1199    if (typeof ngDevMode === "undefined" || ngDevMode) {
1200      const providersAlreadyPresent = inject(BROWSER_MODULE_PROVIDERS_MARKER, {
1201        optional: true,
1202        skipSelf: true
1203      });
1204      if (providersAlreadyPresent) {
1205        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.`);
1206      }
1207    }
1208  }
1209  static ɵfac = function BrowserModule_Factory(__ngFactoryType__) {
1210    return new (__ngFactoryType__ || _BrowserModule)();
1211  };
1212  static ɵmod = ɵɵdefineNgModule({
1213    type: _BrowserModule,
1214    exports: [CommonModule, ApplicationModule]
1215  });
1216  static ɵinj = ɵɵdefineInjector({
1217    providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
1218    imports: [CommonModule, ApplicationModule]
1219  });
1220};
1221(() => {
1222  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserModule, [{
1223    type: NgModule,
1224    args: [{
1225      providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
1226      exports: [CommonModule, ApplicationModule]
1227    }]
1228  }], () => [], null);
1229})();
1230

1231// node_modules/@angular/platform-browser/fesm2022/platform-browser.mjs
1232var Meta = class _Meta {
1233  _doc;
1234  _dom;
1235  constructor(_doc) {
1236    this._doc = _doc;
1237    this._dom = getDOM();
1238  }
1239  /**
1240   * Retrieves or creates a specific `<meta>` tag element in the current HTML document.
1241   * In searching for an existing tag, Angular attempts to match the `name` or `property` attribute
1242   * values in the provided tag definition, and verifies that all other attribute values are equal.
1243   * If an existing element is found, it is returned and is not modified in any way.
1244   * @param tag The definition of a `<meta>` element to match or create.
1245   * @param forceCreation True to create a new element without checking whether one already exists.
1246   * @returns The existing element with the same attributes and values if found,
1247   * the new element if no match is found, or `null` if the tag parameter is not defined.
1248   */
1249  addTag(tag, forceCreation = false) {
1250    if (!tag) return null;
1251    return this._getOrCreateElement(tag, forceCreation);
1252  }
1253  /**
1254   * Retrieves or creates a set of `<meta>` tag elements in the current HTML document.
1255   * In searching for an existing tag, Angular attempts to match the `name` or `property` attribute
1256   * values in the provided tag definition, and verifies that all other attribute values are equal.
1257   * @param tags An array of tag definitions to match or create.
1258   * @param forceCreation True to create new elements without checking whether they already exist.
1259   * @returns The matching elements if found, or the new elements.
1260   */
1261  addTags(tags, forceCreation = false) {
1262    if (!tags) return [];
1263    return tags.reduce((result, tag) => {
1264      if (tag) {
1265        result.push(this._getOrCreateElement(tag, forceCreation));
1266      }
1267      return result;
1268    }, []);
1269  }
1270  /**
1271   * Retrieves a `<meta>` tag element in the current HTML document.
1272   * @param attrSelector The tag attribute and value to match against, in the format
1273   * `"tag_attribute='value string'"`.
1274   * @returns The matching element, if any.
1275   */
1276  getTag(attrSelector) {
1277    if (!attrSelector) return null;
1278    return this._doc.querySelector(`meta[${attrSelector}]`) || null;
1279  }
1280  /**
1281   * Retrieves a set of `<meta>` tag elements in the current HTML document.
1282   * @param attrSelector The tag attribute and value to match against, in the format
1283   * `"tag_attribute='value string'"`.
1284   * @returns The matching elements, if any.
1285   */
1286  getTags(attrSelector) {
1287    if (!attrSelector) return [];
1288    const list = this._doc.querySelectorAll(`meta[${attrSelector}]`);
1289    return list ? [].slice.call(list) : [];
1290  }
1291  /**
1292   * Modifies an existing `<meta>` tag element in the current HTML document.
1293   * @param tag The tag description with which to replace the existing tag content.
1294   * @param selector A tag attribute and value to match against, to identify
1295   * an existing tag. A string in the format `"tag_attribute=`value string`"`.
1296   * If not supplied, matches a tag with the same `name` or `property` attribute value as the
1297   * replacement tag.
1298   * @return The modified element.
1299   */
1300  updateTag(tag, selector) {
1301    if (!tag) return null;
1302    selector = selector || this._parseSelector(tag);
1303    const meta = this.getTag(selector);
1304    if (meta) {
1305      return this._setMetaElementAttributes(tag, meta);
1306    }
1307    return this._getOrCreateElement(tag, true);
1308  }
1309  /**
1310   * Removes an existing `<meta>` tag element from the current HTML document.
1311   * @param attrSelector A tag attribute and value to match against, to identify
1312   * an existing tag. A string in the format `"tag_attribute=`value string`"`.
1313   */
1314  removeTag(attrSelector) {
1315    this.removeTagElement(this.getTag(attrSelector));
1316  }
1317  /**
1318   * Removes an existing `<meta>` tag element from the current HTML document.
1319   * @param meta The tag definition to match against to identify an existing tag.
1320   */
1321  removeTagElement(meta) {
1322    if (meta) {
1323      this._dom.remove(meta);
1324    }
1325  }
1326  _getOrCreateElement(meta, forceCreation = false) {
1327    if (!forceCreation) {
1328      const selector = this._parseSelector(meta);
1329      const elem = this.getTags(selector).filter((elem2) => this._containsAttributes(meta, elem2))[0];
1330      if (elem !== void 0) return elem;
1331    }
1332    const element = this._dom.createElement("meta");
1333    this._setMetaElementAttributes(meta, element);
1334    const head = this._doc.getElementsByTagName("head")[0];
1335    head.appendChild(element);
1336    return element;
1337  }
1338  _setMetaElementAttributes(tag, el) {
1339    Object.keys(tag).forEach((prop) => el.setAttribute(this._getMetaKeyMap(prop), tag[prop]));
1340    return el;
1341  }
1342  _parseSelector(tag) {
1343    const attr = tag.name ? "name" : "property";
1344    return `${attr}="${tag[attr]}"`;
1345  }
1346  _containsAttributes(tag, elem) {
1347    return Object.keys(tag).every((key) => elem.getAttribute(this._getMetaKeyMap(key)) === tag[key]);
1348  }
1349  _getMetaKeyMap(prop) {
1350    return META_KEYS_MAP[prop] || prop;
1351  }
1352  static ɵfac = function Meta_Factory(__ngFactoryType__) {
1353    return new (__ngFactoryType__ || _Meta)(ɵɵinject(DOCUMENT));
1354  };
1355  static ɵprov = ɵɵdefineInjectable({
1356    token: _Meta,
1357    factory: _Meta.ɵfac,
1358    providedIn: "root"
1359  });
1360};
1361(() => {
1362  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Meta, [{
1363    type: Injectable,
1364    args: [{
1365      providedIn: "root"
1366    }]
1367  }], () => [{
1368    type: void 0,
1369    decorators: [{
1370      type: Inject,
1371      args: [DOCUMENT]
1372    }]
1373  }], null);
1374})();
1375var META_KEYS_MAP = {
1376  httpEquiv: "http-equiv"
1377};
1378var Title = class _Title {
1379  _doc;
1380  constructor(_doc) {
1381    this._doc = _doc;
1382  }
1383  /**
1384   * Get the title of the current HTML document.
1385   */
1386  getTitle() {
1387    return this._doc.title;
1388  }
1389  /**
1390   * Set the title of the current HTML document.
1391   * @param newTitle
1392   */
1393  setTitle(newTitle) {
1394    this._doc.title = newTitle || "";
1395  }
1396  static ɵfac = function Title_Factory(__ngFactoryType__) {
1397    return new (__ngFactoryType__ || _Title)(ɵɵinject(DOCUMENT));
1398  };
1399  static ɵprov = ɵɵdefineInjectable({
1400    token: _Title,
1401    factory: _Title.ɵfac,
1402    providedIn: "root"
1403  });
1404};
1405(() => {
1406  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Title, [{
1407    type: Injectable,
1408    args: [{
1409      providedIn: "root"
1410    }]
1411  }], () => [{
1412    type: void 0,
1413    decorators: [{
1414      type: Inject,
1415      args: [DOCUMENT]
1416    }]
1417  }], null);
1418})();
1419function exportNgVar(name, value) {
1420  if (typeof COMPILED === "undefined" || !COMPILED) {
1421    const ng = _global["ng"] = _global["ng"] || {};
1422    ng[name] = value;
1423  }
1424}
1425var ChangeDetectionPerfRecord = class {
1426  msPerTick;
1427  numTicks;
1428  constructor(msPerTick, numTicks) {
1429    this.msPerTick = msPerTick;
1430    this.numTicks = numTicks;
1431  }
1432};
1433var AngularProfiler = class {
1434  appRef;
1435  constructor(ref) {
1436    this.appRef = ref.injector.get(ApplicationRef);
1437  }
1438  // tslint:disable:no-console
1439  /**
1440   * Exercises change detection in a loop and then prints the average amount of
1441   * time in milliseconds how long a single round of change detection takes for
1442   * the current state of the UI. It runs a minimum of 5 rounds for a minimum
1443   * of 500 milliseconds.
1444   *
1445   * Optionally, a user may pass a `config` parameter containing a map of
1446   * options. Supported options are:
1447   *
1448   * `record` (boolean) - causes the profiler to record a CPU profile while
1449   * it exercises the change detector. Example:
1450   *
1451   * ```ts
1452   * ng.profiler.timeChangeDetection({record: true})
1453   * ```
1454   */
1455  timeChangeDetection(config) {
1456    const record = config && config["record"];
1457    const profileName = "Change Detection";
1458    if (record && "profile" in console && typeof console.profile === "function") {
1459      console.profile(profileName);
1460    }
1461    const start = performance.now();
1462    let numTicks = 0;
1463    while (numTicks < 5 || performance.now() - start < 500) {
1464      this.appRef.tick();
1465      numTicks++;
1466    }
1467    const end = performance.now();
1468    if (record && "profileEnd" in console && typeof console.profileEnd === "function") {
1469      console.profileEnd(profileName);
1470    }
1471    const msPerTick = (end - start) / numTicks;
1472    console.log(`ran ${numTicks} change detection cycles`);
1473    console.log(`${msPerTick.toFixed(2)} ms per check`);
1474    return new ChangeDetectionPerfRecord(msPerTick, numTicks);
1475  }
1476};
1477var PROFILER_GLOBAL_NAME = "profiler";
1478function enableDebugTools(ref) {
1479  exportNgVar(PROFILER_GLOBAL_NAME, new AngularProfiler(ref));
1480  return ref;
1481}
1482function disableDebugTools() {
1483  exportNgVar(PROFILER_GLOBAL_NAME, null);
1484}
1485var By = class {
1486  /**
1487   * Match all nodes.
1488   *
1489   * @usageNotes
1490   * ### Example
1491   *
1492   * {@example platform-browser/dom/debug/ts/by/by.ts region='by_all'}
1493   */
1494  static all() {
1495    return () => true;
1496  }
1497  /**
1498   * Match elements by the given CSS selector.
1499   *
1500   * @usageNotes
1501   * ### Example
1502   *
1503   * {@example platform-browser/dom/debug/ts/by/by.ts region='by_css'}
1504   */
1505  static css(selector) {
1506    return (debugElement) => {
1507      return debugElement.nativeElement != null ? elementMatches(debugElement.nativeElement, selector) : false;
1508    };
1509  }
1510  /**
1511   * Match nodes that have the given directive present.
1512   *
1513   * @usageNotes
1514   * ### Example
1515   *
1516   * {@example platform-browser/dom/debug/ts/by/by.ts region='by_directive'}
1517   */
1518  static directive(type) {
1519    return (debugNode) => debugNode.providerTokens.indexOf(type) !== -1;
1520  }
1521};
1522function elementMatches(n, selector) {
1523  if (getDOM().isElementNode(n)) {
1524    return n.matches && n.matches(selector) || n.msMatchesSelector && n.msMatchesSelector(selector) || n.webkitMatchesSelector && n.webkitMatchesSelector(selector);
1525  }
1526  return false;
1527}
1528var EVENT_NAMES = {
1529  // pan
1530  "pan": true,
1531  "panstart": true,
1532  "panmove": true,
1533  "panend": true,
1534  "pancancel": true,
1535  "panleft": true,
1536  "panright": true,
1537  "panup": true,
1538  "pandown": true,
1539  // pinch
1540  "pinch": true,
1541  "pinchstart": true,
1542  "pinchmove": true,
1543  "pinchend": true,
1544  "pinchcancel": true,
1545  "pinchin": true,
1546  "pinchout": true,
1547  // press
1548  "press": true,
1549  "pressup": true,
1550  // rotate
1551  "rotate": true,
1552  "rotatestart": true,
1553  "rotatemove": true,
1554  "rotateend": true,
1555  "rotatecancel": true,
1556  // swipe
1557  "swipe": true,
1558  "swipeleft": true,
1559  "swiperight": true,
1560  "swipeup": true,
1561  "swipedown": true,
1562  // tap
1563  "tap": true,
1564  "doubletap": true
1565};
1566var HAMMER_GESTURE_CONFIG = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "HammerGestureConfig" : "");
1567var HAMMER_LOADER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "HammerLoader" : "");
1568var HammerGestureConfig = class _HammerGestureConfig {
1569  /**
1570   * A set of supported event names for gestures to be used in Angular.
1571   * Angular supports all built-in recognizers, as listed in
1572   * [HammerJS documentation](https://hammerjs.github.io/).
1573   */
1574  events = [];
1575  /**
1576   * Maps gesture event names to a set of configuration options
1577   * that specify overrides to the default values for specific properties.
1578   *
1579   * The key is a supported event name to be configured,
1580   * and the options object contains a set of properties, with override values
1581   * to be applied to the named recognizer event.
1582   * For example, to disable recognition of the rotate event, specify
1583   *  `{"rotate": {"enable": false}}`.
1584   *
1585   * Properties that are not present take the HammerJS default values.
1586   * For information about which properties are supported for which events,
1587   * and their allowed and default values, see
1588   * [HammerJS documentation](https://hammerjs.github.io/).
1589   *
1590   */
1591  overrides = {};
1592  /**
1593   * Properties whose default values can be overridden for a given event.
1594   * Different sets of properties apply to different events.
1595   * For information about which properties are supported for which events,
1596   * and their allowed and default values, see
1597   * [HammerJS documentation](https://hammerjs.github.io/).
1598   */
1599  options;
1600  /**
1601   * Creates a [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)
1602   * and attaches it to a given HTML element.
1603   * @param element The element that will recognize gestures.
1604   * @returns A HammerJS event-manager object.
1605   */
1606  buildHammer(element) {
1607    const mc = new Hammer(element, this.options);
1608    mc.get("pinch").set({
1609      enable: true
1610    });
1611    mc.get("rotate").set({
1612      enable: true
1613    });
1614    for (const eventName in this.overrides) {
1615      mc.get(eventName).set(this.overrides[eventName]);
1616    }
1617    return mc;
1618  }
1619  static ɵfac = function HammerGestureConfig_Factory(__ngFactoryType__) {
1620    return new (__ngFactoryType__ || _HammerGestureConfig)();
1621  };
1622  static ɵprov = ɵɵdefineInjectable({
1623    token: _HammerGestureConfig,
1624    factory: _HammerGestureConfig.ɵfac
1625  });
1626};
1627(() => {
1628  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGestureConfig, [{
1629    type: Injectable
1630  }], null, null);
1631})();
1632var HammerGesturesPlugin = class _HammerGesturesPlugin extends EventManagerPlugin {
1633  _config;
1634  _injector;
1635  loader;
1636  _loaderPromise = null;
1637  constructor(doc, _config, _injector, loader) {
1638    super(doc);
1639    this._config = _config;
1640    this._injector = _injector;
1641    this.loader = loader;
1642  }
1643  supports(eventName) {
1644    if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {
1645      return false;
1646    }
1647    if (!window.Hammer && !this.loader) {
1648      if (typeof ngDevMode === "undefined" || ngDevMode) {
1649        const _console = this._injector.get(Console);
1650        _console.warn(`The "${eventName}" event cannot be bound because Hammer.JS is not loaded and no custom loader has been specified.`);
1651      }
1652      return false;
1653    }
1654    return true;
1655  }
1656  addEventListener(element, eventName, handler) {
1657    const zone = this.manager.getZone();
1658    eventName = eventName.toLowerCase();
1659    if (!window.Hammer && this.loader) {
1660      this._loaderPromise = this._loaderPromise || zone.runOutsideAngular(() => this.loader());
1661      let cancelRegistration = false;
1662      let deregister = () => {
1663        cancelRegistration = true;
1664      };
1665      zone.runOutsideAngular(() => this._loaderPromise.then(() => {
1666        if (!window.Hammer) {
1667          if (typeof ngDevMode === "undefined" || ngDevMode) {
1668            const _console = this._injector.get(Console);
1669            _console.warn(`The custom HAMMER_LOADER completed, but Hammer.JS is not present.`);
1670          }
1671          deregister = () => {
1672          };
1673          return;
1674        }
1675        if (!cancelRegistration) {
1676          deregister = this.addEventListener(element, eventName, handler);
1677        }
1678      }).catch(() => {
1679        if (typeof ngDevMode === "undefined" || ngDevMode) {
1680          const _console = this._injector.get(Console);
1681          _console.warn(`The "${eventName}" event cannot be bound because the custom Hammer.JS loader failed.`);
1682        }
1683        deregister = () => {
1684        };
1685      }));
1686      return () => {
1687        deregister();
1688      };
1689    }
1690    return zone.runOutsideAngular(() => {
1691      const mc = this._config.buildHammer(element);
1692      const callback = function(eventObj) {
1693        zone.runGuarded(function() {
1694          handler(eventObj);
1695        });
1696      };
1697      mc.on(eventName, callback);
1698      return () => {
1699        mc.off(eventName, callback);
1700        if (typeof mc.destroy === "function") {
1701          mc.destroy();
1702        }
1703      };
1704    });
1705  }
1706  isCustomEvent(eventName) {
1707    return this._config.events.indexOf(eventName) > -1;
1708  }
1709  static ɵfac = function HammerGesturesPlugin_Factory(__ngFactoryType__) {
1710    return new (__ngFactoryType__ || _HammerGesturesPlugin)(ɵɵinject(DOCUMENT), ɵɵinject(HAMMER_GESTURE_CONFIG), ɵɵinject(Injector), ɵɵinject(HAMMER_LOADER, 8));
1711  };
1712  static ɵprov = ɵɵdefineInjectable({
1713    token: _HammerGesturesPlugin,
1714    factory: _HammerGesturesPlugin.ɵfac
1715  });
1716};
1717(() => {
1718  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGesturesPlugin, [{
1719    type: Injectable
1720  }], () => [{
1721    type: void 0,
1722    decorators: [{
1723      type: Inject,
1724      args: [DOCUMENT]
1725    }]
1726  }, {
1727    type: HammerGestureConfig,
1728    decorators: [{
1729      type: Inject,
1730      args: [HAMMER_GESTURE_CONFIG]
1731    }]
1732  }, {
1733    type: Injector
1734  }, {
1735    type: void 0,
1736    decorators: [{
1737      type: Optional
1738    }, {
1739      type: Inject,
1740      args: [HAMMER_LOADER]
1741    }]
1742  }], null);
1743})();
1744var HammerModule = class _HammerModule {
1745  static ɵfac = function HammerModule_Factory(__ngFactoryType__) {
1746    return new (__ngFactoryType__ || _HammerModule)();
1747  };
1748  static ɵmod = ɵɵdefineNgModule({
1749    type: _HammerModule
1750  });
1751  static ɵinj = ɵɵdefineInjector({
1752    providers: [{
1753      provide: EVENT_MANAGER_PLUGINS,
1754      useClass: HammerGesturesPlugin,
1755      multi: true,
1756      deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Injector, [new Optional(), HAMMER_LOADER]]
1757    }, {
1758      provide: HAMMER_GESTURE_CONFIG,
1759      useClass: HammerGestureConfig
1760    }]
1761  });
1762};
1763(() => {
1764  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerModule, [{
1765    type: NgModule,
1766    args: [{
1767      providers: [{
1768        provide: EVENT_MANAGER_PLUGINS,
1769        useClass: HammerGesturesPlugin,
1770        multi: true,
1771        deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Injector, [new Optional(), HAMMER_LOADER]]
1772      }, {
1773        provide: HAMMER_GESTURE_CONFIG,
1774        useClass: HammerGestureConfig
1775      }]
1776    }]
1777  }], null, null);
1778})();
1779var DomSanitizer = class _DomSanitizer {
1780  static ɵfac = function DomSanitizer_Factory(__ngFactoryType__) {
1781    return new (__ngFactoryType__ || _DomSanitizer)();
1782  };
1783  static ɵprov = ɵɵdefineInjectable({
1784    token: _DomSanitizer,
1785    factory: function DomSanitizer_Factory(__ngFactoryType__) {
1786      let __ngConditionalFactory__ = null;
1787      if (__ngFactoryType__) {
1788        __ngConditionalFactory__ = new (__ngFactoryType__ || _DomSanitizer)();
1789      } else {
1790        __ngConditionalFactory__ = ɵɵinject(DomSanitizerImpl);
1791      }
1792      return __ngConditionalFactory__;
1793    },
1794    providedIn: "root"
1795  });
1796};
1797(() => {
1798  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizer, [{
1799    type: Injectable,
1800    args: [{
1801      providedIn: "root",
1802      useExisting: forwardRef(() => DomSanitizerImpl)
1803    }]
1804  }], null, null);
1805})();
1806var DomSanitizerImpl = class _DomSanitizerImpl extends DomSanitizer {
1807  _doc;
1808  constructor(_doc) {
1809    super();
1810    this._doc = _doc;
1811  }
1812  sanitize(ctx, value) {
1813    if (value == null) return null;
1814    switch (ctx) {
1815      case SecurityContext.NONE:
1816        return value;
1817      case SecurityContext.HTML:
1818        if (allowSanitizationBypassAndThrow(
1819          value,
1820          "HTML"
1821          /* BypassType.Html */
1822        )) {
1823          return unwrapSafeValue(value);
1824        }
1825        return _sanitizeHtml(this._doc, String(value)).toString();
1826      case SecurityContext.STYLE:
1827        if (allowSanitizationBypassAndThrow(
1828          value,
1829          "Style"
1830          /* BypassType.Style */
1831        )) {
1832          return unwrapSafeValue(value);
1833        }
1834        return value;
1835      case SecurityContext.SCRIPT:
1836        if (allowSanitizationBypassAndThrow(
1837          value,
1838          "Script"
1839          /* BypassType.Script */
1840        )) {
1841          return unwrapSafeValue(value);
1842        }
1843        throw new RuntimeError(5200, (typeof ngDevMode === "undefined" || ngDevMode) && "unsafe value used in a script context");
1844      case SecurityContext.URL:
1845        if (allowSanitizationBypassAndThrow(
1846          value,
1847          "URL"
1848          /* BypassType.Url */
1849        )) {
1850          return unwrapSafeValue(value);
1851        }
1852        return _sanitizeUrl(String(value));
1853      case SecurityContext.RESOURCE_URL:
1854        if (allowSanitizationBypassAndThrow(
1855          value,
1856          "ResourceURL"
1857          /* BypassType.ResourceUrl */
1858        )) {
1859          return unwrapSafeValue(value);
1860        }
1861        throw new RuntimeError(5201, (typeof ngDevMode === "undefined" || ngDevMode) && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);
1862      default:
1863        throw new RuntimeError(5202, (typeof ngDevMode === "undefined" || ngDevMode) && `Unexpected SecurityContext ${ctx} (see ${XSS_SECURITY_URL})`);
1864    }
1865  }
1866  bypassSecurityTrustHtml(value) {
1867    return bypassSanitizationTrustHtml(value);
1868  }
1869  bypassSecurityTrustStyle(value) {
1870    return bypassSanitizationTrustStyle(value);
1871  }
1872  bypassSecurityTrustScript(value) {
1873    return bypassSanitizationTrustScript(value);
1874  }
1875  bypassSecurityTrustUrl(value) {
1876    return bypassSanitizationTrustUrl(value);
1877  }
1878  bypassSecurityTrustResourceUrl(value) {
1879    return bypassSanitizationTrustResourceUrl(value);
1880  }
1881  static ɵfac = function DomSanitizerImpl_Factory(__ngFactoryType__) {
1882    return new (__ngFactoryType__ || _DomSanitizerImpl)(ɵɵinject(DOCUMENT));
1883  };
1884  static ɵprov = ɵɵdefineInjectable({
1885    token: _DomSanitizerImpl,
1886    factory: _DomSanitizerImpl.ɵfac,
1887    providedIn: "root"
1888  });
1889};
1890(() => {
1891  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizerImpl, [{
1892    type: Injectable,
1893    args: [{
1894      providedIn: "root"
1895    }]
1896  }], () => [{
1897    type: void 0,
1898    decorators: [{
1899      type: Inject,
1900      args: [DOCUMENT]
1901    }]
1902  }], null);
1903})();
1904var HydrationFeatureKind;
1905(function(HydrationFeatureKind2) {
1906  HydrationFeatureKind2[HydrationFeatureKind2["NoHttpTransferCache"] = 0] = "NoHttpTransferCache";
1907  HydrationFeatureKind2[HydrationFeatureKind2["HttpTransferCacheOptions"] = 1] = "HttpTransferCacheOptions";
1908  HydrationFeatureKind2[HydrationFeatureKind2["I18nSupport"] = 2] = "I18nSupport";
1909  HydrationFeatureKind2[HydrationFeatureKind2["EventReplay"] = 3] = "EventReplay";
1910  HydrationFeatureKind2[HydrationFeatureKind2["IncrementalHydration"] = 4] = "IncrementalHydration";
1911})(HydrationFeatureKind || (HydrationFeatureKind = {}));
1912function hydrationFeature(ɵkind, ɵproviders = [], ɵoptions = {}) {
1913  return {
1914    ɵkind,
1915    ɵproviders
1916  };
1917}
1918function withNoHttpTransferCache() {
1919  return hydrationFeature(HydrationFeatureKind.NoHttpTransferCache);
1920}
1921function withHttpTransferCacheOptions(options) {
1922  return hydrationFeature(HydrationFeatureKind.HttpTransferCacheOptions, withHttpTransferCache(options));
1923}
1924function withI18nSupport2() {
1925  return hydrationFeature(HydrationFeatureKind.I18nSupport, withI18nSupport());
1926}
1927function withEventReplay2() {
1928  return hydrationFeature(HydrationFeatureKind.EventReplay, withEventReplay());
1929}
1930function withIncrementalHydration2() {
1931  return hydrationFeature(HydrationFeatureKind.IncrementalHydration, withIncrementalHydration());
1932}
1933function provideZoneJsCompatibilityDetector() {
1934  return [{
1935    provide: ENVIRONMENT_INITIALIZER,
1936    useValue: () => {
1937      const ngZone = inject(NgZone);
1938      const isZoneless = inject(ZONELESS_ENABLED);
1939      if (!isZoneless && ngZone.constructor !== NgZone) {
1940        const console2 = inject(Console);
1941        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.");
1942        console2.warn(message);
1943      }
1944    },
1945    multi: true
1946  }];
1947}
1948function provideClientHydration(...features) {
1949  const providers = [];
1950  const featuresKind = /* @__PURE__ */ new Set();
1951  for (const {
1952    ɵproviders,
1953    ɵkind
1954  } of features) {
1955    featuresKind.add(ɵkind);
1956    if (ɵproviders.length) {
1957      providers.push(ɵproviders);
1958    }
1959  }
1960  const hasHttpTransferCacheOptions = featuresKind.has(HydrationFeatureKind.HttpTransferCacheOptions);
1961  if (typeof ngDevMode !== "undefined" && ngDevMode && featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) && hasHttpTransferCacheOptions) {
1962    throw new Error("Configuration error: found both withHttpTransferCacheOptions() and withNoHttpTransferCache() in the same call to provideClientHydration(), which is a contradiction.");
1963  }
1964  return makeEnvironmentProviders([typeof ngDevMode !== "undefined" && ngDevMode ? provideZoneJsCompatibilityDetector() : [], withDomHydration(), featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) || hasHttpTransferCacheOptions ? [] : withHttpTransferCache({}), providers]);
1965}
1966var VERSION = new Version("19.2.14");
1967
1968export {
1969  EVENT_MANAGER_PLUGINS,
1970  EventManager,
1971  EventManagerPlugin,
1972  SharedStylesHost,
1973  REMOVE_STYLES_ON_COMPONENT_DESTROY,
1974  DomRendererFactory2,
1975  BrowserDomAdapter,
1976  BrowserGetTestability,
1977  DomEventsPlugin,
1978  KeyEventsPlugin,
1979  bootstrapApplication,
1980  createApplication,
1981  provideProtractorTestingSupport,
1982  platformBrowser,
1983  BrowserModule,
1984  Meta,
1985  Title,
1986  enableDebugTools,
1987  disableDebugTools,
1988  By,
1989  HAMMER_GESTURE_CONFIG,
1990  HAMMER_LOADER,
1991  HammerGestureConfig,
1992  HammerGesturesPlugin,
1993  HammerModule,
1994  DomSanitizer,
1995  DomSanitizerImpl,
1996  HydrationFeatureKind,
1997  withNoHttpTransferCache,
1998  withHttpTransferCacheOptions,
1999  withI18nSupport2 as withI18nSupport,
2000  withEventReplay2 as withEventReplay,
2001  withIncrementalHydration2 as withIncrementalHydration,
2002  provideClientHydration,
2003  VERSION
2004};
2005/*! Bundled license information:
2006
2007@angular/platform-browser/fesm2022/dom_renderer-DGKzginR.mjs:
2008@angular/platform-browser/fesm2022/browser-D-u-fknz.mjs:
2009@angular/platform-browser/fesm2022/platform-browser.mjs:
2010  (**
2011   * @license Angular v19.2.14
2012   * (c) 2010-2025 Google LLC. https://angular.io/
2013   * License: MIT
2014   *)
2015*/
2016//# sourceMappingURL=chunk-DP5BB6VF.js.map