@leadertechie/md2html 0.1.0-alpha.0 → 0.1.0-alpha.3

package/README.md

@@ -55,10 +55,35 @@ const pipeline = new MarkdownPipeline({
     gfm: true,
     breaks: false,
     pedantic: false
+  },
+  styleOptions: {
+    classPrefix: 'md-',
+    customCSS: 'body { font-family: system-ui; }',
+    addHeadingIds: true
   }
 });
 ```
 
+### Style Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `classPrefix` | string | `''` | Prefix for CSS classes on elements (e.g., `'md-'` produces `md-heading`, `md-paragraph`) |
+| `customCSS` | string | `''` | Custom CSS string to inject (use `pipeline.getCustomCSS()` to retrieve) |
+| `addHeadingIds` | boolean | `false` | Add ID attributes to headings based on their content for anchor links |
+
+When `classPrefix` or `addHeadingIds` is set, CSS classes will be added to elements:
+- `heading`, `paragraph`, `list`, `list-item`, `image`, `code`, `container`, `blockquote`
+
+Example output with `classPrefix: 'md-'` and `addHeadingIds: true`:
+```html
+<h1 id="hello-world" class="md-heading">Hello World</h1>
+<p class="md-paragraph">This is a paragraph.</p>
+<ul class="md-list">
+  <li class="md-list-item">Item 1</li>
+</ul>
+```
+
 ### API
 
 | Method | Description |
@@ -66,7 +91,9 @@ const pipeline = new MarkdownPipeline({
 | `parse(markdown)` | Parse markdown string to AST |
 | `render(nodes)` | Render AST to HTML string |
 | `renderMarkdown(markdown)` | Parse and render in one call |
-| `renderPage(title, nodes)` | Render AST to full HTML page |
+| `renderPage(title, nodes, options?)` | Render AST to full HTML page |
+| `getCustomCSS()` | Get custom CSS string from style config |
+| `getConfig()` | Get current pipeline configuration |
 
 ## License
 

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './parser.js';
+export * from './renderer.js';
+export * from './lit-renderer.js';
+export * from './pipeline.js';
+export { LitRenderer as HTMLRenderer } from './lit-renderer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAE9B,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './parser.js';
+export * from './renderer.js';
+export * from './lit-renderer.js';
+export * from './pipeline.js';
+export { LitRenderer as HTMLRenderer } from './lit-renderer.js';

package/dist/lit-renderer.d.ts

@@ -0,0 +1,10 @@
+import { TemplateResult } from 'lit';
+import { ContentNode } from './types';
+export declare class LitRenderer {
+    private renderTextNode;
+    renderNode(node: ContentNode): TemplateResult;
+    renderNodes(nodes: ContentNode[]): TemplateResult;
+    renderToHTMLString(nodes: ContentNode[]): string;
+    private nodeToHTMLString;
+}
+//# sourceMappingURL=lit-renderer.d.ts.map

package/dist/lit-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit-renderer.d.ts","sourceRoot":"","sources":["../src/lit-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAQ,MAAM,KAAK,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,qBAAa,WAAW;IACtB,OAAO,CAAC,cAAc;IAOtB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,cAAc;IAyC7C,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,cAAc;IAOjD,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM;IAOhD,OAAO,CAAC,gBAAgB;CAuBzB"}

package/dist/lit-renderer.js

@@ -0,0 +1,80 @@
+import { html } from 'lit';
+import { unsafeHTML } from 'lit/directives/unsafe-html.js';
+export class LitRenderer {
+    renderTextNode(node) {
+        if (node.type === 'image') {
+            return html `<img src="${node.src}" alt="${node.alt || ''}" class="inline-image" style="max-width:100%;height:auto;">`;
+        }
+        return html `${unsafeHTML(node.content || '')}`;
+    }
+    renderNode(node) {
+        switch (node.type) {
+            case 'heading': {
+                const level = node.attributes?.level || '2';
+                if (level === '1')
+                    return html `<h1>${unsafeHTML(node.content)}</h1>`;
+                if (level === '2')
+                    return html `<h2>${unsafeHTML(node.content)}</h2>`;
+                if (level === '3')
+                    return html `<h3>${unsafeHTML(node.content)}</h3>`;
+                return html `<h2>${unsafeHTML(node.content)}</h2>`;
+            }
+            case 'paragraph':
+                if (node.children) {
+                    return html `<p>${node.children.map(child => this.renderTextNode(child))}</p>`;
+                }
+                return html `<p>${unsafeHTML(node.content)}</p>`;
+            case 'list':
+                return html `<ul>${node.children?.map(child => this.renderNode(child))}</ul>`;
+            case 'list-item':
+                return html `<li>${unsafeHTML(node.content)}</li>`;
+            case 'image':
+                return html `<img src="${node.src || node.attributes?.src}" alt="${node.alt || node.attributes?.alt || ''}" class="${node.className || ''}" style="max-width:100%;height:auto;">`;
+            case 'container':
+                return html `<div class="${node.className || ''}" style="${node.attributes?.style || ''}">
+          ${node.children?.map(child => this.renderNode(child))}
+        </div>`;
+            case 'code':
+                return html `<pre><code class="language-${node.attributes?.lang || ''}">${node.content || ''}</code></pre>`;
+            case 'text':
+                return html `${node.content}`;
+            default:
+                return html ``;
+        }
+    }
+    renderNodes(nodes) {
+        if (!nodes || nodes.length === 0) {
+            return html ``;
+        }
+        return html `${nodes.map(node => this.renderNode(node))}`;
+    }
+    renderToHTMLString(nodes) {
+        if (!nodes || nodes.length === 0) {
+            return '';
+        }
+        return nodes.map(node => this.nodeToHTMLString(node)).join('\n');
+    }
+    nodeToHTMLString(node) {
+        switch (node.type) {
+            case 'heading':
+                const level = node.attributes?.level || '2';
+                return `<h${level}>${node.content}</h${level}>`;
+            case 'paragraph':
+                return `<p>${node.content}</p>`;
+            case 'list':
+                const items = node.children?.map(child => this.nodeToHTMLString(child)).join('') || '';
+                return `<ul>${items}</ul>`;
+            case 'list-item':
+                return `<li>${node.content}</li>`;
+            case 'image':
+                return `<img src="${node.attributes?.src}" alt="${node.attributes?.alt}" class="${node.className || ''}">`;
+            case 'container':
+                const childrenHTML = node.children?.map(child => this.nodeToHTMLString(child)).join('') || '';
+                return `<div class="${node.className || ''}">${childrenHTML}</div>`;
+            case 'text':
+                return node.content || '';
+            default:
+                return '';
+        }
+    }
+}

package/dist/parser.d.ts

@@ -0,0 +1,16 @@
+import { ContentNode, MarkdownContent, ParseOptions } from './types';
+export declare class MarkdownParser {
+    private imagePathPrefix;
+    private imageBaseUrl;
+    constructor(options?: {
+        imagePathPrefix?: string;
+        imageBaseUrl?: string;
+    });
+    private processImagePath;
+    private processInlineFormatting;
+    private parseTokens;
+    private parseToken;
+    parse(markdown: string, options?: ParseOptions): MarkdownContent;
+    parseToNodes(markdown: string, options?: ParseOptions): ContentNode[];
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAErE,qBAAa,cAAc;IACzB,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,YAAY,CAAS;gBAEjB,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;IAKzE,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,UAAU;IAgFlB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,eAAe;IAgBhE,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,WAAW,EAAE;CAGtE"}

package/dist/parser.js

@@ -0,0 +1,117 @@
+import { marked } from 'marked';
+export class MarkdownParser {
+    constructor(options) {
+        this.imagePathPrefix = options?.imagePathPrefix || '';
+        this.imageBaseUrl = options?.imageBaseUrl || '';
+    }
+    processImagePath(src) {
+        if (src.startsWith('http') || src.startsWith('/')) {
+            return src;
+        }
+        let path = this.imagePathPrefix ? `${this.imagePathPrefix}${src}` : src;
+        if (this.imageBaseUrl && !path.startsWith('http')) {
+            path = `${this.imageBaseUrl}${path}`;
+        }
+        return path;
+    }
+    processInlineFormatting(text) {
+        return text
+            .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+            .replace(/\*(.+?)\*/g, '<em>$1</em>');
+    }
+    parseTokens(tokens) {
+        const nodes = [];
+        for (const token of tokens) {
+            const node = this.parseToken(token);
+            if (node) {
+                nodes.push(node);
+            }
+        }
+        return nodes;
+    }
+    parseToken(token) {
+        switch (token.type) {
+            case 'heading':
+                return {
+                    type: 'heading',
+                    content: token.text,
+                    attributes: { level: String(token.depth) }
+                };
+            case 'paragraph':
+                const tokens = token.tokens || [];
+                const hasInlineImage = tokens.some(t => t.type === 'image');
+                if (hasInlineImage) {
+                    const children = tokens.map(t => {
+                        if (t.type === 'image') {
+                            return {
+                                type: 'image',
+                                src: this.processImagePath(t.href),
+                                alt: t.text || ''
+                            };
+                        }
+                        return {
+                            type: 'text',
+                            content: this.processInlineFormatting(t.text || '')
+                        };
+                    });
+                    return {
+                        type: 'paragraph',
+                        children
+                    };
+                }
+                return {
+                    type: 'paragraph',
+                    content: this.processInlineFormatting(token.text)
+                };
+            case 'list':
+                return {
+                    type: 'list',
+                    ordered: token.ordered,
+                    children: token.items.map((item) => ({
+                        type: 'list-item',
+                        content: this.processInlineFormatting(item.text)
+                    }))
+                };
+            case 'image':
+                return {
+                    type: 'image',
+                    src: this.processImagePath(token.href),
+                    alt: token.title || ''
+                };
+            case 'code':
+                return {
+                    type: 'code',
+                    content: token.text,
+                    attributes: { lang: token.lang || '' }
+                };
+            case 'hr':
+                return { type: 'container', attributes: { tag: 'hr' } };
+            case 'blockquote':
+                return {
+                    type: 'container',
+                    attributes: { tag: 'blockquote' },
+                    children: this.parseTokens(token.tokens || [])
+                };
+            case 'html':
+                return { type: 'container', content: token.raw };
+            default:
+                return null;
+        }
+    }
+    parse(markdown, options) {
+        const parseOptions = {
+            gfm: options?.gfm ?? true,
+            breaks: options?.breaks ?? false,
+            pedantic: options?.pedantic ?? false
+        };
+        const tokens = marked.lexer(markdown, parseOptions);
+        const content = this.parseTokens(tokens);
+        return {
+            title: '',
+            content
+        };
+    }
+    parseToNodes(markdown, options) {
+        return this.parse(markdown, options).content;
+    }
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,18 @@
+import { ContentNode, MarkdownContent, PipelineConfig } from './types.js';
+export declare class MarkdownPipeline {
+    private parser;
+    private renderer;
+    private config;
+    constructor(config?: PipelineConfig);
+    parse(markdown: string): ContentNode[];
+    parseWithMetadata(markdown: string): MarkdownContent;
+    render(nodes: ContentNode[]): string;
+    renderMarkdown(markdown: string): string;
+    renderPage(title: string, nodes: ContentNode[], options?: {
+        lang?: string;
+        charset?: string;
+    }): string;
+    getConfig(): Readonly<Required<PipelineConfig>>;
+    getCustomCSS(): string;
+}
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAe,MAAM,YAAY,CAAC;AAEvF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,MAAM,CAA2B;gBAE7B,MAAM,GAAE,cAAmB;IAuBvC,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IAItC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe;IAIpD,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM;IAIpC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAKxC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,EAAE;QACxD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,MAAM;IAeV,SAAS,IAAI,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;IAI/C,YAAY,IAAI,MAAM;CAGvB"}

package/dist/pipeline.js

@@ -0,0 +1,58 @@
+import { MarkdownParser } from './parser.js';
+import { HTMLRenderer } from './renderer.js';
+export class MarkdownPipeline {
+    constructor(config = {}) {
+        this.config = {
+            imagePathPrefix: config.imagePathPrefix || '',
+            imageBaseUrl: config.imageBaseUrl || '',
+            parseOptions: {
+                gfm: config.parseOptions?.gfm ?? true,
+                breaks: config.parseOptions?.breaks ?? false,
+                pedantic: config.parseOptions?.pedantic ?? false
+            },
+            styleOptions: {
+                classPrefix: config.styleOptions?.classPrefix || '',
+                customCSS: config.styleOptions?.customCSS || '',
+                addHeadingIds: config.styleOptions?.addHeadingIds ?? false
+            }
+        };
+        this.parser = new MarkdownParser({
+            imagePathPrefix: this.config.imagePathPrefix,
+            imageBaseUrl: this.config.imageBaseUrl
+        });
+        this.renderer = new HTMLRenderer(this.config.styleOptions);
+    }
+    parse(markdown) {
+        return this.parser.parseToNodes(markdown, this.config.parseOptions);
+    }
+    parseWithMetadata(markdown) {
+        return this.parser.parse(markdown, this.config.parseOptions);
+    }
+    render(nodes) {
+        return this.renderer.renderNodes(nodes);
+    }
+    renderMarkdown(markdown) {
+        const nodes = this.parse(markdown);
+        return this.render(nodes);
+    }
+    renderPage(title, nodes, options) {
+        const html = this.render(nodes);
+        return `<!DOCTYPE html>
+<html lang="${options?.lang || 'en'}">
+<head>
+  <meta charset="${options?.charset || 'UTF-8'}">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+</head>
+<body>
+  ${html}
+</body>
+</html>`;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    getCustomCSS() {
+        return this.renderer.getCustomCSS();
+    }
+}

package/dist/renderer.d.ts

@@ -0,0 +1,15 @@
+import { ContentNode, StyleConfig } from './types.js';
+export declare class HTMLRenderer {
+    private config;
+    constructor(config?: StyleConfig);
+    private hasClassConfig;
+    private getClass;
+    private generateHeadingId;
+    private renderWithClass;
+    renderNode(node: ContentNode): string;
+    renderNodes(nodes: ContentNode[]): string;
+    renderToHTMLString(nodes: ContentNode[]): string;
+    render(markdown: string): string;
+    getCustomCSS(): string;
+}
+//# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAwB;gBAE1B,MAAM,GAAE,WAAgB;IAQpC,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,QAAQ;IAUhB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,eAAe;IAOvB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;IA4DrC,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM;IAOzC,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM;IAIhD,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAIhC,YAAY,IAAI,MAAM;CAGvB"}

package/dist/renderer.js

@@ -0,0 +1,102 @@
+export class HTMLRenderer {
+    constructor(config = {}) {
+        this.config = {
+            classPrefix: config.classPrefix || '',
+            customCSS: config.customCSS || '',
+            addHeadingIds: config.addHeadingIds ?? false
+        };
+    }
+    hasClassConfig() {
+        return this.config.classPrefix !== '' || this.config.addHeadingIds;
+    }
+    getClass(baseClass, nodeClass) {
+        if (!this.hasClassConfig()) {
+            return nodeClass || '';
+        }
+        const prefix = this.config.classPrefix;
+        const classes = [prefix ? `${prefix}${baseClass}` : baseClass];
+        if (nodeClass)
+            classes.push(nodeClass);
+        return classes.join(' ');
+    }
+    generateHeadingId(content) {
+        if (!content)
+            return '';
+        return content
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/(^-|-$)/g, '');
+    }
+    renderWithClass(tag, content, baseClass, nodeClass, extraAttrs) {
+        const classAttr = this.hasClassConfig() && baseClass
+            ? ` class="${this.getClass(baseClass, nodeClass)}"`
+            : '';
+        return `<${tag}${classAttr}${extraAttrs || ''}>${content}</${tag}>`;
+    }
+    renderNode(node) {
+        switch (node.type) {
+            case 'heading':
+                const level = node.attributes?.level || '2';
+                const headingId = this.config.addHeadingIds
+                    ? ` id="${this.generateHeadingId(node.content)}"`
+                    : '';
+                if (!this.hasClassConfig()) {
+                    return `<h${level}${headingId}>${node.content || ''}</h${level}>`;
+                }
+                return `<h${level}${headingId} class="${this.getClass('heading')}">${node.content || ''}</h${level}>`;
+            case 'paragraph':
+                if (node.children) {
+                    const childrenHtml = node.children.map(child => this.renderNode(child)).join('');
+                    return this.renderWithClass('p', childrenHtml, 'paragraph');
+                }
+                return this.renderWithClass('p', node.content || '', 'paragraph');
+            case 'list':
+                const tag = node.ordered ? 'ol' : 'ul';
+                const items = node.children?.map(child => this.renderNode(child)).join('') || '';
+                return this.renderWithClass(tag, items, 'list');
+            case 'list-item':
+                return this.renderWithClass('li', node.content || '', 'list-item');
+            case 'image':
+                const src = node.src || node.attributes?.src || '';
+                const alt = node.alt || node.attributes?.alt || '';
+                const classStr = this.getClass('image', node.className || undefined);
+                return `<img src="${src}" alt="${alt}"${classStr ? ` class="${classStr}"` : ''}>`;
+            case 'code':
+                const codeClass = this.hasClassConfig()
+                    ? ` class="${this.getClass('code')} language-${node.attributes?.lang || ''}"`
+                    : ` class="language-${node.attributes?.lang || ''}"`;
+                return `<pre><code${codeClass}>${node.content || ''}</code></pre>`;
+            case 'container':
+                if (node.attributes?.tag === 'hr')
+                    return '<hr>';
+                if (node.attributes?.tag === 'blockquote') {
+                    const children = node.children?.map(child => this.renderNode(child)).join('') || '';
+                    return this.renderWithClass('blockquote', children, 'blockquote');
+                }
+                const containerChildren = node.children?.map(child => this.renderNode(child)).join('') || '';
+                return this.renderWithClass('div', containerChildren, 'container', node.className || undefined);
+            case 'strong':
+                return `<strong>${node.content || ''}</strong>`;
+            case 'emphasis':
+                return `<em>${node.content || ''}</em>`;
+            case 'text':
+            default:
+                return node.content || '';
+        }
+    }
+    renderNodes(nodes) {
+        if (!nodes || nodes.length === 0) {
+            return '';
+        }
+        return nodes.map(node => this.renderNode(node)).join('\n');
+    }
+    renderToHTMLString(nodes) {
+        return this.renderNodes(nodes);
+    }
+    render(markdown) {
+        return markdown;
+    }
+    getCustomCSS() {
+        return this.config.customCSS;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+export type ContentNodeType = 'text' | 'heading' | 'paragraph' | 'list' | 'list-item' | 'image' | 'code' | 'container' | 'strong' | 'emphasis';
+export interface ContentNode {
+    type: ContentNodeType;
+    content?: string;
+    children?: ContentNode[];
+    attributes?: Record<string, unknown>;
+    className?: string;
+    src?: string;
+    alt?: string;
+    ordered?: boolean;
+}
+export interface MarkdownContent {
+    title: string;
+    metadata?: Record<string, unknown>;
+    content: ContentNode[];
+}
+export interface ParseOptions {
+    gfm?: boolean;
+    breaks?: boolean;
+    pedantic?: boolean;
+}
+export interface StyleConfig {
+    classPrefix?: string;
+    customCSS?: string;
+    addHeadingIds?: boolean;
+}
+export interface PipelineConfig {
+    imagePathPrefix?: string;
+    imageBaseUrl?: string;
+    parseOptions?: ParseOptions;
+    styleOptions?: StyleConfig;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,SAAS,GACT,WAAW,GACX,MAAM,GACN,WAAW,GACX,OAAO,GACP,MAAM,GACN,WAAW,GACX,QAAQ,GACR,UAAU,CAAC;AAEf,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leadertechie/md2html",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.3",
   "description": "Markdown to HTML pipeline - parse markdown to AST, render to HTML or Lit templates",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,6 +36,11 @@
     "ssr"
   ],
   "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/leadertechie/md2html.git"

package/.github/workflows/publish.yml

@@ -1,76 +0,0 @@
-name: CI / Publish
-
-on:
-  push:
-    branches:
-      - '**'
-  pull_request:
-  workflow_dispatch:
-
-jobs:
-  build-and-test:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    
-    steps:
-      - uses: actions/checkout@v4
-      
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-      
-      - name: Install dependencies
-        run: npm install
-      
-      - name: Run tests
-        run: npm test
-      
-      - name: Build package
-        run: npm run build
-
-  publish:
-    needs: build-and-test
-    runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
-    permissions:
-      contents: read
-    
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      
-      - name: Setup GitVersion
-        uses: gittools/actions/gitversion/setup@v0.10.2
-        with:
-          versionSpec: '5.x'
-      
-      - name: Execute GitVersion
-        id: gitversion
-        uses: gittools/actions/gitversion/execute@v0.10.2
-        with:
-          useConfigFile: true
-      
-      - name: Display GitVersion outputs
-        run: |
-          echo "FullSemVer: ${{ steps.gitversion.outputs.fullSemVer }}"
-      
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org/'
-      
-      - name: Install dependencies
-        run: npm install
-      
-      - name: Build package
-        run: npm run build
-      
-      - name: Update package version
-        run: npm version ${{ steps.gitversion.outputs.fullSemVer }} --no-git-tag-version
-      
-      - name: Publish to npm
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/GitVersion.yml

@@ -1,7 +0,0 @@
-next-version: 0.0.1
-mode: Mainline
-branches:
-  main:
-    regex: ^main$
-    increment: Patch
-    tag: alpha

package/__tests__/index.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/__tests__/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["index.test.ts"],"names":[],"mappings":""}