crossnote 0.8.0

package/out/types/src/converters/process-graphs.d.ts

@@ -0,0 +1,22 @@
+import { CodeChunkData } from '../code-chunk/code-chunk-data';
+export declare function processGraphs(text: string, { fileDirectoryPath, projectDirectoryPath, imageDirectoryPath, imageFilePrefix, useRelativeFilePath, codeChunksData, graphsCache, imageMagickPath, mermaidTheme, addOptionsStr, plantumlJarPath, plantumlServer, }: {
+    fileDirectoryPath: string;
+    projectDirectoryPath: string;
+    imageDirectoryPath: string;
+    imageFilePrefix: string;
+    useRelativeFilePath: boolean;
+    codeChunksData: {
+        [key: string]: CodeChunkData;
+    };
+    graphsCache: {
+        [key: string]: string;
+    };
+    imageMagickPath: string;
+    mermaidTheme: string;
+    addOptionsStr: boolean;
+    plantumlJarPath: string;
+    plantumlServer: string;
+}): Promise<{
+    outputString: string;
+    imagePaths: string[];
+}>;

package/out/types/src/custom-markdown-it-features/admonition.d.ts

@@ -0,0 +1,3 @@
+import MarkdownIt from 'markdown-it';
+declare const _default: (md: MarkdownIt) => void;
+export default _default;

package/out/types/src/custom-markdown-it-features/code-fences.d.ts

@@ -0,0 +1,3 @@
+import MarkdownIt from 'markdown-it';
+declare const _default: (md: MarkdownIt) => void;
+export default _default;

package/out/types/src/custom-markdown-it-features/critic-markup.d.ts

@@ -0,0 +1,4 @@
+import MarkdownIt from 'markdown-it';
+import { NotebookConfig } from '../notebook';
+declare const _default: (md: MarkdownIt, config: NotebookConfig) => void;
+export default _default;

package/out/types/src/custom-markdown-it-features/emoji.d.ts

@@ -0,0 +1,4 @@
+import MarkdownIt from 'markdown-it';
+import { NotebookConfig } from '../notebook';
+declare const _default: (md: MarkdownIt, config: NotebookConfig) => void;
+export default _default;

package/out/types/src/custom-markdown-it-features/html5-embed.d.ts

@@ -0,0 +1,4 @@
+import MarkdownIt from 'markdown-it';
+import { NotebookConfig } from '../notebook';
+declare const _default: (md: MarkdownIt, config: NotebookConfig) => void;
+export default _default;

package/out/types/src/custom-markdown-it-features/math.d.ts

@@ -0,0 +1,4 @@
+import MarkdownIt from 'markdown-it';
+import { NotebookConfig } from '../notebook';
+declare const _default: (md: MarkdownIt, config: NotebookConfig) => void;
+export default _default;

package/out/types/src/custom-markdown-it-features/wikilink.d.ts

@@ -0,0 +1,4 @@
+import MarkdownIt from 'markdown-it';
+import { NotebookConfig } from '../notebook';
+declare const _default: (md: MarkdownIt, config: NotebookConfig) => void;
+export default _default;

package/out/types/src/index.d.ts

@@ -0,0 +1,13 @@
+import { addFileProtocol, getCrossnoteBuildDirectory, openFile, setCrossnoteBuildDirectory, uploadImage, useExternalAddFileProtocolFunction } from './utility';
+export declare const utility: {
+    addFileProtocol: typeof addFileProtocol;
+    getCrossnoteBuildDirectory: typeof getCrossnoteBuildDirectory;
+    openFile: typeof openFile;
+    setCrossnoteBuildDirectory: typeof setCrossnoteBuildDirectory;
+    useExternalAddFileProtocolFunction: typeof useExternalAddFileProtocolFunction;
+    uploadImage: typeof uploadImage;
+};
+export * from './code-chunk/code-chunk-data';
+export * from './markdown-engine';
+export * from './notebook';
+export { loadConfigsInDirectory, wrapNodeFSAsApi, } from './notebook/config-helper';

package/out/types/src/lib/block-attributes/index.d.ts

@@ -0,0 +1,4 @@
+export * from './normalizeBlockAttributes';
+export * from './parseBlockAttributes';
+export * from './stringifyBlockAttributes';
+export * from './types';

package/out/types/src/lib/block-attributes/normalizeBlockAttributes.d.ts

@@ -0,0 +1,2 @@
+import { BlockAttributes } from './types';
+export declare const normalizeBlockAttributes: (attributes: BlockAttributes) => BlockAttributes;

package/out/types/src/lib/block-attributes/parseBlockAttributes.d.ts

@@ -0,0 +1,2 @@
+import { BlockAttributes } from './types';
+export declare const parseBlockAttributes: (text?: string | null) => BlockAttributes;

package/out/types/src/lib/block-attributes/stringifyBlockAttributes.d.ts

@@ -0,0 +1,2 @@
+import { BlockAttributes } from './types';
+export declare const stringifyBlockAttributes: (attributes?: BlockAttributes, addCurlyBrackets?: boolean) => string;

package/out/types/src/lib/block-attributes/types.d.ts

@@ -0,0 +1,3 @@
+export interface BlockAttributes {
+    [key: string]: any;
+}

package/out/types/src/lib/block-info/index.d.ts

@@ -0,0 +1,3 @@
+export * from './normalizeBlockInfo';
+export * from './parseBlockInfo';
+export * from './types';

package/out/types/src/lib/block-info/normalizeBlockInfo.d.ts

@@ -0,0 +1,2 @@
+import { BlockInfo } from './types';
+export declare const normalizeBlockInfo: (blockInfo: BlockInfo) => BlockInfo;

package/out/types/src/lib/block-info/parseBlockInfo.d.ts

@@ -0,0 +1,2 @@
+import { BlockInfo } from './types';
+export declare const parseBlockInfo: (raw?: string) => BlockInfo;

package/out/types/src/lib/block-info/types.d.ts

@@ -0,0 +1,6 @@
+import { BlockAttributes } from '../block-attributes/types';
+export interface BlockInfo {
+    attributes: BlockAttributes;
+    derivedAttributes?: BlockAttributes;
+    language: string;
+}

package/out/types/src/lib/compute-checksum.d.ts

@@ -0,0 +1,3 @@
+export type HashFunction = (text: string) => string;
+declare const computeChecksum: HashFunction;
+export default computeChecksum;

package/out/types/src/markdown-engine/custom-subjects.d.ts

@@ -0,0 +1,11 @@
+export declare enum CustomSubjects {
+    pagebreak = 0,
+    newpage = 1,
+    toc = 2,
+    tocstop = 3,
+    slide = 4,
+    '.slide' = 5,
+    '.slide:' = 6,
+    ebook = 7,
+    'toc-bracket' = 8
+}

package/out/types/src/markdown-engine/extension-helper.d.ts

@@ -0,0 +1 @@
+export declare function scopeForLanguageName(language: any): any;

package/out/types/src/markdown-engine/heading-id-generator.d.ts

@@ -0,0 +1,5 @@
+export default class HeadingIdGenerator {
+    private table;
+    constructor();
+    generateId(heading: string): string;
+}

package/out/types/src/markdown-engine/index.d.ts

@@ -0,0 +1,108 @@
+import { JsonObject } from 'type-fest';
+import * as vscode from 'vscode';
+import { Notebook } from '../notebook';
+interface MarkdownEngineConstructorArgs {
+    notebook: Notebook;
+    filePath: string;
+}
+export interface MarkdownEngineRenderOption {
+    useRelativeFilePath: boolean;
+    isForPreview: boolean;
+    hideFrontMatter: boolean;
+    triggeredBySave?: boolean;
+    runAllCodeChunks?: boolean;
+    emojiToSvg?: boolean;
+    vscodePreviewPanel?: vscode.WebviewPanel | null;
+    fileDirectoryPath?: string;
+}
+export interface MarkdownEngineOutput {
+    html: string;
+    markdown: string;
+    tocHTML: string;
+    yamlConfig: JsonObject;
+    JSAndCssFiles: string[];
+}
+export interface HTMLTemplateOption {
+    isForPrint: boolean;
+    isForPrince: boolean;
+    offline: boolean;
+    embedLocalImages: boolean;
+    embedSVG?: boolean;
+}
+export declare class MarkdownEngine {
+    private readonly filePath;
+    private readonly fileDirectoryPath;
+    private readonly projectDirectoryPath;
+    private readonly notebook;
+    private readonly fs;
+    private headings;
+    private tocHTML;
+    private vscodePreviewPanel;
+    private graphsCache;
+    private codeChunksData;
+    private filesCache;
+    isPreviewInPresentationMode: boolean;
+    constructor({ filePath, notebook }: MarkdownEngineConstructorArgs);
+    private get protocolsWhiteListRegExp();
+    cacheCodeChunkResult(id: string, result: string): void;
+    private generateScriptsForPreview;
+    private static AutoPrismThemeMap;
+    private static AutoPrismThemeMapForPresentation;
+    private getPrismTheme;
+    private generateStylesForPreview;
+    private generateJSAndCssFilesForPreview;
+    generateHTMLTemplateForPreview({ inputString, body, webviewScript, scripts, styles, head, config, vscodePreviewPanel, contentSecurityPolicy, isVSCodeWebExtension, }: {
+        inputString?: string;
+        body?: string;
+        webviewScript?: string;
+        scripts?: string;
+        styles?: string;
+        head?: string;
+        config: JsonObject;
+        vscodePreviewPanel: vscode.WebviewPanel | null | undefined;
+        contentSecurityPolicy?: string;
+        isVSCodeWebExtension?: boolean;
+    }): Promise<string>;
+    generateHTMLTemplateForExport(html: string, yamlConfig: {} | undefined, options: HTMLTemplateOption): Promise<string>;
+    openInBrowser({ runAllCodeChunks }: {
+        runAllCodeChunks?: boolean | undefined;
+    }): Promise<void>;
+    htmlExport({ offline, runAllCodeChunks, }: {
+        offline?: boolean | undefined;
+        runAllCodeChunks?: boolean | undefined;
+    }): Promise<string>;
+    chromeExport({ fileType, runAllCodeChunks, openFileAfterGeneration, }: {
+        fileType?: string | undefined;
+        runAllCodeChunks?: boolean | undefined;
+        openFileAfterGeneration?: boolean | undefined;
+    }): Promise<string>;
+    princeExport({ runAllCodeChunks, openFileAfterGeneration, }: {
+        runAllCodeChunks?: boolean | undefined;
+        openFileAfterGeneration?: boolean | undefined;
+    }): Promise<string>;
+    private eBookDownloadImages;
+    eBookExport({ fileType, runAllCodeChunks, }: {
+        fileType: string;
+        runAllCodeChunks?: boolean;
+    }): Promise<string>;
+    pandocExport({ runAllCodeChunks, openFileAfterGeneration, }: {
+        runAllCodeChunks?: boolean | undefined;
+        openFileAfterGeneration?: boolean | undefined;
+    }): Promise<string>;
+    markdownExport({ runAllCodeChunks }: {
+        runAllCodeChunks?: boolean | undefined;
+    }): Promise<string>;
+    private exportOnSave;
+    private resolveFilePath;
+    clearCaches(): void;
+    private frontMatterToTable;
+    private processFrontMatter;
+    private parseSlides;
+    pandocRender(text: string | undefined, args: string[]): Promise<string>;
+    parseMD(inputString: string, options: MarkdownEngineRenderOption): Promise<MarkdownEngineOutput>;
+    runCodeChunks(): Promise<string[]>;
+    runCodeChunk(id: string): Promise<string>;
+    private modifySource;
+    private generateRunOptions;
+}
+export {};

package/out/types/src/markdown-engine/toc.d.ts

@@ -0,0 +1,18 @@
+export interface TocOption {
+    ordered: boolean;
+    depthFrom: number;
+    depthTo: number;
+    tab: string;
+    ignoreLink?: boolean;
+}
+export interface HeadingData {
+    content: string;
+    level: number;
+    offset?: number;
+    id?: string;
+}
+export declare function toc(headings: HeadingData[], opt: TocOption): {
+    content: string;
+    array: string[];
+};
+export declare function generateSidebarToCHTML(headings: HeadingData[], mdRender: (md: string) => string, opt: TocOption): string;

package/out/types/src/markdown-engine/transformer.d.ts

@@ -0,0 +1,28 @@
+import HeadingIdGenerator from './heading-id-generator';
+import { HeadingData } from './toc';
+export interface TransformMarkdownOutput {
+    outputString: string;
+    slideConfigs: object[];
+    tocBracketEnabled: boolean;
+    JSAndCssFiles: string[];
+    headings: HeadingData[];
+    frontMatterString: string;
+}
+export interface TransformMarkdownOptions {
+    fileDirectoryPath: string;
+    projectDirectoryPath: string;
+    filesCache: {
+        [key: string]: string;
+    };
+    useRelativeFilePath: boolean;
+    forPreview: boolean;
+    forMarkdownExport?: boolean;
+    protocolsWhiteListRegExp: RegExp | null;
+    notSourceFile?: boolean;
+    imageDirectoryPath?: string;
+    usePandocParser: boolean;
+    headingIdGenerator?: HeadingIdGenerator;
+    onWillTransformMarkdown?: ((markdown: string) => Promise<string>) | null;
+    onDidTransformMarkdown?: ((markdown: string) => Promise<string>) | null;
+}
+export declare function transformMarkdown(inputString: string, { fileDirectoryPath, projectDirectoryPath, filesCache, useRelativeFilePath, forPreview, forMarkdownExport, protocolsWhiteListRegExp, notSourceFile, imageDirectoryPath, usePandocParser, headingIdGenerator, onWillTransformMarkdown, onDidTransformMarkdown, }: TransformMarkdownOptions): Promise<TransformMarkdownOutput>;

package/out/types/src/notebook/config-helper.d.ts

@@ -0,0 +1,16 @@
+import { KatexOptions } from 'katex';
+import { MermaidConfig } from 'mermaid';
+import { JsonObject } from 'type-fest';
+import { FileSystemApi, ParserConfig } from './types';
+export declare function loadConfigsInDirectory(directoryPath: string, fileSystem: FileSystemApi, createDirectoryIfNotExists?: boolean): Promise<{
+    globalCss: string;
+    mermaidConfig: MermaidConfig;
+    mathjaxConfig: JsonObject;
+    katexConfig: KatexOptions;
+    parserConfig: ParserConfig;
+}>;
+export declare function getMermaidConfig(configPath: string, fs: FileSystemApi): Promise<MermaidConfig>;
+export declare function getMathjaxConfig(configPath: string, fs: FileSystemApi): Promise<JsonObject>;
+export declare function getKatexConfig(configPath: string, fs: FileSystemApi): Promise<KatexOptions>;
+export declare function getParserConfig(configPath: string, fs: FileSystemApi): Promise<ParserConfig>;
+export declare function wrapNodeFSAsApi(): FileSystemApi;

package/out/types/src/notebook/graph-view.d.ts

@@ -0,0 +1,15 @@
+import { Notebook } from '.';
+export interface GraphViewNode {
+    id: string;
+    label: string;
+}
+export interface GraphViewLink {
+    source: string;
+    target: string;
+}
+export interface GraphViewData {
+    hash: string;
+    nodes: GraphViewNode[];
+    links: GraphViewLink[];
+}
+export declare function constructGraphView(notebook: Notebook): GraphViewData;

package/out/types/src/notebook/index.d.ts

@@ -0,0 +1,53 @@
+import MarkdownIt from 'markdown-it';
+import { MarkdownEngine } from '../markdown-engine';
+import { Note, NoteConfig, Notes } from './note';
+import { Reference, ReferenceMap } from './reference';
+import { FileSystemApi, NotebookConfig } from './types';
+export * from './types';
+interface NotebookConstructorArgs {
+    notebookPath: string;
+    config: Partial<NotebookConfig>;
+    fs?: FileSystemApi;
+}
+interface RefreshNotesArgs {
+    dir: string;
+    includeSubdirectories?: boolean;
+    refreshRelations?: boolean;
+}
+export declare class Notebook {
+    notebookPath: string;
+    config: NotebookConfig;
+    fs: FileSystemApi;
+    notes: Notes;
+    hasLoadedNotes: boolean;
+    referenceMap: ReferenceMap;
+    private refreshNotesIfNotLoadedMutex;
+    private search;
+    md: MarkdownIt;
+    private markdownEngines;
+    private constructor();
+    private init;
+    static init(args: NotebookConstructorArgs): Promise<Notebook>;
+    private initConfig;
+    private initMarkdownIt;
+    initFs(_fs?: FileSystemApi): void;
+    updateConfig(config: Partial<NotebookConfig>): void;
+    private interpolateConfig;
+    getBacklinkedNotes(filePath: string): Promise<Notes>;
+    getReferences(noteFilePath: string, backlinkedNoteFilePath: string): Promise<Reference[]>;
+    processNoteMentionsAndMentionedBy(filePath: string): Promise<void>;
+    getNote(filePath: string, refreshNoteRelations?: boolean): Promise<Note | null>;
+    refreshNotesIfNotLoaded({ dir, includeSubdirectories, }: RefreshNotesArgs): Promise<Notes>;
+    refreshNotes({ dir, includeSubdirectories, refreshRelations, }: RefreshNotesArgs): Promise<Notes>;
+    writeNote(filePath: string, markdown: string, noteConfig: NoteConfig): Promise<Note | null>;
+    removeNoteRelations(filePath: string): Promise<void>;
+    deleteNote(filePath: string): Promise<void>;
+    duplicateNote(filePath: string): Promise<Note | null | undefined>;
+    private resolveNoteAbsolutePath;
+    private resolveNoteRelativePath;
+    getNoteMarkdownEngine(filePath: string): MarkdownEngine;
+    getNoteMarkdownEngines(): {
+        [key: string]: MarkdownEngine;
+    };
+    clearAllNoteMarkdownEngineCaches(): void;
+}

package/out/types/src/notebook/markdown.d.ts

@@ -0,0 +1,11 @@
+import { JsonObject } from 'type-fest';
+export declare const TagStopRegExp: RegExp;
+export declare function getTags(markdown: string): string[];
+export declare function sanitizeTag(tagName: string): string;
+export declare function sanitizeNoteTitle(noteTitle: string): string;
+export interface MatterOutput {
+    data: JsonObject;
+    content: string;
+}
+export declare function matter(markdown: string): MatterOutput;
+export declare function matterStringify(markdown: string, frontMatter: JsonObject): string;

package/out/types/src/notebook/note.d.ts

@@ -0,0 +1,25 @@
+export type FilePath = string;
+export interface NoteConfigEncryption {
+    title: string;
+}
+export interface NoteConfig {
+    createdAt: Date;
+    modifiedAt: Date;
+    pinned?: boolean;
+    favorited?: boolean;
+    icon?: string;
+    aliases?: string[];
+}
+export type Mentions = Set<FilePath>;
+export interface Note {
+    notebookPath: string;
+    filePath: FilePath;
+    title: string;
+    markdown: string;
+    config: NoteConfig;
+    mentions: Mentions;
+}
+export interface Notes {
+    [key: string]: Note;
+}
+export declare function getNoteIcon(note: Note): string;

package/out/types/src/notebook/reference.d.ts

@@ -0,0 +1,22 @@
+import Token from 'markdown-it/lib/token';
+export interface Reference {
+    elementId: string;
+    parentToken: Token | null;
+    token: Token;
+    text: string;
+    link: string;
+}
+export declare class ReferenceMap {
+    map: {
+        [key: string]: {
+            [key: string]: Reference[];
+        };
+    };
+    constructor();
+    addReference(noteFilePath: string, referredByNoteFilePath: string, reference?: Reference): void;
+    deleteReferences(noteFilePath: string, referredByNoteFilePath: string): void;
+    hasRelation(filePath1: string, filePath2: string): boolean;
+    getReferences(noteFilePath: string, referredByNoteFilePath: string): Reference[];
+    noteHasReferences(filePath: string): boolean;
+    getReferredByNotesCount(noteFilePath: string): number;
+}

package/out/types/src/notebook/search.d.ts

@@ -0,0 +1,18 @@
+import { SearchOptions, SearchResult } from 'minisearch';
+export declare function slugify(str: string, separater?: string): string;
+export interface SearchDoc {
+    id: string;
+    title: string;
+    filePath: string;
+    aliases: string[];
+}
+export default class Search {
+    private miniSearch;
+    private _cache;
+    constructor();
+    add(filePath: string, title: string, aliases?: string[]): void;
+    remove(filePath: string): void;
+    search(queryString: string, options?: SearchOptions): SearchResult[];
+    addAlias(filePath: string, alias: string): void;
+    deleteAlias(filePath: string, alias: string): void;
+}

package/out/types/src/notebook/slash.d.ts

@@ -0,0 +1 @@
+export default function slash(path: any): any;

package/out/types/src/notebook/types.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="cheerio" />
+import { KatexOptions } from 'katex';
+import { MermaidConfig } from 'mermaid';
+import { JsonObject } from 'type-fest';
+export declare const IS_NODE: boolean;
+export type FileSystemStats = {
+    mtimeMs: number;
+    ctimeMs: number;
+    size: number;
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isSymbolicLink: () => boolean;
+};
+export type FileSystemApi = {
+    readFile: (path: string, encoding?: string) => Promise<string>;
+    writeFile: (path: string, content: string, encoding?: string) => Promise<void>;
+    mkdir: (path: string) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+    stat: (path: string) => Promise<FileSystemStats>;
+    readdir: (path: string) => Promise<string[]>;
+    unlink: (path: string) => Promise<void>;
+};
+export type MathRenderingOption = 'None' | 'KaTeX' | 'MathJax';
+export interface ParserConfig {
+    onWillParseMarkdown?: (markdown: string) => Promise<string>;
+    onDidParseMarkdown?: (html: string, opts: {
+        cheerio: CheerioAPI;
+    }) => Promise<string>;
+    onWillTransformMarkdown?: (markdown: string) => Promise<string>;
+    onDidTransformMarkdown?: (markdown: string) => Promise<string>;
+}
+export type PreviewTheme = 'atom-dark.css' | 'atom-light.css' | 'atom-material.css' | 'github-dark.css' | 'github-light.css' | 'gothic.css' | 'medium.css' | 'monokai.css' | 'newsprint.css' | 'night.css' | 'none.css' | 'one-dark.css' | 'one-light.css' | 'solarized-dark.css' | 'solarized-light.css' | 'vue.css';
+export type CodeBlockTheme = 'auto.css' | 'default.css' | 'atom-dark.css' | 'atom-light.css' | 'atom-material.css' | 'coy.css' | 'darcula.css' | 'dark.css' | 'funky.css' | 'github.css' | 'hopscotch.css' | 'monokai.css' | 'okaidia.css' | 'one-dark.css' | 'one-light.css' | 'pen-paper-coffee.css' | 'pojoaque.css' | 'solarized-dark.css' | 'solarized-light.css' | 'twilight.css' | 'vue.css' | 'vs.css' | 'xonokai.css';
+export type RevealJsTheme = 'beige.css' | 'black.css' | 'blood.css' | 'league.css' | 'moon.css' | 'night.css' | 'serif.css' | 'simple.css' | 'sky.css' | 'solarized.css' | 'white.css' | 'none.css';
+export type MermaidTheme = 'default' | 'forest' | 'dark' | 'neutral' | 'null';
+export type FrontMatterRenderingOption = 'none' | 'table' | 'code';
+export interface NotebookConfig {
+    globalCss: string;
+    mermaidConfig: MermaidConfig;
+    mathjaxConfig: JsonObject;
+    katexConfig: KatexOptions;
+    usePandocParser: boolean;
+    parserConfig: ParserConfig;
+    breakOnSingleNewLine: boolean;
+    enableTypographer: boolean;
+    enableWikiLinkSyntax: boolean;
+    enableLinkify: boolean;
+    useGitHubStylePipedLink: boolean;
+    wikiLinkFileExtension: string;
+    enableEmojiSyntax: boolean;
+    enableExtendedTableSyntax: boolean;
+    enableCriticMarkupSyntax: boolean;
+    protocolsWhiteList: string;
+    mathRenderingOption: MathRenderingOption;
+    mathInlineDelimiters: string[][];
+    mathBlockDelimiters: string[][];
+    mathRenderingOnlineService: string;
+    mathjaxV3ScriptSrc: string;
+    codeBlockTheme: CodeBlockTheme;
+    previewTheme: PreviewTheme;
+    revealjsTheme: RevealJsTheme;
+    mermaidTheme: MermaidTheme;
+    frontMatterRenderingOption: FrontMatterRenderingOption;
+    imageFolderPath: string;
+    printBackground: boolean;
+    chromePath: string;
+    imageMagickPath: string;
+    pandocPath: string;
+    pandocMarkdownFlavor: string;
+    pandocArguments: string[];
+    latexEngine: string;
+    enableScriptExecution: boolean;
+    enableHTML5Embed: boolean;
+    HTML5EmbedUseImageSyntax: boolean;
+    HTML5EmbedUseLinkSyntax: boolean;
+    HTML5EmbedIsAllowedHttp: boolean;
+    HTML5EmbedAudioAttributes: string;
+    HTML5EmbedVideoAttributes: string;
+    puppeteerWaitForTimeout: number;
+    puppeteerArgs: string[];
+    plantumlServer: string;
+    plantumlJarPath: string;
+    jsdelivrCdnHost: string;
+    krokiServer: string;
+    isVSCode: boolean;
+}
+export declare function getDefaultMermaidConfig(): MermaidConfig;
+export declare function getDefaultMathjaxConfig(): JsonObject;
+export declare function getDefaultKatexConfig(): KatexOptions;
+export declare function getDefaultParserConfig(): ParserConfig;
+export declare function getDefaultNotebookConfig(): NotebookConfig;

package/out/types/src/prism/iele.d.ts

@@ -0,0 +1 @@
+export default function (Prism: any): void;

package/out/types/src/prism/k.d.ts

@@ -0,0 +1 @@
+export default function (Prism: any): void;

package/out/types/src/render-enhancers/code-block-styling.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="cheerio" />
+export default function enhance($: CheerioStatic): Promise<void>;

package/out/types/src/render-enhancers/embedded-local-images.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="cheerio" />
+import { NotebookConfig } from '../notebook';
+export default function enhance($: CheerioStatic, options: NotebookConfig, resolveFilePath: (path: string, useRelativeFilePath: boolean) => string): Promise<void>;

package/out/types/src/render-enhancers/embedded-svgs.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="cheerio" />
+import { NotebookConfig } from '../notebook';
+export default function enhance($: CheerioStatic, options: NotebookConfig, resolveFilePath: (path: string, useRelativeFilePath: boolean) => string): Promise<void>;

package/out/types/src/render-enhancers/extended-table-syntax.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="cheerio" />
+export default function enhance($: CheerioStatic): Promise<void>;

package/out/types/src/render-enhancers/fenced-code-chunks.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="cheerio" />
+import { CodeChunkData, CodeChunksData } from '../code-chunk/code-chunk-data';
+import { BlockInfo } from '../lib/block-info';
+import { MarkdownEngineOutput, MarkdownEngineRenderOption } from '../markdown-engine';
+import { HeadingData } from '../markdown-engine/toc';
+export default function enhance($: CheerioStatic, codeChunksData: CodeChunksData, renderOptions: MarkdownEngineRenderOption, runOptions: RunCodeChunkOptions): Promise<void>;
+export declare function renderCodeBlock($container: Cheerio, normalizedInfo: BlockInfo, $: CheerioStatic, codeChunksData: CodeChunksData, arrayOfCodeChunkData: CodeChunkData[], renderOptions: MarkdownEngineRenderOption, runOptions: RunCodeChunkOptions): Promise<void>;
+export interface RunCodeChunkOptions {
+    enableScriptExecution: boolean;
+    fileDirectoryPath: string;
+    filePath: string;
+    imageFolderPath: string;
+    latexEngine?: string;
+    modifySource: (codeChunkData: CodeChunkData, result: string, filePath: string) => Promise<string>;
+    parseMD: (inputString: string, options: MarkdownEngineRenderOption) => Promise<MarkdownEngineOutput>;
+    headings: HeadingData[];
+}
+export declare function runCodeChunk(id: string, codeChunksData: CodeChunksData, runOptions: RunCodeChunkOptions): Promise<string>;
+export declare function runCodeChunks(codeChunksData: CodeChunksData, runOptions: RunCodeChunkOptions): Promise<string[]>;

package/out/types/src/render-enhancers/fenced-diagrams.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="cheerio" />
+export default function enhance({ $, graphsCache, fileDirectoryPath, imageDirectoryPath, plantumlServer, plantumlJarPath, kirokiServer, }: {
+    $: CheerioStatic;
+    graphsCache: {
+        [key: string]: string;
+    };
+    fileDirectoryPath: string;
+    imageDirectoryPath: string;
+    plantumlServer: string;
+    plantumlJarPath: string;
+    kirokiServer: string;
+}): Promise<void>;

package/out/types/src/render-enhancers/fenced-math.d.ts

@@ -0,0 +1,3 @@
+import { KatexOptions } from 'katex';
+import { MathRenderingOption } from '../notebook';
+export default function enhance($: any, renderingOption: MathRenderingOption, mathBlockDelimiters: string[][], katexConfig: KatexOptions): Promise<void>;

package/out/types/src/render-enhancers/resolved-image-paths.d.ts

@@ -0,0 +1,2 @@
+import { MarkdownEngineRenderOption } from '../markdown-engine';
+export default function enhance($: any, options: MarkdownEngineRenderOption, resolveFilePath: (path: string, useRelativeFilePath: boolean, fileDirectoryPath?: string) => string, usePandocParser: any): Promise<void>;