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

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

@@ -0,0 +1,1787 @@
+// @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 };