mdream 0.2.8 → 0.4.0

package/dist/_chunks/types-D9VKEbix.d.mts

@@ -0,0 +1,255 @@
+//#region src/plugins/extraction.d.ts
+interface ExtractedElement extends ElementNode {
+  textContent: string;
+}
+declare function extractionPlugin(selectors: Record<string, (element: ExtractedElement, state: MdreamRuntimeState) => void>): Plugin;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Plugin interface for extending HTML to Markdown conversion
+ */
+interface Plugin {
+  /**
+   * Process a node before it's handled by the parser
+   */
+  beforeNodeProcess?: (event: NodeEvent, state: MdreamRuntimeState) => undefined | void | {
+    skip: boolean;
+  };
+  /**
+   * Hook that runs when entering a node
+   * @returns String to add to the output, or PluginHookResult with content
+   */
+  onNodeEnter?: (node: ElementNode, state: MdreamRuntimeState) => string | undefined | void;
+  /**
+   * Hook that runs when exiting a node
+   * @param event - The node event
+   * @param state - The current runtime state
+   * @returns String to add to the output, or PluginHookResult with content
+   */
+  onNodeExit?: (node: ElementNode, state: MdreamRuntimeState) => string | undefined | void;
+  /**
+   * Process attributes for a node
+   * @param node - The node to process attributes for
+   * @param state - The current runtime state
+   */
+  processAttributes?: (node: ElementNode, state: MdreamRuntimeState) => void;
+  /**
+   * Process a text node before it's added to the output
+   * @param node - The text node to process
+   * @param state - The current runtime state
+   * @returns Result with content and skip flag, or undefined for no transformation
+   */
+  processTextNode?: (node: TextNode, state: MdreamRuntimeState) => {
+    content: string;
+    skip: boolean;
+  } | undefined;
+}
+/**
+ * Plugin creation options for controlling plugin behavior
+ */
+interface PluginCreationOptions {
+  /**
+   * Order in which plugins are executed
+   * Lower numbers run first
+   */
+  order?: number;
+  /**
+   * Priority for region conflict resolution
+   * Higher numbers take precedence over lower
+   */
+  priority?: number;
+}
+interface HTMLToMarkdownOptions {
+  /**
+   * Origin URL for resolving relative image paths and internal links.
+   * Important when converting HTML with relative paths from a specific website.
+   */
+  origin?: string;
+  /**
+   * Plugins to extend HTML to Markdown conversion
+   */
+  plugins?: Plugin[];
+}
+declare const ELEMENT_NODE = 1;
+declare const TEXT_NODE = 3;
+interface ElementNode extends Node {
+  /** Element tag name (for ELEMENT_NODE) */
+  name: string;
+  /** HTML attributes (for ELEMENT_NODE) */
+  attributes: Record<string, string>;
+  /** Custom data added by plugins */
+  context?: PluginContext;
+  /** ID of the tag for fast handler lookup */
+  tagId?: number;
+  /** Map of tag names to their nesting count (using Uint8Array for performance) */
+  depthMap: Uint8Array;
+  /** Plugin outputs collected during processing */
+  pluginOutput?: string[];
+}
+interface TextNode extends Node {
+  /** Text content (for TEXT_NODE) */
+  value: string;
+  /** Custom data added by plugins */
+  context?: PluginContext;
+  /** Whether this text node should be excluded from markdown output (for script/style elements) */
+  excludedFromMarkdown?: boolean;
+}
+/**
+ * Base DOM node interface
+ * Optimized for streaming HTML parsing with minimal memory footprint
+ */
+interface Node {
+  /** Node type (ELEMENT_NODE or TEXT_NODE) */
+  type: number;
+  /** Current nesting depth in the DOM tree */
+  depth: number;
+  /** Node exclusion and filtering now handled by plugins */
+  /** Index of this node within its parent's children */
+  index: number;
+  /** Current walk index for child traversal during streaming */
+  currentWalkIndex?: number;
+  /** Count of text child nodes - used for whitespace handling */
+  childTextNodeIndex?: number;
+  /** Whether node contains whitespace - used for whitespace optimization */
+  containsWhitespace?: boolean;
+  /** Cached reference to tag handler for performance */
+  tagHandler?: TagHandler;
+  /** Parent node */
+  parent?: ElementNode | null;
+  /** Custom data added by plugins */
+  context?: PluginContext;
+  /** Region ID for buffer region tracking */
+  regionId?: number;
+}
+/**
+ * Buffer region for tracking content inclusion/exclusion
+ */
+interface BufferRegion {
+  /** Unique identifier */
+  id: number;
+  /** Inclusion state */
+  include: boolean;
+}
+/**
+ * State interface for HTML parsing and processing
+ * Contains parsing state that's maintained during HTML traversal
+ */
+interface MdreamProcessingState {
+  /** Map of tag names to their current nesting depth - uses TypedArray for performance */
+  depthMap: Uint8Array;
+  /** Current overall nesting depth */
+  depth: number;
+  /** Currently processing element node */
+  currentNode?: ElementNode | null;
+  /** Node filtering and exclusion is now handled by plugins */
+  /** Whether current content contains HTML entities that need decoding */
+  hasEncodedHtmlEntity?: boolean;
+  /** Whether the last processed character was whitespace - for collapsing whitespace */
+  lastCharWasWhitespace?: boolean;
+  /** Whether the last processed buffer has whitespace - optimization flag */
+  textBufferContainsWhitespace?: boolean;
+  /** Whether the last processed buffer contains non-whitespace characters */
+  textBufferContainsNonWhitespace?: boolean;
+  /** Whether a tag was just closed - affects whitespace handling */
+  justClosedTag?: boolean;
+  /** Whether the next text node is the first in its element - for whitespace trimming */
+  isFirstTextInElement?: boolean;
+  /** Reference to the last processed text node - for context tracking */
+  lastTextNode?: Node;
+  /** Quote state tracking for non-nesting tags - avoids backward scanning */
+  inSingleQuote?: boolean;
+  inDoubleQuote?: boolean;
+  inBacktick?: boolean;
+  /** Backslash escaping state tracking - avoids checking previous character */
+  lastCharWasBackslash?: boolean;
+  /** Plugin instances array for efficient iteration */
+  plugins?: Plugin[];
+  /** Configuration options for conversion */
+  options?: HTMLToMarkdownOptions;
+}
+/**
+ * Runtime state for markdown generation
+ * Extended state that includes output tracking and options
+ */
+interface MdreamRuntimeState extends Partial<MdreamProcessingState> {
+  /** Number of newlines at end of most recent output */
+  lastNewLines?: number;
+  /** Configuration options for conversion */
+  options?: HTMLToMarkdownOptions;
+  /** Table processing state - specialized for Markdown tables */
+  tableRenderedTable?: boolean;
+  tableCurrentRowCells?: number;
+  tableColumnAlignments?: string[];
+  /** Plugin instances array for efficient iteration */
+  plugins?: Plugin[];
+  /** Map of region IDs to buffer regions for O(1) lookups */
+  regionToggles: Map<number, boolean>;
+  /** Content buffers for regions */
+  regionContentBuffers: Map<number, string[]>;
+  /** Performance cache for last content to avoid iteration */
+  lastContentCache?: string;
+  /** Reference to the last processed node */
+  lastNode?: Node;
+  context?: PluginContext;
+}
+type NodeEventEnter = 0;
+type NodeEventExit = 1;
+/**
+ * Node event for DOM traversal
+ * Used in the event-based traversal system for streaming processing
+ */
+interface NodeEvent {
+  /** Event type - enter (start tag) or exit (end tag) */
+  type: NodeEventEnter | NodeEventExit;
+  /** The node being processed */
+  node: Node;
+}
+/**
+ * Handler context for markdown conversion
+ * Passed to tag handler functions for converting specific elements
+ */
+interface HandlerContext {
+  /** Current node being processed */
+  node: ElementNode;
+  /** Parent node (if any) */
+  parent?: ElementNode;
+  /** Runtime state */
+  state: MdreamRuntimeState;
+}
+/**
+ * Tag handler interface for HTML elements
+ * Used by plugins to extend or customize tag handling
+ */
+interface TagHandler {
+  enter?: (context: HandlerContext) => string | undefined | void;
+  exit?: (context: HandlerContext) => string | undefined | void;
+  isSelfClosing?: boolean;
+  isNonNesting?: boolean;
+  collapsesInnerWhiteSpace?: boolean;
+  isInline?: boolean;
+  spacing?: readonly [number, number];
+  excludesTextNodes?: boolean;
+}
+interface ReadabilityContext {
+  score?: number;
+  tagCount?: number;
+  linkTextLength?: number;
+  textLength?: number;
+  isHighLinkDensity?: boolean;
+}
+interface TailwindContext {
+  hidden?: boolean;
+  prefix?: string;
+  suffix?: string;
+}
+interface PluginContext {
+  score?: number;
+  tagCount?: number;
+  linkTextLength?: number;
+  textLength?: number;
+  isHighLinkDensity?: boolean;
+  tailwind?: TailwindContext;
+  [key: string]: unknown;
+}
+//#endregion
+export { BufferRegion, ELEMENT_NODE as ELEMENT_NODE$1, ElementNode, ExtractedElement, HTMLToMarkdownOptions, HandlerContext, MdreamProcessingState, MdreamRuntimeState, Node, NodeEvent, Plugin, PluginContext, PluginCreationOptions, ReadabilityContext, TEXT_NODE as TEXT_NODE$1, TagHandler, TailwindContext, TextNode, extractionPlugin as extractionPlugin$1 };

package/dist/cli.d.mts

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

package/dist/cli.mjs

@@ -1,25 +1,29 @@
-import { Readable } from 'node:stream';
-import { cac } from 'cac';
-import { f as frontmatterPlugin } from './shared/mdream.CNrwlePY.mjs';
-import { r as readabilityPlugin } from './shared/mdream.VU-fHLcf.mjs';
-import { s as streamHtmlToMarkdown } from './shared/mdream.DZEl9tTZ.mjs';
-import './shared/mdream.C8Xgmr_a.mjs';
+import "./_chunks/plugin-Bqz9GKOA.mjs";
+import { streamHtmlToMarkdown } from "./_chunks/stream-IeCVDuTy.mjs";
+import "./_chunks/plugins-D305pIpW.mjs";
+import { withMinimalPreset } from "./_chunks/minimal-Ru8PBNVI.mjs";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import { cac } from "cac";
 
+//#region src/cli.ts
 async function streamingConvert(options = {}) {
-  const outputStream = process.stdout;
-  const conversionOptions = { origin: options.origin };
-  conversionOptions.plugins = conversionOptions.plugins || [];
-  conversionOptions.plugins.push(readabilityPlugin());
-  conversionOptions.plugins.push(frontmatterPlugin());
-  const markdownGenerator = streamHtmlToMarkdown(Readable.toWeb(process.stdin), conversionOptions);
-  for await (const markdownChunk of markdownGenerator) {
-    if (markdownChunk && markdownChunk.length > 0) {
-      outputStream.write(markdownChunk);
-    }
-  }
+	const outputStream = process.stdout;
+	let conversionOptions = { origin: options.origin };
+	if (options.preset === "minimal") conversionOptions = withMinimalPreset(conversionOptions);
+	const markdownGenerator = streamHtmlToMarkdown(Readable.toWeb(process.stdin), conversionOptions);
+	for await (const markdownChunk of markdownGenerator) if (markdownChunk && markdownChunk.length > 0) outputStream.write(markdownChunk);
 }
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = join(__dirname, "..", "package.json");
+const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+const version = packageJson.version;
 const cli = cac();
 cli.command("[options]", "Convert HTML from stdin to Markdown on stdout").option("--origin <url>", "Origin URL for resolving relative image paths").option("--preset <preset>", "Conversion presets: minimal").action(async (_, opts) => {
-  await streamingConvert(opts);
+	await streamingConvert(opts);
 });
-cli.help().version("1.0.0").parse();
+cli.help().version(version).parse();
+
+//#endregion

package/dist/index.d.mts

@@ -1,10 +1,66 @@
-import { H as HTMLToMarkdownOptions } from './shared/mdream.C0Qx0F7t.mjs';
-export { B as BufferRegion, b as ELEMENT_NODE, E as ElementNode, f as HandlerContext, d as MdreamProcessingState, M as MdreamRuntimeState, N as Node, e as NodeEvent, P as Plugin, a as PluginCreationOptions, T as TEXT_NODE, g as TagHandler, c as TextNode } from './shared/mdream.C0Qx0F7t.mjs';
-import { ReadableStream } from 'node:stream/web';
-export { E as ExtractedElement } from './shared/mdream.DMe7T-0M.mjs';
+import { BufferRegion, ELEMENT_NODE$1 as ELEMENT_NODE, ElementNode, ExtractedElement, HTMLToMarkdownOptions, HandlerContext, MdreamProcessingState, MdreamRuntimeState, Node, NodeEvent, Plugin, PluginContext, PluginCreationOptions, ReadabilityContext, TEXT_NODE$1 as TEXT_NODE, TagHandler, TailwindContext, TextNode } from "./_chunks/types-D9VKEbix.mjs";
+import { createPlugin$1 as createPlugin } from "./_chunks/plugin-D45YAMmt.mjs";
+import { ReadableStream } from "node:stream/web";
 
-declare const TagIdMap: Record<string, number>;
+//#region src/const.d.ts
 
+declare const TagIdMap: Record<string, number>;
+//#endregion
+//#region src/markdown-processor.d.ts
+interface MarkdownState {
+  /** Configuration options for conversion */
+  options?: HTMLToMarkdownOptions;
+  /** Map of region IDs to buffer regions for O(1) lookups */
+  regionToggles: Map<number, boolean>;
+  /** Content buffers for regions */
+  regionContentBuffers: Map<number, string[]>;
+  /** Performance cache for last content to avoid iteration */
+  lastContentCache?: string;
+  /** Reference to the last processed node */
+  lastNode?: ElementNode | TextNode;
+  /** Reference to the last processed text node - for context tracking */
+  lastTextNode?: TextNode;
+  /** Table processing state - specialized for Markdown tables */
+  tableRenderedTable?: boolean;
+  tableCurrentRowCells?: number;
+  tableColumnAlignments?: string[];
+  /** Map of tag names to their current nesting depth */
+  depthMap: Uint8Array;
+  /** Current depth for plugin access */
+  depth?: number;
+  /** Context for additional data */
+  context?: PluginContext;
+}
+/**
+ * Creates a markdown processor that consumes DOM events and generates markdown
+ */
+declare function createMarkdownProcessor(options?: HTMLToMarkdownOptions): {
+  processEvent: (event: NodeEvent) => void;
+  processHtml: (html: string) => void;
+  getMarkdown: () => string;
+  getMarkdownChunk: () => string;
+  state: MarkdownState;
+};
+declare const MarkdownProcessor: typeof createMarkdownProcessor;
+//#endregion
+//#region src/parse.d.ts
+interface ParseOptions {
+  plugins?: Plugin[];
+}
+interface ParseResult {
+  events: NodeEvent[];
+  remainingHtml: string;
+}
+/**
+ * Pure HTML parser that emits DOM events
+ * Completely decoupled from markdown generation
+ */
+declare function parseHtml(html: string, options?: ParseOptions): ParseResult;
+/**
+ * Streaming HTML parser - calls onEvent for each DOM event
+ */
+//#endregion
+//#region src/stream.d.ts
 /**
  * Creates a markdown stream from an HTML stream
  * @param htmlStream - ReadableStream of HTML content (as Uint8Array or string)
@@ -12,7 +68,8 @@ declare const TagIdMap: Record<string, number>;
  * @returns An async generator yielding markdown chunks
  */
 declare function streamHtmlToMarkdown(htmlStream: ReadableStream | null, options?: HTMLToMarkdownOptions): AsyncIterable<string>;
-
+//#endregion
+//#region src/index.d.ts
 declare function htmlToMarkdown(html: string, options?: HTMLToMarkdownOptions): string;
-
-export { HTMLToMarkdownOptions, TagIdMap, htmlToMarkdown, streamHtmlToMarkdown };
+//#endregion
+export { BufferRegion, ELEMENT_NODE, ElementNode, ExtractedElement, HTMLToMarkdownOptions, HandlerContext, MarkdownProcessor, MdreamProcessingState, MdreamRuntimeState, Node, NodeEvent, Plugin, PluginContext, PluginCreationOptions, ReadabilityContext, TEXT_NODE, TagHandler, TagIdMap, TailwindContext, TextNode, createPlugin, htmlToMarkdown, parseHtml, streamHtmlToMarkdown };

package/dist/index.mjs

@@ -1,13 +1,12 @@
-import { p as processPartialHTMLToMarkdown } from './shared/mdream.DZEl9tTZ.mjs';
-export { s as streamHtmlToMarkdown } from './shared/mdream.DZEl9tTZ.mjs';
-export { T as TagIdMap } from './shared/mdream.C8Xgmr_a.mjs';
+import { TagIdMap, createPlugin } from "./_chunks/plugin-Bqz9GKOA.mjs";
+import { MarkdownProcessor, createMarkdownProcessor, parseHtml, streamHtmlToMarkdown } from "./_chunks/stream-IeCVDuTy.mjs";
 
+//#region src/index.ts
 function htmlToMarkdown(html, options = {}) {
-  const state = {
-    options
-  };
-  const result = processPartialHTMLToMarkdown(html, state).chunk;
-  return result.trimEnd();
+	const processor = createMarkdownProcessor(options);
+	processor.processHtml(html);
+	return processor.getMarkdown();
 }
 
-export { htmlToMarkdown };
+//#endregion
+export { MarkdownProcessor, TagIdMap, createPlugin, htmlToMarkdown, parseHtml, streamHtmlToMarkdown };

package/dist/plugins.d.mts

@@ -1,12 +1,7 @@
-import { P as Plugin } from './shared/mdream.C0Qx0F7t.mjs';
-export { e as extractionPlugin } from './shared/mdream.DMe7T-0M.mjs';
+import { Plugin, extractionPlugin$1 as extractionPlugin } from "./_chunks/types-D9VKEbix.mjs";
+import { createPlugin$1 as createPlugin } from "./_chunks/plugin-D45YAMmt.mjs";
 
-/**
- * Create a plugin that implements the Plugin interface with improved type inference
- *
- * @returns A complete plugin implementation
- */
-declare function createPlugin<T extends Partial<Plugin>>(plugin: T): Plugin;
+//#region src/plugins/filter.d.ts
 
 /**
  * Plugin that filters nodes based on CSS selectors.
@@ -21,29 +16,31 @@ declare function createPlugin<T extends Partial<Plugin>>(plugin: T): Plugin;
  * withQuerySelectorPlugin({ exclude: ['nav', '#sidebar', '.footer'] })
  */
 declare function filterPlugin(options?: {
-    /** CSS selectors (or Tag Ids) for elements to include (all others will be excluded) */
-    include?: (string | number)[];
-    /** CSS selectors (or Tag Ids) for elements to exclude */
-    exclude?: (string | number)[];
-    /** Whether to also process the children of matching elements */
-    processChildren?: boolean;
-    keepAbsolute?: boolean;
+  /** CSS selectors (or Tag Ids) for elements to include (all others will be excluded) */
+  include?: (string | number)[];
+  /** CSS selectors (or Tag Ids) for elements to exclude */
+  exclude?: (string | number)[];
+  /** Whether to also process the children of matching elements */
+  processChildren?: boolean;
+  keepAbsolute?: boolean;
 }): Plugin;
-
+//#endregion
+//#region src/plugins/frontmatter.d.ts
 interface FrontmatterPluginOptions {
-    /** Additional frontmatter fields to include */
-    additionalFields?: Record<string, string>;
-    /** Meta tag names to extract (beyond the standard ones) */
-    metaFields?: string[];
-    /** Custom formatter for frontmatter values */
-    formatValue?: (name: string, value: string) => string;
+  /** Additional frontmatter fields to include */
+  additionalFields?: Record<string, string>;
+  /** Meta tag names to extract (beyond the standard ones) */
+  metaFields?: string[];
+  /** Custom formatter for frontmatter values */
+  formatValue?: (name: string, value: string) => string;
 }
 /**
  * A plugin that manages frontmatter generation from HTML head elements
  * Extracts metadata from meta tags and title and generates YAML frontmatter
  */
 declare function frontmatterPlugin(options?: FrontmatterPluginOptions): Plugin;
-
+//#endregion
+//#region src/plugins/isolate-main.d.ts
 /**
  * Plugin that isolates main content using the following priority order:
  * 1. If an explicit <main> element exists (within 5 depth levels), use its content exclusively
@@ -74,16 +71,18 @@ declare function frontmatterPlugin(options?: FrontmatterPluginOptions): Plugin;
  * ```
  */
 declare function isolateMainPlugin(): Plugin;
-
+//#endregion
+//#region src/plugins/readability.d.ts
 /**
  * Creates a plugin that implements readability.js style heuristics for content quality assessment
  * Controls content inclusion/exclusion using buffer regions
  */
 declare function readabilityPlugin(): Plugin;
-
+//#endregion
+//#region src/plugins/tailwind.d.ts
 /**
  * Creates a plugin that adds Tailwind class processing
  */
 declare function tailwindPlugin(): Plugin;
-
-export { createPlugin, filterPlugin, frontmatterPlugin, isolateMainPlugin, readabilityPlugin, tailwindPlugin };
+//#endregion
+export { createPlugin, extractionPlugin, filterPlugin, frontmatterPlugin, isolateMainPlugin, readabilityPlugin, tailwindPlugin };

package/dist/plugins.mjs

@@ -1,46 +1,4 @@
-import { c as createPlugin } from './shared/mdream.CNrwlePY.mjs';
-export { f as frontmatterPlugin } from './shared/mdream.CNrwlePY.mjs';
-import { p as parseSelector } from './shared/mdream.Crxe0Sar.mjs';
-export { f as filterPlugin, i as isolateMainPlugin, t as tailwindPlugin } from './shared/mdream.Crxe0Sar.mjs';
-export { r as readabilityPlugin } from './shared/mdream.VU-fHLcf.mjs';
-import './shared/mdream.C8Xgmr_a.mjs';
+import { createPlugin } from "./_chunks/plugin-Bqz9GKOA.mjs";
+import { extractionPlugin, filterPlugin, frontmatterPlugin, isolateMainPlugin, readabilityPlugin, tailwindPlugin } from "./_chunks/plugins-D305pIpW.mjs";
 
-function extractionPlugin(selectors) {
-  const matcherCallbacks = Object.entries(selectors).map(([selector, callback]) => ({
-    matcher: parseSelector(selector),
-    callback
-  }));
-  const trackedElements = /* @__PURE__ */ new Map();
-  return createPlugin({
-    onNodeEnter(element) {
-      matcherCallbacks.forEach(({ matcher, callback }) => {
-        if (matcher.matches(element)) {
-          trackedElements.set(element, { textContent: "", callback });
-        }
-      });
-    },
-    processTextNode(textNode) {
-      let currentParent = textNode.parent;
-      while (currentParent) {
-        const tracked = trackedElements.get(currentParent);
-        if (tracked) {
-          tracked.textContent += textNode.value;
-        }
-        currentParent = currentParent.parent;
-      }
-    },
-    onNodeExit(element, state) {
-      const tracked = trackedElements.get(element);
-      if (tracked) {
-        const extractedElement = {
-          ...element,
-          textContent: tracked.textContent.trim()
-        };
-        tracked.callback(extractedElement, state);
-        trackedElements.delete(element);
-      }
-    }
-  });
-}
-
-export { createPlugin, extractionPlugin };
+export { createPlugin, extractionPlugin, filterPlugin, frontmatterPlugin, isolateMainPlugin, readabilityPlugin, tailwindPlugin };

package/dist/preset/minimal.d.mts

@@ -1,4 +1,6 @@
-import { H as HTMLToMarkdownOptions } from '../shared/mdream.C0Qx0F7t.mjs';
+import { HTMLToMarkdownOptions } from "../_chunks/types-D9VKEbix.mjs";
+
+//#region src/preset/minimal.d.ts
 
 /**
  * Creates a configurable minimal preset with advanced options
@@ -7,5 +9,5 @@ import { H as HTMLToMarkdownOptions } from '../shared/mdream.C0Qx0F7t.mjs';
  * @returns HTML to Markdown options with configured plugins
  */
 declare function withMinimalPreset(options?: HTMLToMarkdownOptions): HTMLToMarkdownOptions;
-
-export { withMinimalPreset };
+//#endregion
+export { withMinimalPreset };

package/dist/preset/minimal.mjs

@@ -1,39 +1,5 @@
-import { aa as TAG_FORM, W as TAG_FIELDSET, b2 as TAG_OBJECT, a5 as TAG_EMBED, b6 as TAG_FIGURE, ab as TAG_FOOTER, v as TAG_ASIDE, Q as TAG_IFRAME, a4 as TAG_INPUT, Y as TAG_TEXTAREA, Z as TAG_SELECT, ai as TAG_BUTTON, ak as TAG_NAV } from '../shared/mdream.C8Xgmr_a.mjs';
-import { i as isolateMainPlugin, t as tailwindPlugin, f as filterPlugin } from '../shared/mdream.Crxe0Sar.mjs';
-import { f as frontmatterPlugin } from '../shared/mdream.CNrwlePY.mjs';
+import "../_chunks/plugin-Bqz9GKOA.mjs";
+import "../_chunks/plugins-D305pIpW.mjs";
+import { withMinimalPreset } from "../_chunks/minimal-Ru8PBNVI.mjs";
 
-function withMinimalPreset(options = {}) {
-  const plugins = [
-    isolateMainPlugin(),
-    frontmatterPlugin(),
-    tailwindPlugin(),
-    // First apply readability plugin to extract main content
-    // Then filter out unwanted tags
-    filterPlugin({
-      exclude: [
-        TAG_FORM,
-        TAG_FIELDSET,
-        TAG_OBJECT,
-        TAG_EMBED,
-        TAG_FIGURE,
-        TAG_FOOTER,
-        TAG_ASIDE,
-        TAG_IFRAME,
-        TAG_INPUT,
-        TAG_TEXTAREA,
-        TAG_SELECT,
-        TAG_BUTTON,
-        TAG_NAV
-      ]
-    })
-  ];
-  if (options.plugins) {
-    plugins.push(...options.plugins);
-  }
-  return {
-    ...options,
-    plugins
-  };
-}
-
-export { withMinimalPreset };
+export { withMinimalPreset };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mdream",
   "type": "module",
-  "version": "0.2.8",
+  "version": "0.4.0",
   "description": "Ultra-performant JavaScript HTML to Markdown converter optimized for LLMs.",
   "author": {
     "name": "Harlan Wilton",
@@ -28,18 +28,6 @@
   "dependencies": {
     "cac": "^6.7.14"
   },
-  "devDependencies": {
-    "@antfu/eslint-config": "^4.16.1",
-    "@types/node": "^22.15.34",
-    "bumpp": "^10.2.0",
-    "crawlee": "^3.13.8",
-    "eslint": "^9.30.0",
-    "llm-cost": "^1.0.5",
-    "playwright": "^1.53.1",
-    "typescript": "5.8.3",
-    "unbuild": "^3.5.0",
-    "vitest": "^3.2.4"
-  },
   "scripts": {
     "flame": "pnpm build && unbuild bench/bundle && clinic flame -- node bench/bundle/dist/string.mjs 10",
     "bench:build": "pnpm build && unbuild bench/bundle",
@@ -53,10 +41,9 @@
     "test:github:file": "cat test/fixtures/github-markdown-complete.html | node ./bin/mdream.mjs --origin https://docs.github.com | tee test/github-markdown.md",
     "test:wiki:file": "pnpm build && cat test/fixtures/wikipedia-largest.html | node ./bin/mdream.mjs --origin https://en.wikipedia.org | tee test/wiki-markdown.md",
     "test:wiki-small:file": "cat test/fixtures/wikipedia-small.html | node ./bin/mdream.mjs --origin https://en.wikipedia.org | tee test/wiki-markdown.md",
-    "build": "unbuild",
-    "typecheck": "tsc --noEmit src/index.ts",
-    "dev:prepare": "unbuild --stub",
-    "test": "vitest test",
-    "release": "pnpm build && bumpp && pnpm -r publish"
+    "build": "obuild",
+    "typecheck": "tsc --noEmit",
+    "dev:prepare": "obuild --stub",
+    "test": "vitest test"
   }
 }