@mdfriday/foundry 25.12.1 → 26.2.2

package/dist/internal/application/incremental-build-coordinator.d.ts

@@ -11,7 +11,7 @@ export interface IncrementalBuildConfig {
     enableWatching: boolean;
     batchDelay?: number;
     progressCallback?: SSGProgressCallback;
-    markdown: MarkdownRenderer;
+    markdown?: MarkdownRenderer;
     httpClient?: HttpClient;
     liveReload?: {
         enabled?: boolean;

package/dist/internal/application/ssg.d.ts

@@ -13,8 +13,8 @@ export interface DomainInstances {
     modules: Modules;
     resources: Resources;
 }
-export declare function generateStaticSite(projDir: string, modulesDir: string, markdown: MarkdownRenderer): Promise<void>;
-export declare function processSSG(projDir: string, modulesDir: string, markdown: MarkdownRenderer): Promise<void>;
+export declare function generateStaticSite(projDir: string, modulesDir: string, markdown?: MarkdownRenderer): Promise<void>;
+export declare function processSSG(projDir: string, modulesDir: string, markdown?: MarkdownRenderer): Promise<void>;
 export interface SSGProgressCallback {
     (progress: {
         stage: 'config' | 'modules' | 'filesystem' | 'content' | 'site' | 'template' | 'pages' | 'build' | 'completion';
@@ -30,6 +30,6 @@ export interface SSGProgressCallback {
         };
     }): void;
 }
-export declare function generateStaticSiteWithProgress(projDir: string, modulesDir: string, markdown: MarkdownRenderer, onProgress?: SSGProgressCallback, httpClient?: HttpClient): Promise<DomainInstances>;
-export declare function processSSGWithProgress(projDir: string, modulesDir: string, markdown: MarkdownRenderer, onProgress?: SSGProgressCallback, httpClient?: HttpClient): Promise<void>;
-export declare function serveSSG(projDir: string, modulesDir: string, markdown: MarkdownRenderer, onProgress?: SSGProgressCallback, httpClient?: HttpClient): Promise<DomainInstances>;
+export declare function generateStaticSiteWithProgress(projDir: string, modulesDir: string, markdown?: MarkdownRenderer, onProgress?: SSGProgressCallback, httpClient?: HttpClient): Promise<DomainInstances>;
+export declare function processSSGWithProgress(projDir: string, modulesDir: string, markdown?: MarkdownRenderer, onProgress?: SSGProgressCallback, httpClient?: HttpClient): Promise<void>;
+export declare function serveSSG(projDir: string, modulesDir: string, markdown?: MarkdownRenderer, onProgress?: SSGProgressCallback, httpClient?: HttpClient): Promise<DomainInstances>;

package/dist/internal/domain/config/entity/config.d.ts

@@ -7,6 +7,7 @@ import { Social } from './social';
 import { Language } from './language';
 import { Taxonomy } from './taxonomy';
 import { Dir } from "./dir";
+import { Markdown } from './markdown';
 export declare class Config {
     private configSourceFs;
     private provider;
@@ -17,7 +18,8 @@ export declare class Config {
     private social;
     private language;
     private taxonomy;
-    constructor(configSourceFs: Fs, provider: Provider, root: Root, dir: Dir, module: Module, service: Service, social: Social, language: Language, taxonomy: Taxonomy);
+    private markdown;
+    constructor(configSourceFs: Fs, provider: Provider, root: Root, dir: Dir, module: Module, service: Service, social: Social, language: Language, taxonomy: Taxonomy, markdown: Markdown);
     fs(): Fs;
     getProvider(): Provider;
     theme(): string;
@@ -28,8 +30,10 @@ export declare class Config {
     getSocial(): Social;
     getLanguage(): Language;
     getTaxonomy(): Taxonomy;
+    getMarkdown(): Markdown;
     setLanguage(language: Language): void;
     setTaxonomy(taxonomy: Taxonomy): void;
+    setMarkdown(markdown: Markdown): void;
     validate(): boolean;
 }
-export declare function newConfig(configSourceFs: Fs, provider: Provider, root: Root, dir: Dir, module: Module, service: Service, social: Social, language: Language, taxonomy: Taxonomy): Config;
+export declare function newConfig(configSourceFs: Fs, provider: Provider, root: Root, dir: Dir, module: Module, service: Service, social: Social, language: Language, taxonomy: Taxonomy, markdown: Markdown): Config;

package/dist/internal/domain/config/entity/markdown.d.ts

@@ -0,0 +1,16 @@
+import { MarkdownConfig, MarkdownPlugins } from '../type';
+export declare class Markdown {
+    private markdownConfig;
+    constructor(markdownConfig: MarkdownConfig);
+    useInternalRenderer(): boolean;
+    isWikilinkEnabled(): boolean;
+    isTagEnabled(): boolean;
+    isCalloutEnabled(): boolean;
+    isLatexEnabled(): boolean;
+    isMermaidEnabled(): boolean;
+    getMarkdownConfig(): MarkdownConfig;
+    getPlugins(): MarkdownPlugins;
+    hasEnabledPlugins(): boolean;
+    validate(): boolean;
+}
+export declare function newMarkdown(data: any): Markdown;

package/dist/internal/domain/config/index.d.ts

@@ -6,10 +6,12 @@ export { Service, newService } from './entity/service';
 export { Language, newLanguage } from './entity/language';
 export { Taxonomy, newTaxonomy } from './entity/taxonomy';
 export { Social, newSocial } from './entity/social';
+export { Markdown, newMarkdown } from './entity/markdown';
 export * from './vo/root';
 export * from './vo/module';
 export * from './vo/service';
 export * from './vo/language';
 export * from './vo/taxonomy';
 export * from './vo/social';
+export * from './vo/markdown';
 export { loadConfigWithParams } from './factory/config';

package/dist/internal/domain/config/type.d.ts

@@ -112,6 +112,17 @@ export interface ViewName {
     plural: string;
     pluralTreeKey: string;
 }
+export interface MarkdownPlugins {
+    wikilink: boolean;
+    tag: boolean;
+    callout: boolean;
+    latex: boolean;
+    mermaid: boolean;
+}
+export interface MarkdownConfig {
+    useInternalRenderer: boolean;
+    plugins: MarkdownPlugins;
+}
 export declare class ConfigError extends Error {
     code?: string | undefined;
     constructor(message: string, code?: string | undefined);

package/dist/internal/domain/config/vo/markdown.d.ts

@@ -0,0 +1,5 @@
+import { MarkdownConfig, MarkdownPlugins } from '../type';
+export declare const DefaultMarkdownPlugins: MarkdownPlugins;
+export declare const DefaultMarkdownConfig: MarkdownConfig;
+export declare function decodeMarkdownConfig(data: any): MarkdownConfig;
+export declare function isDefaultMarkdownConfig(config: MarkdownConfig): boolean;

package/dist/internal/domain/content/entity/page.d.ts

@@ -26,6 +26,8 @@ export declare class PageImpl implements Page {
     section(): string;
     paths(): Path;
     path(): string;
+    slug(): string;
+    private pathToSlug;
     posOffset(offset: number): Promise<Position>;
     description(): string;
     get Description(): string;

package/dist/internal/domain/content/entity/pagesource.d.ts

@@ -17,6 +17,8 @@ export declare class Source implements PageSource {
     section(): string;
     paths(): any;
     path(): string;
+    slug(): string;
+    private pathToSlug;
     opener(): () => Promise<any>;
     openReader(): any;
     content(): Promise<Uint8Array>;

package/dist/internal/domain/content/type.d.ts

@@ -6,8 +6,16 @@ export interface ComponentPath {
     component(): string;
     path(): string;
 }
-export interface Services extends URLService, LangService, FsService, TaxonomyService {
-    markdown(): MarkdownRenderer;
+export interface Services extends URLService, LangService, FsService, TaxonomyService, MDService {
+    markdown(): MarkdownRenderer | undefined;
+}
+export interface MDService {
+    useInternalRenderer(): boolean;
+    isWikilinkEnabled(): boolean;
+    isTagEnabled(): boolean;
+    isCalloutEnabled(): boolean;
+    isLatexEnabled(): boolean;
+    isMermaidEnabled(): boolean;
 }
 export interface URLService {
     baseUrl(): string;
@@ -55,6 +63,7 @@ export interface PageSource {
     section(): string;
     paths(): Path;
     path(): string;
+    slug(): string;
 }
 export interface FileProvider {
     file(): File;
@@ -196,6 +205,7 @@ export interface FileWithoutOverlap {
     dir(): string;
     ext(): string;
     logicalName(): string;
+    originalBaseFileName(): string;
     baseFileName(): string;
     translationBaseName(): string;
     contentBaseName(): string;
@@ -261,7 +271,7 @@ export interface FrontMatter {
     title: string;
     description: string;
     weight: number;
-    date: Date;
+    date?: Date;
     terms: Record<string, string[]>;
     params?: Record<string, any> | undefined;
     organization?: Organization;

package/dist/internal/domain/content/vo/fileinfo.d.ts

@@ -19,6 +19,7 @@ export declare class FileInfo implements File {
     dir(): string;
     ext(): string;
     logicalName(): string;
+    originalBaseFileName(): string;
     baseFileName(): string;
     translationBaseName(): string;
     contentBaseName(): string;

package/dist/internal/domain/markdown/entity/markdown.d.ts

@@ -10,6 +10,8 @@ export declare class MarkdownImpl implements Markdown {
     isDefaultCodeBlockRenderer(): boolean;
     prepareRender(source: Uint8Array): Promise<RenderableDocument>;
     parseAndRenderContent(source: Uint8Array, options?: ParseAndRenderOptions): Promise<ContentResult>;
+    private hasCollectedTagsSupport;
+    private getCollectedTags;
     parseContent(source: Uint8Array): Promise<ParsedContentResult>;
     private parseFrontMatter;
     private parseYAML;

package/dist/internal/domain/markdown/factory/it/config.d.ts

@@ -0,0 +1,107 @@
+export declare const AutoHeadingIDType: {
+    readonly GitHub: "github";
+    readonly GitHubAscii: "github-ascii";
+    readonly Blackfriday: "blackfriday";
+};
+export type AutoHeadingIDType = typeof AutoHeadingIDType[keyof typeof AutoHeadingIDType];
+export interface TypographerConfig {
+    disable: boolean;
+    leftSingleQuote: string;
+    rightSingleQuote: string;
+    leftDoubleQuote: string;
+    rightDoubleQuote: string;
+    enDash: string;
+    emDash: string;
+    ellipsis: string;
+    leftAngleQuote: string;
+    rightAngleQuote: string;
+    apostrophe: string;
+}
+export interface CJKConfig {
+    enable: boolean;
+    eastAsianLineBreaks: boolean;
+    eastAsianLineBreaksStyle: string;
+    escapedSpace: boolean;
+}
+export interface DelimitersConfig {
+    inline: string[][];
+    block: string[][];
+}
+export interface PassthroughConfig {
+    enable: boolean;
+    delimiters: DelimitersConfig;
+}
+export interface HighlightConfig {
+    style: string;
+    lineNos: boolean;
+    lineNoStart: number;
+    anchorLineNos: boolean;
+    lineAnchors: string;
+    lineNumbersInTable: boolean;
+    noClasses: boolean;
+    codeFences: boolean;
+    guessSyntax: boolean;
+    tabWidth: number;
+}
+export interface ParserAttributeConfig {
+    title: boolean;
+    block: boolean;
+}
+export interface ParserConfig {
+    autoHeadingID: boolean;
+    autoHeadingIDType: AutoHeadingIDType;
+    wrapStandAloneImageWithinParagraph: boolean;
+    attribute: ParserAttributeConfig;
+}
+export interface RendererConfig {
+    unsafe: boolean;
+}
+export interface WikilinkConfig {
+    enable: boolean;
+    disableBrokenWikilinks?: boolean;
+    markdownLinkResolution?: 'absolute' | 'relative' | 'shortest';
+    prettyLinks?: boolean;
+}
+export interface LatexConfig {
+    enable: boolean;
+}
+export interface MermaidConfig {
+    enable: boolean;
+}
+export interface ExtensionsConfig {
+    typographer: TypographerConfig;
+    footnote: boolean;
+    definitionList: boolean;
+    table: boolean;
+    strikethrough: boolean;
+    linkify: boolean;
+    linkifyProtocol: string;
+    taskList: boolean;
+    cjk: CJKConfig;
+    passthrough: PassthroughConfig;
+    highlight: HighlightConfig;
+    wikilink?: WikilinkConfig;
+    parseTags?: boolean;
+    callouts?: boolean;
+    latex?: LatexConfig;
+    mermaid?: MermaidConfig;
+}
+export interface ImageRenderHookConfig {
+    enableDefault: boolean;
+}
+export interface LinkRenderHookConfig {
+    enableDefault: boolean;
+}
+export interface RenderHooksConfig {
+    image: ImageRenderHookConfig;
+    link: LinkRenderHookConfig;
+}
+export interface DomainMarkdownConfig {
+    renderer: RendererConfig;
+    parser: ParserConfig;
+    extensions: ExtensionsConfig;
+    duplicateResourceFiles: boolean;
+    renderHooks: RenderHooksConfig;
+}
+export declare const DefaultHighlightConfig: HighlightConfig;
+export declare const DefaultMarkdownConfig: DomainMarkdownConfig;

package/dist/internal/domain/markdown/factory/it/index.d.ts

@@ -0,0 +1,32 @@
+import MarkdownIt from 'markdown-it';
+import Token from 'markdown-it/lib/token.mjs';
+import { DomainMarkdownConfig } from './config';
+import { MarkdownRenderer, ParsingResult } from "@internal/domain/markdown";
+export declare class MarkdownItRenderer implements MarkdownRenderer {
+    private md;
+    private config;
+    private idGenerator;
+    private collectedTags;
+    constructor(config: DomainMarkdownConfig, externalMd?: MarkdownIt);
+    private setupRendererRules;
+    render(source: string): Promise<string>;
+    getCollectedTags(): string[];
+    parse(source: string): Promise<ParsingResult>;
+    _parse(source: string): Promise<Token[]>;
+    getMarkdownIt(): MarkdownIt;
+    addPlugin(plugin: any, options?: any): void;
+    private createMarkdownItInstance;
+    private configureBasicPlugins;
+}
+export declare function createMarkdownItRenderer(config?: Partial<DomainMarkdownConfig>, externalMd?: MarkdownIt): MarkdownItRenderer;
+export { DomainMarkdownConfig, DefaultMarkdownConfig } from './config';
+export { ParserResult } from './parserresult';
+export { TableOfContentsImpl, HeaderImpl, LinkImpl, ParagraphImpl, TOCBuilder, AutoIDGenerator, Fragment } from './tableofcontents';
+export { wikilinkPlugin } from './plugins/wikilink-plugin';
+export { tagPlugin } from './plugins/tag-plugin';
+export { calloutPlugin } from './plugins/callout-plugin';
+export { latexPlugin } from './plugins/latex-plugin';
+export { mermaidPlugin } from './plugins/mermaid-plugin';
+export { preprocessWikilinks } from './plugins/wikilink';
+export * from './util/path';
+export * from './util/slugger-fallback';

package/dist/internal/domain/markdown/factory/it/parserresult.d.ts

@@ -0,0 +1,18 @@
+import Token from 'markdown-it/lib/token.mjs';
+import { ParsingResult, Header, TocFragments } from '../../index';
+import { AutoIDGenerator } from '@internal/domain/markdown/vo/tableofcontents';
+export declare class ParserResult implements ParsingResult {
+    private _headers;
+    private _toc;
+    private tokens;
+    private source;
+    private idGenerator;
+    constructor(tokens: Token[], source: Uint8Array, idGenerator?: AutoIDGenerator);
+    headers(): Header[];
+    tableOfContents(): TocFragments;
+    getTokens(): Token[];
+    getSource(): Uint8Array;
+    private buildTableOfContents;
+    private extractHeaders;
+    private findNextTextToken;
+}

package/dist/internal/domain/markdown/factory/it/plugins/callout-plugin.d.ts

@@ -0,0 +1,6 @@
+import MarkdownIt from 'markdown-it';
+export interface CalloutPluginOptions {
+    enable?: boolean;
+}
+export declare function calloutPlugin(md: MarkdownIt, options?: CalloutPluginOptions): void;
+export default calloutPlugin;

package/dist/internal/domain/markdown/factory/it/plugins/latex-plugin.d.ts

@@ -0,0 +1,6 @@
+import MarkdownIt from 'markdown-it';
+export interface LatexPluginOptions {
+    enable?: boolean;
+}
+export declare function latexPlugin(md: MarkdownIt, options?: LatexPluginOptions): void;
+export default latexPlugin;

package/dist/internal/domain/markdown/factory/it/plugins/mermaid-plugin.d.ts

@@ -0,0 +1,6 @@
+import MarkdownIt from 'markdown-it';
+export interface MermaidPluginOptions {
+    enable?: boolean;
+}
+export declare function mermaidPlugin(md: MarkdownIt, options?: MermaidPluginOptions): void;
+export default mermaidPlugin;

package/dist/internal/domain/markdown/factory/it/plugins/tag-plugin.d.ts

@@ -0,0 +1,24 @@
+import MarkdownIt from 'markdown-it';
+interface TagPluginState {
+    tagBaseURL?: string;
+    onTagFound?: (tag: string) => void;
+}
+declare module 'markdown-it' {
+    interface MarkdownIt {
+        __tagPluginState?: TagPluginState;
+    }
+}
+export interface TagMeta {
+    rawTag: string;
+    slugTag: string;
+    url: string;
+}
+export declare const tagRegex: RegExp;
+export interface TagPluginOptions {
+    enable?: boolean;
+    tagBaseURL?: string;
+    onTagFound?: (tag: string) => void;
+}
+export declare function slugTag(tag: string): string;
+export declare function tagPlugin(md: MarkdownIt, options?: TagPluginOptions): void;
+export default tagPlugin;

package/dist/internal/domain/markdown/factory/it/plugins/wikilink-plugin.d.ts

@@ -0,0 +1,12 @@
+import MarkdownIt from 'markdown-it';
+export interface WikilinkMeta {
+    isEmbed: boolean;
+    filepath: string;
+    anchor: string;
+    alias?: string | undefined;
+    url: string;
+}
+export declare function wikilinkPlugin(md: MarkdownIt, options?: {
+    enable?: boolean;
+}): void;
+export default wikilinkPlugin;

package/dist/internal/domain/markdown/factory/it/plugins/wikilink.d.ts

@@ -0,0 +1,16 @@
+export declare const externalLinkRegex: RegExp;
+export declare const wikilinkRegex: RegExp;
+export declare const tableRegex: RegExp;
+export declare const tableWikilinkRegex: RegExp;
+export declare function preprocessWikilinks(src: string): string;
+export interface WikilinkComponents {
+    isEmbed: boolean;
+    filepath: string;
+    anchor: string;
+    alias?: string;
+    url: string;
+}
+export declare function parseWikilink(match: string): WikilinkComponents | null;
+export declare function getEmbedType(filepath: string): 'image' | 'video' | 'audio' | 'pdf' | 'transclude';
+export declare function generateEmbedHtml(components: WikilinkComponents): string;
+export declare function checkWikilinkExists(filepath: string, allSlugs: string[]): boolean;

package/dist/internal/domain/markdown/factory/it/tableofcontents.d.ts

@@ -0,0 +1,60 @@
+import { TocFragments, Header, Link, Paragraph } from '../../index';
+export interface Fragment {
+    id: string;
+    text: string;
+    level: number;
+    children?: Fragment[];
+}
+export declare class TableOfContentsImpl implements TocFragments {
+    private fragments;
+    constructor(fragments?: Fragment[]);
+    toHTML(startLevel: number, stopLevel: number, ordered: boolean): string;
+    private filterByLevel;
+    private renderFragments;
+    private escapeHTML;
+    addFragment(fragment: Fragment): void;
+    getFragments(): Fragment[];
+}
+export declare class HeaderImpl implements Header {
+    private _name;
+    private _level;
+    private _links;
+    private _paragraphs;
+    private _listParagraphs;
+    constructor(_name: string, _level: number, _links?: Link[], _paragraphs?: Paragraph[], _listParagraphs?: Paragraph[]);
+    name(): string;
+    level(): number;
+    links(): Link[];
+    paragraphs(): Paragraph[];
+    listParagraphs(): Paragraph[];
+    addLink(link: Link): void;
+    addParagraph(paragraph: Paragraph): void;
+    addListParagraph(paragraph: Paragraph): void;
+}
+export declare class LinkImpl implements Link {
+    private _text;
+    private _url;
+    constructor(_text: string, _url: string);
+    text(): string;
+    url(): string;
+}
+export declare class ParagraphImpl implements Paragraph {
+    private _text;
+    constructor(_text: string);
+    text(): string;
+}
+export declare class TOCBuilder {
+    private fragments;
+    private stack;
+    addHeading(text: string, level: number, id: string): void;
+    build(): TableOfContentsImpl;
+    reset(): void;
+}
+export declare class AutoIDGenerator {
+    private usedIds;
+    generateID(text: string, type?: 'github' | 'github-ascii' | 'blackfriday'): string;
+    private githubStyle;
+    private githubAsciiStyle;
+    private blackfridayStyle;
+    reset(): void;
+}

package/dist/internal/domain/markdown/factory/it/util/path.d.ts

@@ -0,0 +1,32 @@
+type SlugLike<T> = string & {
+    __brand: T;
+};
+export type FilePath = SlugLike<"filepath">;
+export declare function isFilePath(s: string): s is FilePath;
+export type FullSlug = SlugLike<"full">;
+export declare function isFullSlug(s: string): s is FullSlug;
+export type SimpleSlug = SlugLike<"simple">;
+export declare function isSimpleSlug(s: string): s is SimpleSlug;
+export type RelativeURL = SlugLike<"relative">;
+export declare function isRelativeURL(s: string): s is RelativeURL;
+export declare function isAbsoluteURL(s: string): boolean;
+export declare function slugifyFilePath(fp: FilePath | string, excludeExt?: boolean): FullSlug;
+export declare function simplifySlug(fp: FullSlug | string): SimpleSlug;
+export declare function transformInternalLink(link: string): RelativeURL;
+export declare function pathToRoot(slug: FullSlug | string): RelativeURL;
+export declare function resolveRelative(current: FullSlug | string, target: FullSlug | SimpleSlug | string): RelativeURL;
+export declare function splitAnchor(link: string): [string, string];
+export declare function slugTag(tag: string): string;
+export declare function joinSegments(...args: string[]): string;
+export declare function getAllSegmentPrefixes(tags: string): string[];
+export interface TransformOptions {
+    strategy: "absolute" | "relative" | "shortest";
+    allSlugs: string[];
+}
+export declare function transformLink(src: string, target: string, opts: TransformOptions): RelativeURL;
+export declare function isFolderPath(fplike: string): boolean;
+export declare function endsWith(s: string, suffix: string): boolean;
+export declare function trimSuffix(s: string, suffix: string): string;
+export declare function getFileExtension(s: string): string | undefined;
+export declare function stripSlashes(s: string, onlyStripPrefix?: boolean): string;
+export {};

package/dist/internal/domain/markdown/factory/it/util/slugger-fallback.d.ts

@@ -0,0 +1,2 @@
+export declare function slug(text: string): string;
+export { slug as slugAnchor };

package/dist/internal/domain/markdown/factory/markdown.d.ts

@@ -1,2 +1,2 @@
 import { Markdown, MarkdownRenderer } from '../type';
-export declare function createMarkdown(renderer: MarkdownRenderer): Markdown;
+export declare function createMarkdown(renderer: MarkdownRenderer | undefined, useInternalRenderer: Boolean): Markdown;

package/dist/internal/domain/paths/entity/path.d.ts

@@ -8,6 +8,7 @@ export declare class Path implements IPath {
     component(): string;
     path(): string;
     name(): string;
+    originalNameNoExt(): string;
     nameNoExt(): string;
     nameNoLang(): string;
     dir(): string;

package/dist/internal/domain/site/entity/page.d.ts

@@ -13,6 +13,7 @@ export declare class Page implements ContentPage, PageMeta {
     private site;
     private resources;
     private _paginator;
+    private _processedContent;
     constructor(tmplSvc: Template, langSvc: LanguageService, publisher: Publisher, contentPage: ContentPage, site: Site);
     processResources(pageSources: PageSource[]): Promise<void>;
     render(): Promise<void>;
@@ -29,6 +30,7 @@ export declare class Page implements ContentPage, PageMeta {
     section(): string;
     paths(): import("../../paths").Path;
     path(): string;
+    slug(): string;
     file(): import("@internal/domain/content").File;
     name(): string;
     title(): string;
@@ -42,9 +44,12 @@ export declare class Page implements ContentPage, PageMeta {
     get IsSection(): boolean;
     get IsPage(): boolean;
     get Content(): Promise<any>;
+    WikilinkContent(): Promise<any>;
     Summary(): Promise<string>;
     ReadingTime(): Promise<number>;
     WordCount(): Promise<number>;
+    Backlinks(): Promise<Page[]>;
+    OutgoingLinks(): string[];
     get Description(): string;
     get Date(): Date;
     get LocalDate(): String;
@@ -52,6 +57,7 @@ export declare class Page implements ContentPage, PageMeta {
     get GitInfo(): {};
     get File(): {
         BaseFileName: string;
+        OriginalBaseName: string;
         Dir: string;
     };
     isHome(): boolean;

package/dist/internal/domain/site/entity/pagegraph.d.ts

@@ -0,0 +1,17 @@
+import { LinkStrategy } from '../vo/path';
+export declare class PageGraph {
+    private allSlugs;
+    private outgoingLinks;
+    constructor(slugs: string[]);
+    registerOutgoingLinks(srcSlug: string, links: string[]): void;
+    getBacklinks(targetSlug: string): string[];
+    getAllSlugs(): string[];
+    hasSlug(slug: string): boolean;
+    resolveLink(srcSlug: string, targetLink: string, strategy: LinkStrategy): string;
+    getOutgoingLinks(srcSlug: string): string[];
+    getAllOutgoingLinks(): Map<string, string[]>;
+    getStats(): {
+        totalPages: number;
+        slugs: string[];
+    };
+}

package/dist/internal/domain/site/entity/site.d.ts

@@ -10,6 +10,7 @@ import { Author } from '../valueobject/author';
 import { Organization } from '../valueobject/organization';
 import { TaxonomyList } from "@internal/domain/site/entity/taxonomies-builder";
 import { Menus } from "@internal/domain/site/valueobject/menu";
+import { PageGraph } from './pagegraph';
 export declare class Site {
     private configSvc;
     private contentSvc;
@@ -28,6 +29,7 @@ export declare class Site {
     navigation: Navigation | null;
     private title;
     private home;
+    private pageGraph;
     get Title(): string;
     get Description(): string;
     get Compiler(): Compiler;
@@ -93,4 +95,10 @@ export declare class Site {
     GetPage(...ref: string[]): Page | null;
     copyStaticFiles(): Promise<void>;
     siteWeightedPage(ordinalWeightPage: any): Promise<any>;
+    private buildPageGraph;
+    private collectResourceSlugs;
+    ProcessWikilinks(srcSlug: string, html: string): Promise<string>;
+    getPageGraph(): PageGraph | null;
+    GetBacklinks(targetSlug: string): string[];
+    GetContentIndex(): Promise<Map<string, any>>;
 }

package/dist/internal/domain/site/service/html-link-processor.d.ts

@@ -0,0 +1,20 @@
+import { PageGraph } from '../entity/pagegraph';
+import { LinkStrategy } from '../vo/path';
+export interface LinkProcessorOptions {
+    markdownLinkResolution: LinkStrategy;
+    prettyLinks: boolean;
+    openLinksInNewTab: boolean;
+    lazyLoad: boolean;
+    externalLinkIcon: boolean;
+    baseURL?: string;
+}
+export declare class HtmlLinkProcessor {
+    private graph;
+    private options;
+    constructor(graph: PageGraph, options?: Partial<LinkProcessorOptions>);
+    processLinks(srcSlug: string, html: string): Promise<{
+        html: string;
+        outgoingLinks: string[];
+    }>;
+}
+export declare function createHtmlLinkProcessor(graph: PageGraph, options?: Partial<LinkProcessorOptions>): HtmlLinkProcessor;