markstream-angular 0.0.2-beta.0 → 0.0.2-beta.10

package/dist/types/markstream-angular/src/optional/infographic.d.ts

@@ -0,0 +1,13 @@
+export interface InfographicInstance {
+    render: (source: string) => unknown;
+    destroy?: () => unknown;
+    on?: (event: string, handler: (payload: unknown) => void) => unknown;
+}
+export interface InfographicConstructor {
+    new (options: {
+        container: HTMLElement;
+        width?: string | number;
+        height?: string | number;
+    }): InfographicInstance;
+}
+export declare function getInfographic(): Promise<InfographicConstructor | null>;

package/dist/types/markstream-angular/src/optional/katex.d.ts

@@ -0,0 +1,9 @@
+export interface KatexModule {
+    renderToString: (content: string, options?: Record<string, unknown>) => string;
+}
+export type KatexLoader = () => Promise<unknown> | unknown;
+export declare function setKatexLoader(loader: KatexLoader | null): void;
+export declare function enableKatex(loader?: KatexLoader): void;
+export declare function disableKatex(): void;
+export declare function isKatexEnabled(): boolean;
+export declare function getKatex(): Promise<KatexModule | null>;

package/dist/types/markstream-angular/src/optional/mermaid.d.ts

@@ -0,0 +1,27 @@
+export type MermaidLoader = () => Promise<unknown> | unknown;
+export interface MermaidModule {
+    render: (id: string, source: string) => Promise<MermaidRenderResult> | MermaidRenderResult;
+    parse?: (source: string) => Promise<unknown> | unknown;
+    initialize?: (config?: Record<string, unknown>) => unknown;
+    mermaidAPI?: {
+        render?: MermaidModule['render'];
+        parse?: MermaidModule['parse'];
+        initialize?: MermaidModule['initialize'];
+    };
+}
+export type MermaidRenderResult = string | {
+    svg?: string;
+    bindFunctions?: (element: Element) => unknown;
+};
+interface MermaidInitConfig extends Record<string, unknown> {
+    securityLevel?: unknown;
+    flowchart?: {
+        htmlLabels?: unknown;
+    };
+}
+export declare function setMermaidLoader(loader: MermaidLoader | null): void;
+export declare function enableMermaid(loader?: MermaidLoader): void;
+export declare function disableMermaid(): void;
+export declare function isMermaidEnabled(): boolean;
+export declare function getMermaid(initConfig?: MermaidInitConfig): Promise<MermaidModule | null>;
+export {};

package/dist/types/markstream-angular/src/optional/monaco.d.ts

@@ -0,0 +1,18 @@
+export interface MonacoRuntimeHelpers {
+    createEditor?: (container: HTMLElement, code: string, language: string) => Promise<unknown> | unknown;
+    createDiffEditor?: (container: HTMLElement, original: string, modified: string, language: string) => Promise<unknown> | unknown;
+    updateCode?: (code: string, language?: string) => Promise<unknown> | unknown;
+    updateDiff?: (original: string, modified: string, language?: string) => Promise<unknown> | unknown;
+    cleanupEditor?: () => unknown;
+    safeClean?: () => unknown;
+    setTheme?: (theme?: string | Record<string, unknown>) => Promise<unknown> | unknown;
+    getEditorView?: () => unknown;
+    getDiffEditorView?: () => unknown;
+    refreshDiffPresentation?: () => unknown;
+}
+export interface MonacoRuntimeModule {
+    useMonaco: (options?: Record<string, unknown>) => MonacoRuntimeHelpers;
+    preloadMonacoWorkers?: () => Promise<unknown> | unknown;
+    getOrCreateHighlighter?: (...args: unknown[]) => Promise<unknown> | unknown;
+}
+export declare function getUseMonaco(): Promise<MonacoRuntimeModule | null>;

package/dist/types/{parseNestedMarkdownToNodes.d.ts → markstream-angular/src/parseNestedMarkdownToNodes.d.ts}

@@ -1,6 +1,10 @@
-import { BaseNode, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+import { BaseNode, MarkdownIt, ParseOptions } from '../../markdown-parser/src/index.ts';
+type NestedMarkdownSourceNode = BaseNode & {
+    children?: BaseNode[];
+    content?: string;
+};
 export interface NestedMarkdownNodesInput {
-    node?: (BaseNode & Record<string, any>) | null;
+    node?: NestedMarkdownSourceNode | null;
     nodes?: readonly BaseNode[] | null;
     content?: string | null;
 }
@@ -12,3 +16,4 @@ export interface NestedMarkdownNodesOptions {
     customMarkdownIt?: (markdown: MarkdownIt) => MarkdownIt;
 }
 export declare function parseNestedMarkdownToNodes(input: NestedMarkdownNodesInput, options?: NestedMarkdownNodesOptions): BaseNode[];
+export {};

package/dist/types/{renderMarkdownHtml.d.ts → markstream-angular/src/renderMarkdownHtml.d.ts}

@@ -1,4 +1,4 @@
-import { BaseNode, ParsedNode, ParseOptions } from 'stream-markdown-parser';
+import { BaseNode, HtmlPolicy, ParsedNode, ParseOptions } from '../../markdown-parser/src/index.ts';
 export type RenderableMarkdownNode = (ParsedNode | BaseNode) & Record<string, unknown>;
 type NestedClassValue = string | readonly string[] | null | undefined;
 export interface MarkstreamAngularRenderOptions {
@@ -8,11 +8,13 @@ export interface MarkstreamAngularRenderOptions {
     parseOptions?: ParseOptions;
     customHtmlTags?: readonly string[];
     allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
 }
 export interface NestedMarkdownHtmlOptions {
     cacheKey?: string;
     customHtmlTags?: readonly string[];
     allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
     customNodeTag?: string;
     customNodeClass?: NestedClassValue | ((node: RenderableMarkdownNode) => NestedClassValue);
 }

package/dist/types/markstream-angular/src/sanitizeHtmlContent.d.ts

@@ -0,0 +1,2 @@
+import { HtmlPolicy } from '../../markdown-parser/src/index.ts';
+export declare function sanitizeHtmlContent(content: string, policy?: HtmlPolicy): string;

package/dist/types/{types → markstream-angular/src/types}/monaco.d.ts

@@ -7,7 +7,7 @@ export interface CodeBlockMonacoThemeObject {
     [key: string]: unknown;
 }
 export type CodeBlockMonacoTheme = string | CodeBlockMonacoThemeObject;
-export type CodeBlockMonacoLanguage = string | ((...args: any[]) => unknown);
+export type CodeBlockMonacoLanguage = string | ((...args: unknown[]) => unknown);
 export interface CodeBlockDiffHideUnchangedRegionsOptions {
     enabled?: boolean;
     contextLineCount?: number;
@@ -60,6 +60,6 @@ export interface CodeBlockMonacoOptions {
     diffHunkActionsOnHover?: boolean;
     diffHunkHoverHideDelayMs?: number;
     onDiffHunkAction?: (context: CodeBlockDiffHunkActionContext) => void | boolean | Promise<void | boolean>;
-    scrollbar?: Record<string, any>;
-    [key: string]: any;
+    scrollbar?: Record<string, unknown>;
+    [key: string]: unknown;
 }

package/dist/types/markstream-angular/src/utils/normalizeKaTeXRenderInput.d.ts

@@ -0,0 +1 @@
+export declare function normalizeKaTeXRenderInput(content: string): string;

package/dist/workers/mermaidParser.worker.js

@@ -1,6 +1,6 @@
 import f from "mermaid";
-f.initialize({ startOnLoad: !1, securityLevel: "loose" });
-function h(r, t) {
+f.initialize({ startOnLoad: !1, securityLevel: "strict", flowchart: { htmlLabels: !1 } });
+function u(r, t) {
   const e = `%%{init: {"theme": "${t === "dark" ? "dark" : "default"}"}}%%
 `;
   return r.trimStart().startsWith("%%{") ? r : e + r;
@@ -15,7 +15,7 @@ function g(r) {
   return -1;
 }
 async function l(r, t) {
-  const a = h(r, t), e = f;
+  const a = u(r, t), e = f;
   if (typeof e.parse == "function")
     return await e.parse(a), !0;
   throw new Error("mermaid.parse not available in worker");
@@ -28,16 +28,16 @@ async function p(r, t) {
   const n = a.slice(0, e + 1);
   await l(n.join(`
 `), t);
-  let o = e + 1, s = a.length, c = e + 1, d = 0;
+  let s = e + 1, o = a.length, c = e + 1, d = 0;
   const m = 12;
-  for (; o <= s && d < m; ) {
-    const i = Math.floor((o + s) / 2), u = [...n, ...a.slice(e + 1, i)].join(`
+  for (; s <= o && d < m; ) {
+    const i = Math.floor((s + o) / 2), h = [...n, ...a.slice(e + 1, i)].join(`
 `);
     d += 1;
     try {
-      await l(u, t), c = i, o = i + 1;
+      await l(h, t), c = i, s = i + 1;
     } catch {
-      s = i - 1;
+      o = i - 1;
     }
   }
   return [...n, ...a.slice(e + 1, c)].join(`

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "markstream-angular",
   "type": "module",
-  "version": "0.0.2-beta.0",
+  "version": "0.0.2-beta.10",
   "description": "Experimental Angular Markdown renderer for Markstream, built on stream-markdown AST and a stable HTML baseline renderer.",
   "author": "Simon He",
   "license": "MIT",
@@ -47,7 +47,7 @@
     "@terrastruct/d2": ">=0.1.33",
     "katex": ">=0.16.22",
     "mermaid": ">=11",
-    "stream-monaco": ">=0.0.22"
+    "stream-monaco": ">=0.0.40"
   },
   "peerDependenciesMeta": {
     "@antv/infographic": {
@@ -68,7 +68,7 @@
   },
   "dependencies": {
     "@floating-ui/dom": "^1.7.6",
-    "stream-markdown-parser": "0.0.82"
+    "stream-markdown-parser": "0.0.93"
   },
   "devDependencies": {
     "@types/node": "^18.19.130",

package/dist/types/components/TableNode/TableNode.component.d.ts

@@ -1,14 +0,0 @@
-import { AngularRenderableNode, AngularRenderContext } from '../shared/node-helpers';
-export declare class TableNodeComponent {
-    node: AngularRenderableNode;
-    context?: AngularRenderContext;
-    indexKey?: string;
-    get headerRow(): AngularRenderableNode;
-    get rows(): AngularRenderableNode[];
-    cellsFor(row: AngularRenderableNode): AngularRenderableNode[];
-    childrenFor(cell: AngularRenderableNode): AngularRenderableNode[];
-    alignment(cell: AngularRenderableNode): string;
-    trackRow: (index: number) => string;
-    trackCell: (index: number) => number;
-    cellPrefix(rowIndex: string | number, cellIndex: number): string;
-}

package/dist/types/optional/d2.d.ts

@@ -1,6 +0,0 @@
-export type D2Loader = () => Promise<any> | any;
-export declare function setD2Loader(loader: D2Loader | null): void;
-export declare function enableD2(loader?: D2Loader): void;
-export declare function disableD2(): void;
-export declare function isD2Enabled(): boolean;
-export declare function getD2(): Promise<any>;

package/dist/types/optional/infographic.d.ts

@@ -1 +0,0 @@
-export declare function getInfographic(): Promise<any>;

package/dist/types/optional/katex.d.ts

@@ -1,6 +0,0 @@
-export type KatexLoader = () => Promise<any> | any;
-export declare function setKatexLoader(loader: KatexLoader | null): void;
-export declare function enableKatex(loader?: KatexLoader): void;
-export declare function disableKatex(): void;
-export declare function isKatexEnabled(): boolean;
-export declare function getKatex(): Promise<any>;

package/dist/types/optional/mermaid.d.ts

@@ -1,6 +0,0 @@
-export type MermaidLoader = () => Promise<any> | any;
-export declare function setMermaidLoader(loader: MermaidLoader | null): void;
-export declare function enableMermaid(loader?: MermaidLoader): void;
-export declare function disableMermaid(): void;
-export declare function isMermaidEnabled(): boolean;
-export declare function getMermaid(initConfig?: Record<string, any>): Promise<any>;

package/dist/types/optional/monaco.d.ts

@@ -1 +0,0 @@
-export declare function getUseMonaco(): Promise<any>;

package/dist/types/sanitizeHtmlContent.d.ts

@@ -1 +0,0 @@
-export declare function sanitizeHtmlContent(content: string): string;