@absolutejs/absolute 0.19.0-beta.1083 → 0.19.0-beta.1085

package/dist/angular/vendor/server/chunk-hs2gc8sr.js

@@ -1,1787 +0,0 @@
-// @bun
-import {
-  CommonModule,
-  PLATFORM_BROWSER_ID
-} from "./chunk-p2fdvyh1.js";
-import {
-  withHttpTransferCache
-} from "./chunk-2akxms5e.js";
-import {
-  DomAdapter,
-  XhrFactory,
-  getDOM,
-  parseCookieValue,
-  setRootDomAdapter
-} from "./chunk-vthxj7kd.js";
-import {
-  APP_ID,
-  ApplicationModule,
-  ApplicationRef,
-  CSP_NONCE,
-  Console,
-  DOCUMENT,
-  ENVIRONMENT_INITIALIZER,
-  ErrorHandler,
-  INJECTOR_SCOPE,
-  IS_ENABLED_BLOCKING_INITIAL_NAVIGATION,
-  Inject,
-  Injectable,
-  InjectionToken,
-  Injector,
-  NgModule,
-  NgZone,
-  Optional,
-  PLATFORM_ID,
-  PLATFORM_INITIALIZER,
-  RendererFactory2,
-  RendererStyleFlags2,
-  RuntimeError,
-  SecurityContext,
-  TESTABILITY,
-  TESTABILITY_GETTER,
-  Testability,
-  TracingService,
-  Version,
-  ViewEncapsulation,
-  XSS_SECURITY_URL,
-  _global,
-  _sanitizeHtml,
-  _sanitizeUrl,
-  allLeavingAnimations,
-  allowSanitizationBypassAndThrow,
-  bypassSanitizationTrustHtml,
-  bypassSanitizationTrustResourceUrl,
-  bypassSanitizationTrustScript,
-  bypassSanitizationTrustStyle,
-  bypassSanitizationTrustUrl,
-  createPlatformFactory,
-  formatRuntimeError,
-  forwardRef,
-  inject,
-  internalCreateApplication,
-  makeEnvironmentProviders,
-  platformCore,
-  provideStabilityDebugging,
-  resolveComponentResources,
-  setClassMetadata,
-  setDocument,
-  unwrapSafeValue,
-  withDomHydration,
-  withEventReplay,
-  withI18nSupport,
-  withIncrementalHydration,
-  \u{275}\u{275}defineInjectable as \u{275}_defineInjectable,
-  \u{275}\u{275}defineInjector as \u{275}_defineInjector,
-  \u{275}\u{275}defineNgModule as \u{275}_defineNgModule,
-  \u{275}\u{275}inject as \u{275}_inject
-} from "./chunk-xahr7f2f.js";
-import {
-  __export
-} from "./chunk-dhs2bg35.js";
-
-// node_modules/@angular/platform-browser/fesm2022/_dom_renderer-chunk.mjs
-class EventManagerPlugin {
-  _doc;
-  constructor(_doc) {
-    this._doc = _doc;
-  }
-  manager;
-}
-
-class DomEventsPlugin extends EventManagerPlugin {
-  constructor(doc) {
-    super(doc);
-  }
-  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 \u{275}fac = function DomEventsPlugin_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || DomEventsPlugin)(\u{275}_inject(DOCUMENT));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: DomEventsPlugin,
-    factory: DomEventsPlugin.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomEventsPlugin, [{
-    type: Injectable
-  }], () => [{
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [DOCUMENT]
-    }]
-  }], null);
-})();
-var EVENT_MANAGER_PLUGINS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "EventManagerPlugins" : "");
-
-class EventManager {
-  _zone;
-  _plugins;
-  _eventNameToPlugin = new Map;
-  constructor(plugins, _zone) {
-    this._zone = _zone;
-    plugins.forEach((plugin) => {
-      plugin.manager = this;
-    });
-    const otherPlugins = plugins.filter((p) => !(p instanceof DomEventsPlugin));
-    this._plugins = otherPlugins.slice().reverse();
-    const domEventPlugin = plugins.find((p) => p instanceof DomEventsPlugin);
-    if (domEventPlugin) {
-      this._plugins.push(domEventPlugin);
-    }
-  }
-  addEventListener(element, eventName, handler, options) {
-    const plugin = this._findPluginFor(eventName);
-    return plugin.addEventListener(element, eventName, handler, options);
-  }
-  getZone() {
-    return this._zone;
-  }
-  _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 \u{275}fac = function EventManager_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || EventManager)(\u{275}_inject(EVENT_MANAGER_PLUGINS), \u{275}_inject(NgZone));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: EventManager,
-    factory: EventManager.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EventManager, [{
-    type: Injectable
-  }], () => [{
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [EVENT_MANAGER_PLUGINS]
-    }]
-  }, {
-    type: NgZone
-  }], null);
-})();
-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;
-}
-
-class SharedStylesHost {
-  doc;
-  appId;
-  nonce;
-  inline = new Map;
-  external = new Map;
-  hosts = new Set;
-  constructor(doc, appId, nonce, platformId = {}) {
-    this.doc = doc;
-    this.appId = appId;
-    this.nonce = nonce;
-    addServerStyles(doc, appId, this.inline, this.external);
-    this.hosts.add(doc.head);
-  }
-  addStyles(styles, urls) {
-    for (const value of styles) {
-      this.addUsage(value, this.inline, createStyleElement);
-    }
-    urls?.forEach((value) => this.addUsage(value, this.external, createLinkElement));
-  }
-  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();
-  }
-  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 (typeof ngServerMode !== "undefined" && ngServerMode) {
-      element.setAttribute(APP_ID_ATTRIBUTE_NAME, this.appId);
-    }
-    return host.appendChild(element);
-  }
-  static \u{275}fac = function SharedStylesHost_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || SharedStylesHost)(\u{275}_inject(DOCUMENT), \u{275}_inject(APP_ID), \u{275}_inject(CSP_NONCE, 8), \u{275}_inject(PLATFORM_ID));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: SharedStylesHost,
-    factory: SharedStylesHost.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SharedStylesHost, [{
-    type: Injectable
-  }], () => [{
-    type: Document,
-    decorators: [{
-      type: Inject,
-      args: [DOCUMENT]
-    }]
-  }, {
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [APP_ID]
-    }]
-  }, {
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [CSP_NONCE]
-    }, {
-      type: Optional
-    }]
-  }, {
-    type: undefined,
-    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(typeof ngDevMode !== "undefined" && ngDevMode ? "RemoveStylesOnCompDestroy" : "", {
-  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} */`;
-    });
-  });
-}
-
-class DomRendererFactory2 {
-  eventManager;
-  sharedStylesHost;
-  appId;
-  removeStylesOnCompDestroy;
-  doc;
-  ngZone;
-  nonce;
-  tracingService;
-  rendererByCompId = new Map;
-  defaultRenderer;
-  constructor(eventManager, sharedStylesHost, appId, removeStylesOnCompDestroy, doc, ngZone, nonce = null, tracingService = null) {
-    this.eventManager = eventManager;
-    this.sharedStylesHost = sharedStylesHost;
-    this.appId = appId;
-    this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
-    this.doc = doc;
-    this.ngZone = ngZone;
-    this.nonce = nonce;
-    this.tracingService = tracingService;
-    this.defaultRenderer = new DefaultDomRenderer2(eventManager, doc, ngZone, this.tracingService);
-  }
-  createRenderer(element, type) {
-    if (!element || !type) {
-      return this.defaultRenderer;
-    }
-    if (typeof ngServerMode !== "undefined" && ngServerMode && (type.encapsulation === ViewEncapsulation.ShadowDom || type.encapsulation === ViewEncapsulation.ExperimentalIsolatedShadowDom)) {
-      type = {
-        ...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 tracingService = this.tracingService;
-      switch (type.encapsulation) {
-        case ViewEncapsulation.Emulated:
-          renderer = new EmulatedEncapsulationDomRenderer2(eventManager, sharedStylesHost, type, this.appId, removeStylesOnCompDestroy, doc, ngZone, tracingService);
-          break;
-        case ViewEncapsulation.ShadowDom:
-          return new ShadowDomRenderer(eventManager, element, type, doc, ngZone, this.nonce, tracingService, sharedStylesHost);
-        case ViewEncapsulation.ExperimentalIsolatedShadowDom:
-          return new ShadowDomRenderer(eventManager, element, type, doc, ngZone, this.nonce, tracingService);
-        default:
-          renderer = new NoneEncapsulationDomRenderer(eventManager, sharedStylesHost, type, removeStylesOnCompDestroy, doc, ngZone, tracingService);
-          break;
-      }
-      rendererByCompId.set(type.id, renderer);
-    }
-    return renderer;
-  }
-  ngOnDestroy() {
-    this.rendererByCompId.clear();
-  }
-  componentReplaced(componentId) {
-    this.rendererByCompId.delete(componentId);
-  }
-  static \u{275}fac = function DomRendererFactory2_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || DomRendererFactory2)(\u{275}_inject(EventManager), \u{275}_inject(SharedStylesHost), \u{275}_inject(APP_ID), \u{275}_inject(REMOVE_STYLES_ON_COMPONENT_DESTROY), \u{275}_inject(DOCUMENT), \u{275}_inject(NgZone), \u{275}_inject(CSP_NONCE), \u{275}_inject(TracingService, 8));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: DomRendererFactory2,
-    factory: DomRendererFactory2.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomRendererFactory2, [{
-    type: Injectable
-  }], () => [{
-    type: EventManager
-  }, {
-    type: SharedStylesHost
-  }, {
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [APP_ID]
-    }]
-  }, {
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [REMOVE_STYLES_ON_COMPONENT_DESTROY]
-    }]
-  }, {
-    type: Document,
-    decorators: [{
-      type: Inject,
-      args: [DOCUMENT]
-    }]
-  }, {
-    type: NgZone
-  }, {
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [CSP_NONCE]
-    }]
-  }, {
-    type: TracingService,
-    decorators: [{
-      type: Inject,
-      args: [TracingService]
-    }, {
-      type: Optional
-    }]
-  }], null);
-})();
-
-class DefaultDomRenderer2 {
-  eventManager;
-  doc;
-  ngZone;
-  tracingService;
-  data = Object.create(null);
-  throwOnSyntheticProps = true;
-  constructor(eventManager, doc, ngZone, tracingService) {
-    this.eventManager = eventManager;
-    this.doc = doc;
-    this.ngZone = ngZone;
-    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 = typeof ngServerMode !== "undefined" && ngServerMode ? this.ngZone.runGuarded(() => eventHandler(event)) : eventHandler(event);
-      if (allowDefaultBehavior === false) {
-        event.preventDefault();
-      }
-      return;
-    };
-  }
-}
-var AT_CHARCODE = (() => 64)();
-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 !== undefined;
-}
-
-class ShadowDomRenderer extends DefaultDomRenderer2 {
-  hostEl;
-  sharedStylesHost;
-  shadowRoot;
-  constructor(eventManager, hostEl, component, doc, ngZone, nonce, tracingService, sharedStylesHost) {
-    super(eventManager, doc, ngZone, tracingService);
-    this.hostEl = hostEl;
-    this.sharedStylesHost = sharedStylesHost;
-    this.shadowRoot = hostEl.attachShadow({
-      mode: "open"
-    });
-    if (this.sharedStylesHost) {
-      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() {
-    if (this.sharedStylesHost) {
-      this.sharedStylesHost.removeHost(this.shadowRoot);
-    }
-  }
-}
-
-class NoneEncapsulationDomRenderer extends DefaultDomRenderer2 {
-  sharedStylesHost;
-  removeStylesOnCompDestroy;
-  styles;
-  styleUrls;
-  constructor(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, tracingService, compId) {
-    super(eventManager, doc, ngZone, 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;
-    }
-    if (allLeavingAnimations.size === 0) {
-      this.sharedStylesHost.removeStyles(this.styles, this.styleUrls);
-    }
-  }
-}
-
-class EmulatedEncapsulationDomRenderer2 extends NoneEncapsulationDomRenderer {
-  contentAttr;
-  hostAttr;
-  constructor(eventManager, sharedStylesHost, component, appId, removeStylesOnCompDestroy, doc, ngZone, tracingService) {
-    const compId = appId + "-" + component.id;
-    super(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, 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-chunk.mjs
-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;
-  }
-  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;
-}
-
-class BrowserGetTestability {
-  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);
-  }
-}
-
-class BrowserXhr {
-  build() {
-    return new XMLHttpRequest;
-  }
-  static \u{275}fac = function BrowserXhr_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || BrowserXhr);
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: BrowserXhr,
-    factory: BrowserXhr.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserXhr, [{
-    type: Injectable
-  }], null, null);
-})();
-var MODIFIER_KEYS = ["alt", "control", "meta", "shift"];
-var _keyMap = {
-  "\b": "Backspace",
-  "\t": "Tab",
-  "\x7F": "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
-};
-
-class KeyEventsPlugin extends EventManagerPlugin {
-  constructor(doc) {
-    super(doc);
-  }
-  supports(eventName) {
-    return KeyEventsPlugin.parseEventName(eventName) != null;
-  }
-  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);
-    });
-  }
-  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;
-  }
-  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;
-  }
-  static eventCallback(fullKey, handler, zone) {
-    return (event) => {
-      if (KeyEventsPlugin.matchEventFullKeyCode(event, fullKey)) {
-        zone.runGuarded(() => handler(event));
-      }
-    };
-  }
-  static _normalizeKey(keyName) {
-    return keyName === "esc" ? "escape" : keyName;
-  }
-  static \u{275}fac = function KeyEventsPlugin_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || KeyEventsPlugin)(\u{275}_inject(DOCUMENT));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: KeyEventsPlugin,
-    factory: KeyEventsPlugin.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(KeyEventsPlugin, [{
-    type: Injectable
-  }], () => [{
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [DOCUMENT]
-    }]
-  }], null);
-})();
-async function bootstrapApplication(rootComponent, options, context) {
-  const config = {
-    rootComponent,
-    ...createProvidersConfig(options, context)
-  };
-  if ((typeof ngJitMode === "undefined" || ngJitMode) && typeof fetch === "function") {
-    await resolveJitResources();
-  }
-  return internalCreateApplication(config);
-}
-async function createApplication(options, context) {
-  if ((typeof ngJitMode === "undefined" || ngJitMode) && typeof fetch === "function") {
-    await resolveJitResources();
-  }
-  return internalCreateApplication(createProvidersConfig(options, context));
-}
-function createProvidersConfig(options, context) {
-  return {
-    platformRef: context?.platformRef,
-    appProviders: [...BROWSER_MODULE_PROVIDERS, ...options?.providers ?? []],
-    platformProviders: INTERNAL_BROWSER_PLATFORM_PROVIDERS
-  };
-}
-async function resolveJitResources() {
-  try {
-    return await resolveComponentResources(fetch);
-  } catch (error) {
-    console.error(error);
-  }
-}
-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
-}, {
-  provide: Testability,
-  useClass: Testability
-}];
-var BROWSER_MODULE_PROVIDERS = [{
-  provide: INJECTOR_SCOPE,
-  useValue: "root"
-}, {
-  provide: ErrorHandler,
-  useFactory: errorHandler
-}, {
-  provide: EVENT_MANAGER_PLUGINS,
-  useClass: DomEventsPlugin,
-  multi: true
-}, {
-  provide: EVENT_MANAGER_PLUGINS,
-  useClass: KeyEventsPlugin,
-  multi: true
-}, DomRendererFactory2, SharedStylesHost, EventManager, {
-  provide: RendererFactory2,
-  useExisting: DomRendererFactory2
-}, {
-  provide: XhrFactory,
-  useClass: BrowserXhr
-}, typeof ngDevMode === "undefined" || ngDevMode ? {
-  provide: BROWSER_MODULE_PROVIDERS_MARKER,
-  useValue: true
-} : []];
-
-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 \u{275}fac = function BrowserModule_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || BrowserModule);
-  };
-  static \u{275}mod = /* @__PURE__ */ \u{275}_defineNgModule({
-    type: BrowserModule
-  });
-  static \u{275}inj = /* @__PURE__ */ \u{275}_defineInjector({
-    providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
-    imports: [CommonModule, ApplicationModule]
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserModule, [{
-    type: NgModule,
-    args: [{
-      providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
-      exports: [CommonModule, ApplicationModule]
-    }]
-  }], () => [], null);
-})();
-
-// node_modules/@angular/platform-browser/fesm2022/platform-browser.mjs
-var exports_platform_browser = {};
-__export(exports_platform_browser, {
-  \u{275}getDOM: () => getDOM,
-  \u{275}SharedStylesHost: () => SharedStylesHost,
-  \u{275}KeyEventsPlugin: () => KeyEventsPlugin,
-  \u{275}HammerGesturesPlugin: () => HammerGesturesPlugin,
-  \u{275}DomSanitizerImpl: () => DomSanitizerImpl,
-  \u{275}DomRendererFactory2: () => DomRendererFactory2,
-  \u{275}DomEventsPlugin: () => DomEventsPlugin,
-  \u{275}BrowserGetTestability: () => BrowserGetTestability,
-  \u{275}BrowserDomAdapter: () => BrowserDomAdapter,
-  withNoHttpTransferCache: () => withNoHttpTransferCache,
-  withIncrementalHydration: () => withIncrementalHydration2,
-  withI18nSupport: () => withI18nSupport2,
-  withHttpTransferCacheOptions: () => withHttpTransferCacheOptions,
-  withEventReplay: () => withEventReplay2,
-  provideProtractorTestingSupport: () => provideProtractorTestingSupport,
-  provideClientHydration: () => provideClientHydration,
-  platformBrowser: () => platformBrowser,
-  enableDebugTools: () => enableDebugTools,
-  disableDebugTools: () => disableDebugTools,
-  createApplication: () => createApplication,
-  bootstrapApplication: () => bootstrapApplication,
-  VERSION: () => VERSION,
-  Title: () => Title,
-  REMOVE_STYLES_ON_COMPONENT_DESTROY: () => REMOVE_STYLES_ON_COMPONENT_DESTROY,
-  Meta: () => Meta,
-  HydrationFeatureKind: () => HydrationFeatureKind,
-  HammerModule: () => HammerModule,
-  HammerGestureConfig: () => HammerGestureConfig,
-  HAMMER_LOADER: () => HAMMER_LOADER,
-  HAMMER_GESTURE_CONFIG: () => HAMMER_GESTURE_CONFIG,
-  EventManagerPlugin: () => EventManagerPlugin,
-  EventManager: () => EventManager,
-  EVENT_MANAGER_PLUGINS: () => EVENT_MANAGER_PLUGINS,
-  DomSanitizer: () => DomSanitizer,
-  By: () => By,
-  BrowserModule: () => BrowserModule
-});
-class Meta {
-  _doc;
-  _dom;
-  constructor(_doc) {
-    this._doc = _doc;
-    this._dom = getDOM();
-  }
-  addTag(tag, forceCreation = false) {
-    if (!tag)
-      return null;
-    return this._getOrCreateElement(tag, forceCreation);
-  }
-  addTags(tags, forceCreation = false) {
-    if (!tags)
-      return [];
-    return tags.reduce((result, tag) => {
-      if (tag) {
-        result.push(this._getOrCreateElement(tag, forceCreation));
-      }
-      return result;
-    }, []);
-  }
-  getTag(attrSelector) {
-    if (!attrSelector)
-      return null;
-    return this._doc.querySelector(`meta[${attrSelector}]`) || null;
-  }
-  getTags(attrSelector) {
-    if (!attrSelector)
-      return [];
-    const list = this._doc.querySelectorAll(`meta[${attrSelector}]`);
-    return list ? [].slice.call(list) : [];
-  }
-  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);
-  }
-  removeTag(attrSelector) {
-    this.removeTagElement(this.getTag(attrSelector));
-  }
-  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 !== undefined)
-        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 \u{275}fac = function Meta_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || Meta)(\u{275}_inject(DOCUMENT));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: Meta,
-    factory: Meta.\u{275}fac,
-    providedIn: "root"
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Meta, [{
-    type: Injectable,
-    args: [{
-      providedIn: "root"
-    }]
-  }], () => [{
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [DOCUMENT]
-    }]
-  }], null);
-})();
-var META_KEYS_MAP = {
-  httpEquiv: "http-equiv"
-};
-
-class Title {
-  _doc;
-  constructor(_doc) {
-    this._doc = _doc;
-  }
-  getTitle() {
-    return this._doc.title;
-  }
-  setTitle(newTitle) {
-    this._doc.title = newTitle || "";
-  }
-  static \u{275}fac = function Title_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || Title)(\u{275}_inject(DOCUMENT));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: Title,
-    factory: Title.\u{275}fac,
-    providedIn: "root"
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Title, [{
-    type: Injectable,
-    args: [{
-      providedIn: "root"
-    }]
-  }], () => [{
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [DOCUMENT]
-    }]
-  }], null);
-})();
-function exportNgVar(name, value) {
-  if (typeof COMPILED === "undefined" || !COMPILED) {
-    const ng = _global["ng"] = _global["ng"] || {};
-    ng[name] = value;
-  }
-}
-
-class ChangeDetectionPerfRecord {
-  msPerTick;
-  numTicks;
-  constructor(msPerTick, numTicks) {
-    this.msPerTick = msPerTick;
-    this.numTicks = numTicks;
-  }
-}
-
-class AngularProfiler {
-  appRef;
-  constructor(ref) {
-    this.appRef = ref.injector.get(ApplicationRef);
-  }
-  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);
-}
-
-class By {
-  static all() {
-    return () => true;
-  }
-  static css(selector) {
-    return (debugElement) => {
-      return debugElement.nativeElement != null ? elementMatches(debugElement.nativeElement, selector) : false;
-    };
-  }
-  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: true,
-  panstart: true,
-  panmove: true,
-  panend: true,
-  pancancel: true,
-  panleft: true,
-  panright: true,
-  panup: true,
-  pandown: true,
-  pinch: true,
-  pinchstart: true,
-  pinchmove: true,
-  pinchend: true,
-  pinchcancel: true,
-  pinchin: true,
-  pinchout: true,
-  press: true,
-  pressup: true,
-  rotate: true,
-  rotatestart: true,
-  rotatemove: true,
-  rotateend: true,
-  rotatecancel: true,
-  swipe: true,
-  swipeleft: true,
-  swiperight: true,
-  swipeup: true,
-  swipedown: true,
-  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" : "");
-
-class HammerGestureConfig {
-  events = [];
-  overrides = {};
-  options;
-  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 \u{275}fac = function HammerGestureConfig_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HammerGestureConfig);
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: HammerGestureConfig,
-    factory: HammerGestureConfig.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGestureConfig, [{
-    type: Injectable
-  }], null, null);
-})();
-
-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 \u{275}fac = function HammerGesturesPlugin_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HammerGesturesPlugin)(\u{275}_inject(DOCUMENT), \u{275}_inject(HAMMER_GESTURE_CONFIG), \u{275}_inject(Injector), \u{275}_inject(HAMMER_LOADER, 8));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: HammerGesturesPlugin,
-    factory: HammerGesturesPlugin.\u{275}fac
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGesturesPlugin, [{
-    type: Injectable
-  }], () => [{
-    type: undefined,
-    decorators: [{
-      type: Inject,
-      args: [DOCUMENT]
-    }]
-  }, {
-    type: HammerGestureConfig,
-    decorators: [{
-      type: Inject,
-      args: [HAMMER_GESTURE_CONFIG]
-    }]
-  }, {
-    type: Injector
-  }, {
-    type: undefined,
-    decorators: [{
-      type: Optional
-    }, {
-      type: Inject,
-      args: [HAMMER_LOADER]
-    }]
-  }], null);
-})();
-
-class HammerModule {
-  static \u{275}fac = function HammerModule_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || HammerModule);
-  };
-  static \u{275}mod = /* @__PURE__ */ \u{275}_defineNgModule({
-    type: HammerModule
-  });
-  static \u{275}inj = /* @__PURE__ */ \u{275}_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);
-})();
-
-class DomSanitizer {
-  static \u{275}fac = function DomSanitizer_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || DomSanitizer);
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: DomSanitizer,
-    factory: function DomSanitizer_Factory(__ngFactoryType__) {
-      let __ngConditionalFactory__ = null;
-      if (__ngFactoryType__) {
-        __ngConditionalFactory__ = new (__ngFactoryType__ || DomSanitizer);
-      } else {
-        __ngConditionalFactory__ = \u{275}_inject(DomSanitizerImpl);
-      }
-      return __ngConditionalFactory__;
-    },
-    providedIn: "root"
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizer, [{
-    type: Injectable,
-    args: [{
-      providedIn: "root",
-      useExisting: forwardRef(() => DomSanitizerImpl)
-    }]
-  }], null, null);
-})();
-
-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")) {
-          return unwrapSafeValue(value);
-        }
-        return _sanitizeHtml(this._doc, String(value)).toString();
-      case SecurityContext.STYLE:
-        if (allowSanitizationBypassAndThrow(value, "Style")) {
-          return unwrapSafeValue(value);
-        }
-        return value;
-      case SecurityContext.SCRIPT:
-        if (allowSanitizationBypassAndThrow(value, "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")) {
-          return unwrapSafeValue(value);
-        }
-        return _sanitizeUrl(String(value));
-      case SecurityContext.RESOURCE_URL:
-        if (allowSanitizationBypassAndThrow(value, "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 \u{275}fac = function DomSanitizerImpl_Factory(__ngFactoryType__) {
-    return new (__ngFactoryType__ || DomSanitizerImpl)(\u{275}_inject(DOCUMENT));
-  };
-  static \u{275}prov = /* @__PURE__ */ \u{275}_defineInjectable({
-    token: DomSanitizerImpl,
-    factory: DomSanitizerImpl.\u{275}fac,
-    providedIn: "root"
-  });
-}
-(() => {
-  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizerImpl, [{
-    type: Injectable,
-    args: [{
-      providedIn: "root"
-    }]
-  }], () => [{
-    type: undefined,
-    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(\u{275}kind, \u{275}providers = [], \u{275}options = {}) {
-  return {
-    \u{275}kind,
-    \u{275}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 provideEnabledBlockingInitialNavigationDetector() {
-  return [{
-    provide: ENVIRONMENT_INITIALIZER,
-    useValue: () => {
-      const isEnabledBlockingInitialNavigation = inject(IS_ENABLED_BLOCKING_INITIAL_NAVIGATION, {
-        optional: true
-      });
-      if (isEnabledBlockingInitialNavigation) {
-        const console2 = inject(Console);
-        const message = formatRuntimeError(5001, "Configuration error: found both hydration and enabledBlocking initial navigation " + "in the same application, which is a contradiction.");
-        console2.warn(message);
-      }
-    },
-    multi: true
-  }];
-}
-function provideClientHydration(...features) {
-  const providers = [];
-  const featuresKind = new Set;
-  for (const {
-    \u{275}providers,
-    \u{275}kind
-  } of features) {
-    featuresKind.add(\u{275}kind);
-    if (\u{275}providers.length) {
-      providers.push(\u{275}providers);
-    }
-  }
-  const hasHttpTransferCacheOptions = featuresKind.has(HydrationFeatureKind.HttpTransferCacheOptions);
-  if (typeof ngDevMode !== "undefined" && ngDevMode && featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) && hasHttpTransferCacheOptions) {
-    throw new RuntimeError(5001, "Configuration error: found both withHttpTransferCacheOptions() and withNoHttpTransferCache() in the same call to provideClientHydration(), which is a contradiction.");
-  }
-  return makeEnvironmentProviders([typeof ngDevMode !== "undefined" && ngDevMode ? provideEnabledBlockingInitialNavigationDetector() : [], typeof ngDevMode !== "undefined" && ngDevMode ? provideStabilityDebugging() : [], withDomHydration(), featuresKind.has(HydrationFeatureKind.NoHttpTransferCache) || hasHttpTransferCacheOptions ? [] : withHttpTransferCache({}), providers]);
-}
-var VERSION = /* @__PURE__ */ new Version("21.2.6");
-
-export { EventManagerPlugin, EVENT_MANAGER_PLUGINS, EventManager, REMOVE_STYLES_ON_COMPONENT_DESTROY, BrowserDomAdapter, bootstrapApplication, createApplication, provideProtractorTestingSupport, platformBrowser, BrowserModule, Meta, Title, enableDebugTools, disableDebugTools, By, HAMMER_GESTURE_CONFIG, HAMMER_LOADER, HammerGestureConfig, HammerModule, DomSanitizer, HydrationFeatureKind, withNoHttpTransferCache, withHttpTransferCacheOptions, withI18nSupport2 as withI18nSupport, withEventReplay2 as withEventReplay, withIncrementalHydration2 as withIncrementalHydration, provideClientHydration, VERSION, exports_platform_browser };