@analogjs/content 1.4.0-beta.2 → 1.4.0-beta.4

package/fesm2022/analogjs-content.mjs

@@ -1,320 +1,318 @@
-// lib/anchor-navigation.directive.mjs
-import { Directive, HostListener, inject } from "@angular/core";
-import { DOCUMENT, Location } from "@angular/common";
-import { Router } from "@angular/router";
-import * as i0 from "@angular/core";
-var AnchorNavigationDirective = class _AnchorNavigationDirective {
-  constructor() {
-    this.document = inject(DOCUMENT);
-    this.location = inject(Location);
-    this.router = inject(Router);
-  }
-  handleNavigation(element) {
-    if (element instanceof HTMLAnchorElement && isInternalUrl(element, this.document) && hasTargetSelf(element) && !hasDownloadAttribute(element)) {
-      const { pathname, search, hash } = element;
-      const url = this.location.normalize(`${pathname}${search}${hash}`);
-      this.router.navigateByUrl(url);
-      return false;
+import * as i0 from '@angular/core';
+import { inject, Directive, HostListener, InjectionToken, ɵPendingTasks as _PendingTasks, Injectable, Component, ViewEncapsulation, Input, NgZone, PLATFORM_ID, ViewContainerRef, ViewChild } from '@angular/core';
+import { DOCUMENT, Location, AsyncPipe, isPlatformBrowser } from '@angular/common';
+import { Router, ActivatedRoute } from '@angular/router';
+import { isObservable, firstValueFrom, of, Observable, from } from 'rxjs';
+import { map, switchMap, tap, mergeMap, catchError } from 'rxjs/operators';
+import fm from 'front-matter';
+import { gfmHeadingId, getHeadingList } from 'marked-gfm-heading-id';
+import { marked } from 'marked';
+import { markedHighlight } from 'marked-highlight';
+import 'prismjs';
+import 'prismjs/components/prism-bash';
+import 'prismjs/components/prism-css';
+import 'prismjs/components/prism-javascript';
+import 'prismjs/components/prism-json';
+import 'prismjs/components/prism-markup';
+import 'prismjs/components/prism-typescript';
+import 'prismjs/plugins/copy-to-clipboard/prism-copy-to-clipboard';
+import 'prismjs/plugins/toolbar/prism-toolbar';
+import { DomSanitizer } from '@angular/platform-browser';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+class AnchorNavigationDirective {
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.location = inject(Location);
+        this.router = inject(Router);
+    }
+    handleNavigation(element) {
+        if (element instanceof HTMLAnchorElement &&
+            isInternalUrl(element, this.document) &&
+            hasTargetSelf(element) &&
+            !hasDownloadAttribute(element)) {
+            const { pathname, search, hash } = element;
+            const url = this.location.normalize(`${pathname}${search}${hash}`);
+            this.router.navigateByUrl(url);
+            return false;
+        }
+        return true;
     }
-    return true;
-  }
-  static {
-    this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i0, type: _AnchorNavigationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-  }
-  static {
-    this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.0-rc.1", type: _AnchorNavigationDirective, isStandalone: true, selector: "[analogAnchorNavigation]", host: { listeners: { "click": "handleNavigation($event.target)" } }, ngImport: i0 });
-  }
-};
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i0, type: AnchorNavigationDirective, decorators: [{
-  type: Directive,
-  args: [{
-    selector: "[analogAnchorNavigation]",
-    standalone: true
-  }]
-}], propDecorators: { handleNavigation: [{
-  type: HostListener,
-  args: ["click", ["$event.target"]]
-}] } });
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AnchorNavigationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.0", type: AnchorNavigationDirective, isStandalone: true, selector: "[analogAnchorNavigation]", host: { listeners: { "click": "handleNavigation($event.target)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AnchorNavigationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[analogAnchorNavigation]',
+                    standalone: true,
+                }]
+        }], propDecorators: { handleNavigation: [{
+                type: HostListener,
+                args: ['click', ['$event.target']]
+            }] } });
 function hasDownloadAttribute(anchorElement) {
-  return anchorElement.getAttribute("download") !== null;
+    return anchorElement.getAttribute('download') !== null;
 }
 function hasTargetSelf(anchorElement) {
-  return !anchorElement.target || anchorElement.target === "_self";
+    return !anchorElement.target || anchorElement.target === '_self';
 }
 function isInternalUrl(anchorElement, document) {
-  return anchorElement.host === document.location.host && anchorElement.protocol === document.location.protocol;
+    return (anchorElement.host === document.location.host &&
+        anchorElement.protocol === document.location.protocol);
 }
 
-// lib/get-content-files.mjs
-var getContentFilesList = () => import.meta.glob(["/src/content/**/*.md", "/src/content/**/*.agx"], {
-  eager: true,
-  import: "default",
-  query: { "analog-content-list": true }
+/**
+ * Returns the list of content files by filename with ?analog-content-list=true.
+ * We use the query param to transform the return into an array of
+ * just front matter attributes.
+ *
+ * @returns
+ */
+const getContentFilesList = () => import.meta.glob(['/src/content/**/*.md', '/src/content/**/*.agx'], {
+    eager: true,
+    import: 'default',
+    query: { 'analog-content-list': true },
 });
-var getContentFiles = () => import.meta.glob(["/src/content/**/*.md"], {
-  query: "?raw",
-  import: "default"
+/**
+ * Returns the lazy loaded content files for lookups.
+ *
+ * @returns
+ */
+const getContentFiles = () => import.meta.glob(['/src/content/**/*.md'], {
+    query: '?raw',
+    import: 'default',
 });
-var getAgxFiles = () => import.meta.glob(["/src/content/**/*.agx"]);
+const getAgxFiles = () => import.meta.glob(['/src/content/**/*.agx']);
 
-// lib/content-files-list-token.mjs
-import { InjectionToken } from "@angular/core";
 function getSlug(filename) {
-  const parts = filename.match(/^(\\|\/)(.+(\\|\/))*(.+)\.(.+)$/);
-  return parts?.length ? parts[4] : "";
+    const parts = filename.match(/^(\\|\/)(.+(\\|\/))*(.+)\.(.+)$/);
+    return parts?.length ? parts[4] : '';
 }
-var CONTENT_FILES_LIST_TOKEN = new InjectionToken("@analogjs/content Content Files List", {
-  providedIn: "root",
-  factory() {
-    const contentFiles = getContentFilesList();
-    return Object.keys(contentFiles).map((filename) => {
-      const attributes = contentFiles[filename];
-      const slug = attributes["slug"];
-      return {
-        filename,
-        attributes,
-        slug: slug ? encodeURI(slug) : encodeURI(getSlug(filename))
-      };
-    });
-  }
+const CONTENT_FILES_LIST_TOKEN = new InjectionToken('@analogjs/content Content Files List', {
+    providedIn: 'root',
+    factory() {
+        const contentFiles = getContentFilesList();
+        return Object.keys(contentFiles).map((filename) => {
+            const attributes = contentFiles[filename];
+            const slug = attributes['slug'];
+            return {
+                filename,
+                attributes,
+                slug: slug ? encodeURI(slug) : encodeURI(getSlug(filename)),
+            };
+        });
+    },
 });
 
-// lib/content-files-token.mjs
-import { InjectionToken as InjectionToken2, inject as inject2 } from "@angular/core";
-var CONTENT_FILES_TOKEN = new InjectionToken2("@analogjs/content Content Files", {
-  providedIn: "root",
-  factory() {
-    const contentFiles = getContentFiles();
-    const agxFiles = getAgxFiles();
-    const allFiles = { ...contentFiles, ...agxFiles };
-    const contentFilesList = inject2(CONTENT_FILES_LIST_TOKEN);
-    const lookup = {};
-    contentFilesList.forEach((item) => {
-      const fileParts = item.filename.split("/");
-      const filePath = fileParts.slice(0, fileParts.length - 1).join("/");
-      const fileNameParts = fileParts[fileParts.length - 1].split(".");
-      lookup[item.filename] = `${filePath}/${item.slug}.${fileNameParts[fileNameParts.length - 1]}`;
-    });
-    const objectUsingSlugAttribute = {};
-    Object.entries(allFiles).forEach((entry) => {
-      const filename = entry[0];
-      const value = entry[1];
-      const newFilename = lookup[filename];
-      if (newFilename !== void 0) {
-        objectUsingSlugAttribute[newFilename] = value;
-      }
-    });
-    return objectUsingSlugAttribute;
-  }
+const CONTENT_FILES_TOKEN = new InjectionToken('@analogjs/content Content Files', {
+    providedIn: 'root',
+    factory() {
+        const contentFiles = getContentFiles();
+        const agxFiles = getAgxFiles();
+        const allFiles = { ...contentFiles, ...agxFiles };
+        const contentFilesList = inject(CONTENT_FILES_LIST_TOKEN);
+        const lookup = {};
+        contentFilesList.forEach((item) => {
+            const fileParts = item.filename.split('/');
+            const filePath = fileParts.slice(0, fileParts.length - 1).join('/');
+            const fileNameParts = fileParts[fileParts.length - 1].split('.');
+            lookup[item.filename] = `${filePath}/${item.slug}.${fileNameParts[fileNameParts.length - 1]}`;
+        });
+        const objectUsingSlugAttribute = {};
+        Object.entries(allFiles).forEach((entry) => {
+            const filename = entry[0];
+            const value = entry[1];
+            const newFilename = lookup[filename];
+            if (newFilename !== undefined) {
+                objectUsingSlugAttribute[newFilename] = value;
+            }
+        });
+        return objectUsingSlugAttribute;
+    },
 });
 
-// lib/parse-raw-content-file.mjs
-import fm from "front-matter";
 function parseRawContentFile(rawContentFile) {
-  const { body, attributes } = fm(rawContentFile);
-  return { content: body, attributes };
+    const { body, attributes } = fm(rawContentFile);
+    return { content: body, attributes };
 }
 
-// lib/utils/zone-wait-for.mjs
-import { firstValueFrom, isObservable } from "rxjs";
 async function waitFor(prom) {
-  if (isObservable(prom)) {
-    prom = firstValueFrom(prom);
-  }
-  const macroTask = Zone.current.scheduleMacroTask(`AnalogContentResolve-${Math.random()}`, () => {
-  }, {}, () => {
-  });
-  return prom.then((p) => {
-    macroTask.invoke();
-    return p;
-  });
+    if (isObservable(prom)) {
+        prom = firstValueFrom(prom);
+    }
+    const macroTask = Zone.current.scheduleMacroTask(`AnalogContentResolve-${Math.random()}`, () => { }, {}, () => { });
+    return prom.then((p) => {
+        macroTask.invoke();
+        return p;
+    });
 }
 
-// lib/render-task.service.mjs
-import { Injectable, inject as inject3, ɵPendingTasks as PendingTasks } from "@angular/core";
-import * as i02 from "@angular/core";
-var RenderTaskService = class _RenderTaskService {
-  #pendingTasks = inject3(PendingTasks);
-  addRenderTask() {
-    return this.#pendingTasks.add();
-  }
-  clearRenderTask(id) {
-    this.#pendingTasks.remove(id);
-  }
-  static {
-    this.ɵfac = i02.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i02, type: _RenderTaskService, deps: [], target: i02.ɵɵFactoryTarget.Injectable });
-  }
-  static {
-    this.ɵprov = i02.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i02, type: _RenderTaskService });
-  }
-};
-i02.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i02, type: RenderTaskService, decorators: [{
-  type: Injectable
-}] });
+class RenderTaskService {
+    #pendingTasks = inject(_PendingTasks);
+    addRenderTask() {
+        return this.#pendingTasks.add();
+    }
+    clearRenderTask(id) {
+        this.#pendingTasks.remove(id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: RenderTaskService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: RenderTaskService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: RenderTaskService, decorators: [{
+            type: Injectable
+        }] });
 
-// lib/content.mjs
-import { inject as inject4 } from "@angular/core";
-import { ActivatedRoute } from "@angular/router";
-import { Observable, of } from "rxjs";
-import { map, switchMap, tap } from "rxjs/operators";
+/// <reference types="vite/client" />
 function getContentFile(contentFiles, prefix, slug, fallback) {
-  const filePath = `/src/content/${prefix}${slug}`;
-  const contentFile = contentFiles[`${filePath}.md`] ?? contentFiles[`${filePath}.agx`];
-  if (!contentFile) {
-    return of({
-      filename: filePath,
-      attributes: {},
-      slug: "",
-      content: fallback
-    });
-  }
-  return new Observable((observer) => {
-    const contentResolver = contentFile();
-    if (import.meta.env.SSR === true) {
-      waitFor(contentResolver).then((content) => {
-        observer.next(content);
-      });
-    } else {
-      contentResolver.then((content) => {
-        observer.next(content);
-      });
-    }
-  }).pipe(map((contentFile2) => {
-    if (typeof contentFile2 === "string") {
-      const { content, attributes } = parseRawContentFile(contentFile2);
-      return {
-        filename: filePath,
-        slug,
-        attributes,
-        content
-      };
+    const filePath = `/src/content/${prefix}${slug}`;
+    const contentFile = contentFiles[`${filePath}.md`] ?? contentFiles[`${filePath}.agx`];
+    if (!contentFile) {
+        return of({
+            filename: filePath,
+            attributes: {},
+            slug: '',
+            content: fallback,
+        });
     }
-    return {
-      filename: filePath,
-      slug,
-      attributes: contentFile2.metadata,
-      content: contentFile2.default
-    };
-  }));
+    return new Observable((observer) => {
+        const contentResolver = contentFile();
+        if (import.meta.env.SSR === true) {
+            waitFor(contentResolver).then((content) => {
+                observer.next(content);
+            });
+        }
+        else {
+            contentResolver.then((content) => {
+                observer.next(content);
+            });
+        }
+    }).pipe(map((contentFile) => {
+        if (typeof contentFile === 'string') {
+            const { content, attributes } = parseRawContentFile(contentFile);
+            return {
+                filename: filePath,
+                slug,
+                attributes,
+                content,
+            };
+        }
+        return {
+            filename: filePath,
+            slug,
+            attributes: contentFile.metadata,
+            content: contentFile.default,
+        };
+    }));
 }
-function injectContent(param = "slug", fallback = "No Content Found") {
-  const contentFiles = inject4(CONTENT_FILES_TOKEN);
-  const renderTaskService = inject4(RenderTaskService);
-  const task = renderTaskService.addRenderTask();
-  if (typeof param === "string" || "param" in param) {
-    const prefix = typeof param === "string" ? "" : `${param.subdirectory}/`;
-    const route = inject4(ActivatedRoute);
-    const paramKey = typeof param === "string" ? param : param.param;
-    return route.paramMap.pipe(map((params) => params.get(paramKey)), switchMap((slug) => {
-      if (slug) {
-        return getContentFile(contentFiles, prefix, slug, fallback);
-      }
-      return of({
-        filename: "",
-        slug: "",
-        attributes: {},
-        content: fallback
-      });
-    }), tap(() => renderTaskService.clearRenderTask(task)));
-  } else {
-    return getContentFile(contentFiles, "", param.customFilename, fallback).pipe(tap(() => renderTaskService.clearRenderTask(task)));
-  }
+/**
+ * Retrieves the static content using the provided param and/or prefix.
+ *
+ * @param param route parameter (default: 'slug')
+ * @param fallback fallback text if content file is not found (default: 'No Content Found')
+ */
+function injectContent(param = 'slug', fallback = 'No Content Found') {
+    const contentFiles = inject(CONTENT_FILES_TOKEN);
+    const renderTaskService = inject(RenderTaskService);
+    const task = renderTaskService.addRenderTask();
+    if (typeof param === 'string' || 'param' in param) {
+        const prefix = typeof param === 'string' ? '' : `${param.subdirectory}/`;
+        const route = inject(ActivatedRoute);
+        const paramKey = typeof param === 'string' ? param : param.param;
+        return route.paramMap.pipe(map((params) => params.get(paramKey)), switchMap((slug) => {
+            if (slug) {
+                return getContentFile(contentFiles, prefix, slug, fallback);
+            }
+            return of({
+                filename: '',
+                slug: '',
+                attributes: {},
+                content: fallback,
+            });
+        }), tap(() => renderTaskService.clearRenderTask(task)));
+    }
+    else {
+        return getContentFile(contentFiles, '', param.customFilename, fallback).pipe(tap(() => renderTaskService.clearRenderTask(task)));
+    }
 }
 
-// lib/content-renderer.mjs
-import { Injectable as Injectable2 } from "@angular/core";
-import * as i03 from "@angular/core";
-var ContentRenderer = class _ContentRenderer {
-  async render(content) {
-    return content;
-  }
-  getContentHeadings() {
-    return [];
-  }
-  // eslint-disable-next-line
-  enhance() {
-  }
-  static {
-    this.ɵfac = i03.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i03, type: _ContentRenderer, deps: [], target: i03.ɵɵFactoryTarget.Injectable });
-  }
-  static {
-    this.ɵprov = i03.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i03, type: _ContentRenderer });
-  }
-};
-i03.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i03, type: ContentRenderer, decorators: [{
-  type: Injectable2
-}] });
+class ContentRenderer {
+    async render(content) {
+        return content;
+    }
+    getContentHeadings() {
+        return [];
+    }
+    // eslint-disable-next-line
+    enhance() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ContentRenderer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ContentRenderer }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ContentRenderer, decorators: [{
+            type: Injectable
+        }] });
 
-// lib/inject-content-files.mjs
-import { inject as inject5 } from "@angular/core";
 function injectContentFiles(filterFn) {
-  const renderTaskService = inject5(RenderTaskService);
-  const task = renderTaskService.addRenderTask();
-  const allContentFiles = inject5(CONTENT_FILES_LIST_TOKEN);
-  renderTaskService.clearRenderTask(task);
-  if (filterFn) {
-    const filteredContentFiles = allContentFiles.filter(filterFn);
-    return filteredContentFiles;
-  }
-  return allContentFiles;
+    const renderTaskService = inject(RenderTaskService);
+    const task = renderTaskService.addRenderTask();
+    const allContentFiles = inject(CONTENT_FILES_LIST_TOKEN);
+    renderTaskService.clearRenderTask(task);
+    if (filterFn) {
+        const filteredContentFiles = allContentFiles.filter(filterFn);
+        return filteredContentFiles;
+    }
+    return allContentFiles;
 }
 
-// lib/prism/angular.mjs
-(function() {
-  if (typeof Prism === "undefined") {
-    return;
-  }
-  Prism.languages.angular = Prism.languages.extend("markup", {
-    keyword: /(?:@if|@for|@switch|@defer|@loading|@error|@placeholder|prefetch)\b/,
-    operator: /\b(?:on|when)\b/,
-    number: {
-      pattern: /\b(minimum|after)\s+\d+(?:s|ms|)/gi,
-      lookbehind: true
-    },
-    builtin: {
-      pattern: /\b(?:viewport|timer|minimum|after|hover|idle|immediate|interaction)/
-    },
-    function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/
-  });
-  Prism.languages.ng = Prism.languages.angular;
+"use strict";
+(function () {
+    if (typeof Prism === 'undefined') {
+        return;
+    }
+    Prism.languages.angular = Prism.languages.extend('markup', {
+        keyword: /(?:@if|@for|@switch|@defer|@loading|@error|@placeholder|prefetch)\b/,
+        operator: /\b(?:on|when)\b/,
+        number: {
+            pattern: /\b(minimum|after)\s+\d+(?:s|ms|)/gi,
+            lookbehind: true,
+        },
+        builtin: {
+            pattern: /\b(?:viewport|timer|minimum|after|hover|idle|immediate|interaction)/,
+        },
+        function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+    });
+    Prism.languages.ng = Prism.languages.angular;
 })();
 
-// lib/marked-setup.service.mjs
-import { Injectable as Injectable3 } from "@angular/core";
-import { marked } from "marked";
-import { gfmHeadingId } from "marked-gfm-heading-id";
-import { markedHighlight } from "marked-highlight";
-import "prismjs";
-import "prismjs/components/prism-bash";
-import "prismjs/components/prism-css";
-import "prismjs/components/prism-javascript";
-import "prismjs/components/prism-json";
-import "prismjs/components/prism-markup";
-import "prismjs/components/prism-typescript";
-import "prismjs/plugins/copy-to-clipboard/prism-copy-to-clipboard";
-import "prismjs/plugins/toolbar/prism-toolbar";
-import * as i04 from "@angular/core";
-var MarkedSetupService = class _MarkedSetupService {
-  constructor() {
-    const renderer = new marked.Renderer();
-    renderer.code = (code, lang) => {
-      if (lang === "mermaid") {
-        return '<pre class="mermaid">' + code + "</pre>";
-      }
-      if (!lang) {
-        return "<pre><code>" + code + "</code></pre>";
-      }
-      const classes = lang.startsWith("diff") && Prism.languages["diff"] ? `language-${lang} diff-highlight` : `language-${lang.replace("diff-", "")}`;
-      return `<pre class="${classes}"><code class="${classes}">${code}</code></pre>`;
-    };
-    marked.use(gfmHeadingId(), markedHighlight({
-      async: true,
-      highlight: (code, lang) => {
-        let diff = lang?.startsWith("diff-");
-        lang = diff ? lang.replace("diff-", "") : lang || "typescript";
-        if (diff && !Prism.languages["diff"]) {
-          diff = false;
-          console.warn(`Notice:
+/**
+ * Credit goes to Scully for original implementation
+ * https://github.com/scullyio/scully/blob/main/libs/scully/src/lib/fileHanderPlugins/markdown.ts
+ */
+class MarkedSetupService {
+    constructor() {
+        const renderer = new marked.Renderer();
+        renderer.code = (code, lang) => {
+            // Let's do a language based detection like on GitHub
+            // So we can still have non-interpreted mermaid code
+            if (lang === 'mermaid') {
+                return '<pre class="mermaid">' + code + '</pre>';
+            }
+            if (!lang) {
+                return '<pre><code>' + code + '</code></pre>';
+            }
+            const classes = lang.startsWith('diff') && Prism.languages['diff']
+                ? `language-${lang} diff-highlight`
+                : `language-${lang.replace('diff-', '')}`;
+            return `<pre class="${classes}"><code class="${classes}">${code}</code></pre>`;
+        };
+        marked.use(gfmHeadingId(), markedHighlight({
+            async: true,
+            highlight: (code, lang) => {
+                let diff = lang?.startsWith('diff-');
+                lang = diff ? lang.replace('diff-', '') : lang || 'typescript';
+                if (diff && !Prism.languages['diff']) {
+                    diff = false;
+                    console.warn(`Notice:
     ---------------------------------------------------------------------------------------
     The \`diff\` language and plugin are not available in the provided setup.
     To enable it, add the following imports your \`main.ts\`:
@@ -322,242 +320,206 @@ var MarkedSetupService = class _MarkedSetupService {
       import 'prismjs/plugins/diff-highlight/prism-diff-highlight';
     ---------------------------------------------------------------------------------------
             `);
-        }
-        if (!Prism.languages[lang]) {
-          if (lang !== "mermaid") {
-            console.warn(`Notice:
+                }
+                if (!Prism.languages[lang]) {
+                    if (lang !== 'mermaid') {
+                        console.warn(`Notice:
     ---------------------------------------------------------------------------------------
     The requested language '${lang}' is not available in the provided setup.
     To enable it, add the following import your \`main.ts\`:
       import 'prismjs/components/prism-${lang}';
     ---------------------------------------------------------------------------------------
               `);
-          }
-          return code;
-        }
-        return Prism.highlight(code, diff ? Prism.languages["diff"] : Prism.languages[lang], lang);
-      }
-    }), {
-      renderer,
-      pedantic: false,
-      gfm: true,
-      breaks: false,
-      sanitize: false,
-      smartypants: false,
-      xhtml: false,
-      mangle: false
-    });
-    this.marked = marked;
-  }
-  getMarkedInstance() {
-    return this.marked;
-  }
-  static {
-    this.ɵfac = i04.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i04, type: _MarkedSetupService, deps: [], target: i04.ɵɵFactoryTarget.Injectable });
-  }
-  static {
-    this.ɵprov = i04.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i04, type: _MarkedSetupService });
-  }
-};
-i04.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i04, type: MarkedSetupService, decorators: [{
-  type: Injectable3
-}], ctorParameters: () => [] });
+                    }
+                    return code;
+                }
+                return Prism.highlight(code, diff ? Prism.languages['diff'] : Prism.languages[lang], lang);
+            },
+        }), {
+            renderer,
+            pedantic: false,
+            gfm: true,
+            breaks: false,
+            sanitize: false,
+            smartypants: false,
+            xhtml: false,
+            mangle: false,
+        });
+        this.marked = marked;
+    }
+    getMarkedInstance() {
+        return this.marked;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MarkedSetupService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MarkedSetupService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MarkedSetupService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
 
-// lib/markdown-content-renderer.service.mjs
-import { inject as inject6, Injectable as Injectable4, InjectionToken as InjectionToken3 } from "@angular/core";
-import { getHeadingList } from "marked-gfm-heading-id";
-import * as i05 from "@angular/core";
-var MarkdownContentRendererService = class _MarkdownContentRendererService {
-  #marked = inject6(MarkedSetupService, { self: true });
-  async render(content) {
-    return this.#marked.getMarkedInstance().parse(content);
-  }
-  /**
-   * The method is meant to be called after `render()`
-   */
-  getContentHeadings() {
-    return getHeadingList();
-  }
-  // eslint-disable-next-line
-  enhance() {
-  }
-  static {
-    this.ɵfac = i05.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i05, type: _MarkdownContentRendererService, deps: [], target: i05.ɵɵFactoryTarget.Injectable });
-  }
-  static {
-    this.ɵprov = i05.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i05, type: _MarkdownContentRendererService });
-  }
-};
-i05.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i05, type: MarkdownContentRendererService, decorators: [{
-  type: Injectable4
-}] });
+class MarkdownContentRendererService {
+    #marked = inject(MarkedSetupService, { self: true });
+    async render(content) {
+        return this.#marked.getMarkedInstance().parse(content);
+    }
+    /**
+     * The method is meant to be called after `render()`
+     */
+    getContentHeadings() {
+        return getHeadingList();
+    }
+    // eslint-disable-next-line
+    enhance() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MarkdownContentRendererService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MarkdownContentRendererService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: MarkdownContentRendererService, decorators: [{
+            type: Injectable
+        }] });
 function withMarkdownRenderer(options) {
-  return [
-    MarkedSetupService,
-    RenderTaskService,
-    {
-      provide: ContentRenderer,
-      useFactory: () => new MarkdownContentRendererService(),
-      deps: [MarkedSetupService]
-    },
-    options?.loadMermaid ? [
-      {
-        provide: MERMAID_IMPORT_TOKEN,
-        useFactory: options.loadMermaid
-      }
-    ] : []
-  ];
+    return [
+        MarkedSetupService,
+        RenderTaskService,
+        {
+            provide: ContentRenderer,
+            useFactory: () => new MarkdownContentRendererService(),
+            deps: [MarkedSetupService],
+        },
+        options?.loadMermaid
+            ? [
+                {
+                    provide: MERMAID_IMPORT_TOKEN,
+                    useFactory: options.loadMermaid,
+                },
+            ]
+            : [],
+    ];
 }
 function provideContent(...features) {
-  return [...features];
+    return [...features];
 }
-var MERMAID_IMPORT_TOKEN = new InjectionToken3("mermaid_import");
+const MERMAID_IMPORT_TOKEN = new InjectionToken('mermaid_import');
 
-// lib/markdown-route.component.mjs
-import { AsyncPipe } from "@angular/common";
-import { Component, inject as inject7, Input, ViewEncapsulation } from "@angular/core";
-import { DomSanitizer } from "@angular/platform-browser";
-import { ActivatedRoute as ActivatedRoute2 } from "@angular/router";
-import * as i06 from "@angular/core";
-var AnalogMarkdownRouteComponent = class _AnalogMarkdownRouteComponent {
-  constructor() {
-    this.sanitizer = inject7(DomSanitizer);
-    this.route = inject7(ActivatedRoute2);
-    this.contentRenderer = inject7(ContentRenderer);
-    this.content = this.sanitizer.bypassSecurityTrustHtml(this.route.snapshot.data["renderedAnalogContent"]);
-    this.classes = "analog-markdown-route";
-  }
-  ngAfterViewChecked() {
-    this.contentRenderer.enhance();
-  }
-  static {
-    this.ɵfac = i06.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i06, type: _AnalogMarkdownRouteComponent, deps: [], target: i06.ɵɵFactoryTarget.Component });
-  }
-  static {
-    this.ɵcmp = i06.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.0-rc.1", type: _AnalogMarkdownRouteComponent, isStandalone: true, selector: "analog-markdown-route", inputs: { classes: "classes" }, hostDirectives: [{ directive: AnchorNavigationDirective }], ngImport: i06, template: `<div [innerHTML]="content" [class]="classes"></div>`, isInline: true, encapsulation: i06.ViewEncapsulation.None, preserveWhitespaces: true });
-  }
-};
-i06.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i06, type: AnalogMarkdownRouteComponent, decorators: [{
-  type: Component,
-  args: [{
-    selector: "analog-markdown-route",
-    standalone: true,
-    imports: [AsyncPipe],
-    hostDirectives: [AnchorNavigationDirective],
-    preserveWhitespaces: true,
-    encapsulation: ViewEncapsulation.None,
-    template: `<div [innerHTML]="content" [class]="classes"></div>`
-  }]
-}], propDecorators: { classes: [{
-  type: Input
-}] } });
+class AnalogMarkdownRouteComponent {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+        this.route = inject(ActivatedRoute);
+        this.contentRenderer = inject(ContentRenderer);
+        this.content = this.sanitizer.bypassSecurityTrustHtml(this.route.snapshot.data['renderedAnalogContent']);
+        this.classes = 'analog-markdown-route';
+    }
+    ngAfterViewChecked() {
+        this.contentRenderer.enhance();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AnalogMarkdownRouteComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.0", type: AnalogMarkdownRouteComponent, isStandalone: true, selector: "analog-markdown-route", inputs: { classes: "classes" }, hostDirectives: [{ directive: AnchorNavigationDirective }], ngImport: i0, template: `<div [innerHTML]="content" [class]="classes"></div>`, isInline: true, encapsulation: i0.ViewEncapsulation.None, preserveWhitespaces: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AnalogMarkdownRouteComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'analog-markdown-route',
+                    standalone: true,
+                    imports: [AsyncPipe],
+                    hostDirectives: [AnchorNavigationDirective],
+                    preserveWhitespaces: true,
+                    encapsulation: ViewEncapsulation.None,
+                    template: `<div [innerHTML]="content" [class]="classes"></div>`,
+                }]
+        }], propDecorators: { classes: [{
+                type: Input
+            }] } });
 
-// lib/markdown.component.mjs
-import { AsyncPipe as AsyncPipe2, isPlatformBrowser } from "@angular/common";
-import { Component as Component2, Input as Input2, NgZone, PLATFORM_ID, ViewChild, ViewContainerRef, ViewEncapsulation as ViewEncapsulation3, inject as inject8 } from "@angular/core";
-import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
-import { DomSanitizer as DomSanitizer2 } from "@angular/platform-browser";
-import { ActivatedRoute as ActivatedRoute3 } from "@angular/router";
-import { from, of as of2 } from "rxjs";
-import { catchError, map as map2, mergeMap } from "rxjs/operators";
-import * as i07 from "@angular/core";
-var AnalogMarkdownComponent = class _AnalogMarkdownComponent {
-  constructor() {
-    this.sanitizer = inject8(DomSanitizer2);
-    this.route = inject8(ActivatedRoute3);
-    this.zone = inject8(NgZone);
-    this.platformId = inject8(PLATFORM_ID);
-    this.mermaidImport = inject8(MERMAID_IMPORT_TOKEN, {
-      optional: true
-    });
-    this.content$ = this.getContentSource();
-    this.classes = "analog-markdown";
-    this.contentRenderer = inject8(ContentRenderer);
-    if (isPlatformBrowser(this.platformId) && this.mermaidImport) {
-      this.loadMermaid(this.mermaidImport);
+class AnalogMarkdownComponent {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+        this.route = inject(ActivatedRoute);
+        this.zone = inject(NgZone);
+        this.platformId = inject(PLATFORM_ID);
+        this.mermaidImport = inject(MERMAID_IMPORT_TOKEN, {
+            optional: true,
+        });
+        this.content$ = this.getContentSource();
+        this.classes = 'analog-markdown';
+        this.contentRenderer = inject(ContentRenderer);
+        if (isPlatformBrowser(this.platformId) && this.mermaidImport) {
+            // Mermaid can only be loaded on client side
+            this.loadMermaid(this.mermaidImport);
+        }
+    }
+    ngOnInit() {
+        this.updateContent();
+    }
+    ngOnChanges() {
+        this.updateContent();
+    }
+    updateContent() {
+        if (this.content && typeof this.content !== 'string') {
+            this.container.clear();
+            const componentRef = this.container.createComponent(this.content);
+            componentRef.changeDetectorRef.detectChanges();
+        }
+        else {
+            this.content$ = this.getContentSource();
+        }
     }
-  }
-  ngOnInit() {
-    this.updateContent();
-  }
-  ngOnChanges() {
-    this.updateContent();
-  }
-  updateContent() {
-    if (this.content && typeof this.content !== "string") {
-      this.container.clear();
-      const componentRef = this.container.createComponent(this.content);
-      componentRef.changeDetectorRef.detectChanges();
-    } else {
-      this.content$ = this.getContentSource();
+    getContentSource() {
+        return this.route.data.pipe(map((data) => this.content ?? data['_analogContent']), mergeMap((contentString) => this.renderContent(contentString)), map((content) => this.sanitizer.bypassSecurityTrustHtml(content)), catchError((e) => of(`There was an error ${e}`)));
     }
-  }
-  getContentSource() {
-    return this.route.data.pipe(map2((data) => this.content ?? data["_analogContent"]), mergeMap((contentString) => this.renderContent(contentString)), map2((content) => this.sanitizer.bypassSecurityTrustHtml(content)), catchError((e) => of2(`There was an error ${e}`)));
-  }
-  async renderContent(content) {
-    return this.contentRenderer.render(content);
-  }
-  ngAfterViewChecked() {
-    this.contentRenderer.enhance();
-    this.zone.runOutsideAngular(() => this.mermaid?.default.run());
-  }
-  loadMermaid(mermaidImport) {
-    this.zone.runOutsideAngular(() => (
-      // Wrap into an observable to avoid redundant initialization once
-      // the markdown component is destroyed before the promise is resolved.
-      from(mermaidImport).pipe(takeUntilDestroyed()).subscribe((mermaid) => {
-        this.mermaid = mermaid;
-        this.mermaid.default.initialize({ startOnLoad: false });
-        this.mermaid?.default.run();
-      })
-    ));
-  }
-  static {
-    this.ɵfac = i07.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i07, type: _AnalogMarkdownComponent, deps: [], target: i07.ɵɵFactoryTarget.Component });
-  }
-  static {
-    this.ɵcmp = i07.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.0-rc.1", type: _AnalogMarkdownComponent, isStandalone: true, selector: "analog-markdown", inputs: { content: "content", classes: "classes" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, hostDirectives: [{ directive: AnchorNavigationDirective }], ngImport: i07, template: `<div
+    async renderContent(content) {
+        return this.contentRenderer.render(content);
+    }
+    ngAfterViewChecked() {
+        this.contentRenderer.enhance();
+        this.zone.runOutsideAngular(() => this.mermaid?.default.run());
+    }
+    loadMermaid(mermaidImport) {
+        this.zone.runOutsideAngular(() => 
+        // Wrap into an observable to avoid redundant initialization once
+        // the markdown component is destroyed before the promise is resolved.
+        from(mermaidImport)
+            .pipe(takeUntilDestroyed())
+            .subscribe((mermaid) => {
+            this.mermaid = mermaid;
+            this.mermaid.default.initialize({ startOnLoad: false });
+            // Explicitly running mermaid as ngAfterViewChecked
+            // has probably already been called
+            this.mermaid?.default.run();
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AnalogMarkdownComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.0", type: AnalogMarkdownComponent, isStandalone: true, selector: "analog-markdown", inputs: { content: "content", classes: "classes" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef, static: true }], usesOnChanges: true, hostDirectives: [{ directive: AnchorNavigationDirective }], ngImport: i0, template: `<div
     #container
     [innerHTML]="content$ | async"
     [class]="classes"
-  ></div>`, isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe2, name: "async" }], encapsulation: i07.ViewEncapsulation.None, preserveWhitespaces: true });
-  }
-};
-i07.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.1", ngImport: i07, type: AnalogMarkdownComponent, decorators: [{
-  type: Component2,
-  args: [{
-    selector: "analog-markdown",
-    standalone: true,
-    imports: [AsyncPipe2],
-    hostDirectives: [AnchorNavigationDirective],
-    preserveWhitespaces: true,
-    encapsulation: ViewEncapsulation3.None,
-    template: `<div
+  ></div>`, isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None, preserveWhitespaces: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AnalogMarkdownComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'analog-markdown',
+                    standalone: true,
+                    imports: [AsyncPipe],
+                    hostDirectives: [AnchorNavigationDirective],
+                    preserveWhitespaces: true,
+                    encapsulation: ViewEncapsulation.None,
+                    template: `<div
     #container
     [innerHTML]="content$ | async"
     [class]="classes"
-  ></div>`
-  }]
-}], ctorParameters: () => [], propDecorators: { content: [{
-  type: Input2
-}], classes: [{
-  type: Input2
-}], container: [{
-  type: ViewChild,
-  args: ["container", { static: true, read: ViewContainerRef }]
-}] } });
-export {
-  AnchorNavigationDirective,
-  ContentRenderer,
-  AnalogMarkdownComponent as MarkdownComponent,
-  MarkdownContentRendererService,
-  AnalogMarkdownRouteComponent as MarkdownRouteComponent,
-  MarkedSetupService,
-  injectContent,
-  injectContentFiles,
-  parseRawContentFile,
-  provideContent,
-  withMarkdownRenderer
-};
+  ></div>`,
+                }]
+        }], ctorParameters: () => [], propDecorators: { content: [{
+                type: Input
+            }], classes: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { static: true, read: ViewContainerRef }]
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AnchorNavigationDirective, ContentRenderer, AnalogMarkdownComponent as MarkdownComponent, MarkdownContentRendererService, AnalogMarkdownRouteComponent as MarkdownRouteComponent, MarkedSetupService, injectContent, injectContentFiles, parseRawContentFile, provideContent, withMarkdownRenderer };
 //# sourceMappingURL=analogjs-content.mjs.map