emdp 1.0.0

package/dist/types/parser/inlines/autolink-extended.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parser for GFM extended autolinks that recognize bare URLs and emails.
+ */
+import type { LinkNode } from '../types.js';
+export declare function parseWwwAutolink(text: string, pos: number, charBefore: string | undefined): {
+    node: LinkNode;
+    length: number;
+} | null;
+export declare function parseUrlAutolink(text: string, pos: number, charBefore: string | undefined): {
+    node: LinkNode;
+    length: number;
+} | null;
+export declare function parseEmailAutolink(text: string, pos: number, charBefore: string | undefined): {
+    node: LinkNode;
+    length: number;
+} | null;
+export declare function parseProtocolAutolink(text: string, pos: number, charBefore: string | undefined): {
+    node: LinkNode;
+    length: number;
+} | null;
+export declare function parseExtendedAutolink(text: string, pos: number, charBefore: string | undefined): {
+    node: LinkNode;
+    length: number;
+} | null;

package/dist/types/parser/inlines/autolink.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser for autolinks enclosed in angle brackets.
+ */
+import type { LinkNode } from '../types.js';
+export declare function parseAutolink(text: string, pos: number): {
+    node: LinkNode;
+    length: number;
+} | null;
+export declare function isAutolinkStart(text: string, pos: number): boolean;

package/dist/types/parser/inlines/code-span.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser for inline code spans delimited by backticks.
+ */
+import type { CodeSpanNode } from '../types.js';
+export declare function parseCodeSpan(text: string, pos: number): {
+    node: CodeSpanNode;
+    length: number;
+} | null;
+export declare function isCodeSpanStart(text: string, pos: number): boolean;

package/dist/types/parser/inlines/emphasis.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parser for emphasis and strong emphasis using * and _ delimiters.
+ */
+export interface DelimiterRun {
+    char: '*' | '_';
+    length: number;
+    canOpen: boolean;
+    canClose: boolean;
+    position: number;
+    origLength: number;
+}
+export declare function parseDelimiterRun(text: string, pos: number): DelimiterRun | null;
+export declare function isEmphasisDelimiter(text: string, pos: number): boolean;
+export declare function canDelimitersMatch(opener: DelimiterRun, closer: DelimiterRun): boolean;

package/dist/types/parser/inlines/entity.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parser for HTML character entities in inline content.
+ */
+export declare function parseEntity(text: string, pos: number): {
+    char: string;
+    length: number;
+} | null;
+export declare function isEntityStart(text: string, pos: number): boolean;

package/dist/types/parser/inlines/escape.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parser for backslash escape sequences and escaped hard breaks.
+ */
+export declare function parseEscape(text: string, pos: number): {
+    char: string;
+    length: number;
+} | null;
+export declare function isEscapedChar(text: string, pos: number): boolean;

package/dist/types/parser/inlines/footnote.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser for GFM footnote labels.
+ */
+export interface FootnoteLabelMatch {
+    label: string;
+    normalized: string;
+    length: number;
+}
+export declare function parseFootnoteLabel(text: string, pos: number): FootnoteLabelMatch | null;

package/dist/types/parser/inlines/hard-break.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser for hard line breaks created by backslash-newline or trailing spaces.
+ */
+import type { HardbreakNode } from '../types.js';
+export declare function parseHardBreak(text: string, pos: number): {
+    node: HardbreakNode;
+    length: number;
+} | null;
+export declare function isHardBreakStart(text: string, pos: number): boolean;

package/dist/types/parser/inlines/image.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Image parsing helpers that reuse link logic and create image nodes.
+ */
+export { createImageNode, isImageStart } from './link.js';

package/dist/types/parser/inlines/link.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Parser for inline links and images, including destinations, titles, and reference labels.
+ */
+import type { LinkNode, ImageNode } from '../types.js';
+export interface LinkMatch {
+    type: 'link' | 'image';
+    destination: string;
+    title: string;
+    textStart: number;
+    textEnd: number;
+    fullEnd: number;
+}
+export declare function parseLinkDestination(text: string): {
+    destination: string;
+    length: number;
+} | null;
+export declare function parseLinkTitle(text: string): {
+    title: string;
+    length: number;
+} | null;
+export declare function parseInlineLink(text: string, pos: number): {
+    destination: string;
+    title: string;
+    length: number;
+} | null;
+export declare function parseLinkLabel(text: string, pos: number): {
+    label: string;
+    length: number;
+} | null;
+export declare function createLinkNode(destination: string, title: string): LinkNode;
+export declare function createImageNode(destination: string, title: string, alt: string): ImageNode;
+export declare function isLinkStart(text: string, pos: number): boolean;
+export declare function isImageStart(text: string, pos: number): boolean;

package/dist/types/parser/inlines/soft-break.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser for soft line breaks created by single newlines.
+ */
+import type { SoftbreakNode } from '../types.js';
+export declare function parseSoftBreak(text: string, pos: number): {
+    node: SoftbreakNode;
+    length: number;
+} | null;
+export declare function isSoftBreak(text: string, pos: number): boolean;

package/dist/types/parser/inlines/strikethrough.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parser for GFM strikethrough using ~ delimiters.
+ */
+import type { StrikethroughNode, InlineNode } from '../types.js';
+export interface StrikethroughDelimiter {
+    char: '~';
+    length: number;
+    canOpen: boolean;
+    canClose: boolean;
+    position: number;
+    origLength: number;
+}
+export declare function parseStrikethroughDelimiter(text: string, pos: number): StrikethroughDelimiter | null;
+export declare function isStrikethroughDelimiter(text: string, pos: number): boolean;
+export declare function createStrikethroughNode(children?: InlineNode[]): StrikethroughNode;
+export declare function canStrikethroughDelimitersMatch(opener: StrikethroughDelimiter, closer: StrikethroughDelimiter): boolean;

package/dist/types/parser/inlines/text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Text node factories for literal inline content.
+ */
+import type { TextNode } from '../types.js';
+export declare function createTextNode(literal: string, noDelim?: boolean): TextNode;
+export declare function mergeTextNodes(nodes: TextNode[]): TextNode;

package/dist/types/parser/renderer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HTML renderer that converts a Markdown AST into HTML with configurable list, URL safety,
+ * and soft-break handling.
+ */
+import type { DocumentNode, RenderOptions } from './types.js';
+export declare class HtmlRenderer {
+    private options;
+    constructor(options?: RenderOptions);
+    render(document: DocumentNode): string;
+    private renderBlocks;
+    private renderBlock;
+    private renderParagraph;
+    private renderHeading;
+    private renderThematicBreak;
+    private renderCodeBlock;
+    private renderBlockquote;
+    private renderList;
+    private renderListItem;
+    private renderHtmlBlock;
+    private renderInlines;
+    private renderInline;
+    private renderText;
+    private renderSoftbreak;
+    private renderHardbreak;
+    private renderCodeSpan;
+    private renderEmphasis;
+    private renderStrong;
+    private renderLink;
+    private renderImage;
+    private renderHtmlInline;
+    private renderInlinesSmart;
+    private applyDashesAndEllipses;
+}

package/dist/types/parser/types.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Type definitions for the Markdown AST nodes and parser/render options.
+ */
+export type BlockType = 'document' | 'paragraph' | 'heading' | 'thematic_break' | 'code_block' | 'blockquote' | 'list' | 'list_item' | 'html_block' | 'link_reference_definition' | 'table';
+export type InlineType = 'text' | 'softbreak' | 'hardbreak' | 'code_span' | 'emphasis' | 'strong' | 'strikethrough' | 'footnote_ref' | 'link' | 'image' | 'html_inline';
+export interface Position {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface SourceLocation {
+    start: Position;
+    end: Position;
+}
+export interface BaseNode {
+    type: string;
+    sourcepos?: SourceLocation;
+}
+export interface DocumentNode extends BaseNode {
+    type: 'document';
+    children: BlockNode[];
+    footnoteDefinitions?: Map<string, FootnoteDefinition>;
+}
+export interface ParagraphNode extends BaseNode {
+    type: 'paragraph';
+    children: InlineNode[];
+}
+export interface HeadingNode extends BaseNode {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineNode[];
+}
+export interface ThematicBreakNode extends BaseNode {
+    type: 'thematic_break';
+}
+export interface CodeBlockNode extends BaseNode {
+    type: 'code_block';
+    info: string;
+    literal: string;
+    fenced: boolean;
+}
+export interface BlockquoteNode extends BaseNode {
+    type: 'blockquote';
+    children: BlockNode[];
+}
+export interface ListNode extends BaseNode {
+    type: 'list';
+    listType: 'bullet' | 'ordered';
+    start: number;
+    tight: boolean;
+    delimiter: '.' | ')' | null;
+    bulletChar: '-' | '+' | '*' | null;
+    children: ListItemNode[];
+}
+export interface ListItemNode extends BaseNode {
+    type: 'list_item';
+    children: BlockNode[];
+    checked?: boolean | null;
+}
+export interface HtmlBlockNode extends BaseNode {
+    type: 'html_block';
+    literal: string;
+}
+export type TableAlignment = 'left' | 'center' | 'right' | null;
+export interface TableCellNode extends BaseNode {
+    type: 'table_cell';
+    children: InlineNode[];
+    align: TableAlignment;
+    isHeader: boolean;
+}
+export interface TableRowNode extends BaseNode {
+    type: 'table_row';
+    children: TableCellNode[];
+    isHeader: boolean;
+}
+export interface TableNode extends BaseNode {
+    type: 'table';
+    alignments: TableAlignment[];
+    children: TableRowNode[];
+}
+export interface LinkReferenceDefinition {
+    destination: string;
+    title: string;
+}
+export type BlockNode = ParagraphNode | HeadingNode | ThematicBreakNode | CodeBlockNode | BlockquoteNode | ListNode | ListItemNode | HtmlBlockNode | TableNode;
+export interface TextNode extends BaseNode {
+    type: 'text';
+    literal: string;
+    noDelim?: boolean;
+    noSmart?: boolean;
+}
+export interface SoftbreakNode extends BaseNode {
+    type: 'softbreak';
+}
+export interface HardbreakNode extends BaseNode {
+    type: 'hardbreak';
+}
+export interface CodeSpanNode extends BaseNode {
+    type: 'code_span';
+    literal: string;
+}
+export interface EmphasisNode extends BaseNode {
+    type: 'emphasis';
+    children: InlineNode[];
+}
+export interface StrongNode extends BaseNode {
+    type: 'strong';
+    children: InlineNode[];
+}
+export interface StrikethroughNode extends BaseNode {
+    type: 'strikethrough';
+    children: InlineNode[];
+}
+export interface FootnoteRefNode extends BaseNode {
+    type: 'footnote_ref';
+    label: string;
+    key: string;
+}
+export interface LinkNode extends BaseNode {
+    type: 'link';
+    destination: string;
+    title: string;
+    children: InlineNode[];
+}
+export interface ImageNode extends BaseNode {
+    type: 'image';
+    destination: string;
+    title: string;
+    alt: string;
+}
+export interface HtmlInlineNode extends BaseNode {
+    type: 'html_inline';
+    literal: string;
+}
+export type InlineNode = TextNode | SoftbreakNode | HardbreakNode | CodeSpanNode | EmphasisNode | StrongNode | StrikethroughNode | FootnoteRefNode | LinkNode | ImageNode | HtmlInlineNode;
+export interface FootnoteDefinition {
+    label: string;
+    blocks: BlockNode[];
+}
+export interface ParseOptions {
+    sourcepos?: boolean;
+    extensions?: string[];
+}
+export interface RenderOptions {
+    softbreak?: string;
+    safe?: boolean;
+    tablePreferStyleAttributes?: boolean;
+    fullInfoString?: boolean;
+    smart?: boolean;
+    tagfilter?: boolean;
+    extensions?: string[];
+}

package/dist/types/parser/utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared text-processing utilities for the parser, including entity decoding, escaping,
+ * whitespace handling, and URI normalization.
+ */
+export declare function decodeHtmlEntities(str: string): string;
+export declare function escapeXml(str: string): string;
+export declare function escapeHtml(str: string, preserveEntities?: boolean): string;
+export declare const ASCII_PUNCTUATION_REGEX: RegExp;
+export declare const ASCII_PUNCTUATION_CHARS = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+export declare function isAsciiPunctuation(char: string): boolean;
+export declare function isWhitespace(char: string): boolean;
+export declare function isUnicodeWhitespace(char: string): boolean;
+export declare function isUnicodePunctuation(char: string): boolean;
+export declare function normalizeLineEndings(str: string): string;
+export declare function expandTabs(line: string, tabStop?: number): string;
+export declare function expandTabsPartial(line: string, startColumn: number, tabStop?: number): string;
+export declare function trimLeadingSpaces(line: string, max?: number): {
+    trimmed: string;
+    count: number;
+};
+export declare function countLeadingSpaces(line: string): number;
+export declare function countLeadingChars(line: string): {
+    spaces: number;
+    chars: number;
+};
+export declare function removeIndent(line: string, indent: number): string;
+export declare function extractContentAfterMarker(line: string, startColumn: number, charIndex: number): string;
+export declare function normalizeUri(uri: string): string;
+export declare function unescapeString(str: string): string;
+export declare function normalizeLabel(label: string): string;
+export declare function isTagFilterTag(tagName: string): boolean;
+export declare function applyTagFilter(html: string): string;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "emdp",
+  "version": "1.0.0",
+  "description": "A CommonMark-compliant Markdown parser with optional GFM support",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./gfm": {
+      "types": "./dist/types/gfm.d.ts",
+      "import": "./dist/esm/gfm.js",
+      "require": "./dist/cjs/gfm.js"
+    }
+  },
+  "bin": {
+    "mdparse": "dist/cjs/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run build:types && npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json && node scripts/write-esm-package.cjs",
+    "build:types": "tsc -p tsconfig.types.json",
+    "test": "node --test dist/cjs/**/*.test.js",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SerenaFontaine/emdp.git"
+  },
+  "keywords": [
+    "markdown",
+    "commonmark",
+    "gfm",
+    "github-flavored-markdown",
+    "parser"
+  ],
+  "author": "Serena Fontaine",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/SerenaFontaine/emdp/issues"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "typescript": "^5.3.0"
+  }
+}