pd-markdown 1.0.0

package/packages/utils/.rollup.cache/Users/pidan/Work/Learn/pd-markdown/packages/utils/dist/string/slugify.js

@@ -0,0 +1,39 @@
+/**
+ * Convert text to URL-safe slug
+ *
+ * @param text - Text to slugify
+ * @returns URL-safe slug
+ */
+export function slugify(text) {
+    return (text
+        // Convert to lowercase
+        .toLowerCase()
+        // Replace Chinese characters with pinyin-like representation (keep as-is for simplicity)
+        // Replace spaces and special chars with hyphens
+        .replace(/[\s_]+/g, '-')
+        // Remove characters that aren't alphanumeric, hyphens, or common CJK
+        .replace(/[^\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff-]/g, '')
+        // Replace multiple consecutive hyphens with single hyphen
+        .replace(/-+/g, '-')
+        // Remove leading/trailing hyphens
+        .replace(/^-+|-+$/g, ''));
+}
+/**
+ * Generate unique slug with counter suffix for duplicates
+ *
+ * @param text - Text to slugify
+ * @param existingSlugs - Set of existing slugs to check against
+ * @returns Unique slug
+ */
+export function uniqueSlugify(text, existingSlugs) {
+    const baseSlug = slugify(text);
+    let slug = baseSlug;
+    let counter = 1;
+    while (existingSlugs.has(slug)) {
+        slug = `${baseSlug}-${counter}`;
+        counter++;
+    }
+    existingSlugs.add(slug);
+    return slug;
+}
+//# sourceMappingURL=slugify.js.map

package/packages/utils/.rollup.cache/Users/pidan/Work/Learn/pd-markdown/packages/utils/dist/string/slugify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.js","sourceRoot":"","sources":["../../src/string/slugify.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY;IAClC,OAAO,CACL,IAAI;QACF,uBAAuB;SACtB,WAAW,EAAE;QACd,yFAAyF;QACzF,gDAAgD;SAC/C,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;QACxB,qEAAqE;SACpE,OAAO,CAAC,gDAAgD,EAAE,EAAE,CAAC;QAC9D,0DAA0D;SACzD,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;QACpB,kCAAkC;SACjC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAC3B,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,aAA0B;IACpE,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9B,IAAI,IAAI,GAAG,QAAQ,CAAA;IACnB,IAAI,OAAO,GAAG,CAAC,CAAA;IAEf,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/B,IAAI,GAAG,GAAG,QAAQ,IAAI,OAAO,EAAE,CAAA;QAC/B,OAAO,EAAE,CAAA;IACX,CAAC;IAED,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACvB,OAAO,IAAI,CAAA;AACb,CAAC"}

package/packages/utils/.rollup.cache/Users/pidan/Work/Learn/pd-markdown/packages/utils/dist/types/index.d.ts

@@ -0,0 +1,49 @@
+import type { Root, Content, Parent, Literal } from 'mdast';
+import type { Node as UnistNode } from 'unist';
+export type { Root, Content, Parent, Literal };
+/**
+ * All possible markdown node types
+ */
+export type MdNode = Root | Content;
+/**
+ * Root node of markdown AST
+ */
+export type MdRoot = Root;
+/**
+ * Visitor function for AST traversal
+ */
+export type Visitor<T extends UnistNode = MdNode> = (node: T, index: number | undefined, parent: Parent | undefined) => void | boolean;
+/**
+ * Plugin options base interface
+ */
+export interface PluginOptions {
+    [key: string]: unknown;
+}
+/**
+ * Position information in source
+ */
+export interface Position {
+    line: number;
+    column: number;
+    offset?: number;
+}
+/**
+ * Location in source
+ */
+export interface Location {
+    start: Position;
+    end: Position;
+}
+/**
+ * Type guard to check if node is a parent node
+ */
+export declare function isParent(node: UnistNode): node is Parent;
+/**
+ * Type guard to check if node is a literal node
+ */
+export declare function isLiteral(node: UnistNode): node is Literal;
+/**
+ * Type guard to check if node has specific type
+ */
+export declare function isNodeType<T extends MdNode>(node: UnistNode, type: T['type']): node is T;
+//# sourceMappingURL=index.d.ts.map

package/packages/utils/.rollup.cache/Users/pidan/Work/Learn/pd-markdown/packages/utils/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC3D,OAAO,KAAK,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,OAAO,CAAA;AAG9C,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAA;AAE9C;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,IAAI,GAAG,OAAO,CAAA;AAEnC;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,IAAI,CAAA;AAEzB;;GAEG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,MAAM,IAAI,CAClD,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,MAAM,GAAG,SAAS,KACvB,IAAI,GAAG,OAAO,CAAA;AAEnB;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,QAAQ,CAAA;IACf,GAAG,EAAE,QAAQ,CAAA;CACd;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,MAAM,CAExD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,OAAO,CAE1D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,GACd,IAAI,IAAI,CAAC,CAEX"}

package/packages/utils/.rollup.cache/Users/pidan/Work/Learn/pd-markdown/packages/utils/dist/types/index.js

@@ -0,0 +1,19 @@
+/**
+ * Type guard to check if node is a parent node
+ */
+export function isParent(node) {
+    return 'children' in node && Array.isArray(node.children);
+}
+/**
+ * Type guard to check if node is a literal node
+ */
+export function isLiteral(node) {
+    return 'value' in node && typeof node.value === 'string';
+}
+/**
+ * Type guard to check if node has specific type
+ */
+export function isNodeType(node, type) {
+    return node.type === type;
+}
+//# sourceMappingURL=index.js.map

package/packages/utils/.rollup.cache/Users/pidan/Work/Learn/pd-markdown/packages/utils/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAiDA;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAe;IACtC,OAAO,UAAU,IAAI,IAAI,IAAI,KAAK,CAAC,OAAO,CAAE,IAAe,CAAC,QAAQ,CAAC,CAAA;AACvE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,SAAS,CAAC,IAAe;IACvC,OAAO,OAAO,IAAI,IAAI,IAAI,OAAQ,IAAgB,CAAC,KAAK,KAAK,QAAQ,CAAA;AACvE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CACxB,IAAe,EACf,IAAe;IAEf,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,CAAA;AAC3B,CAAC"}

package/packages/utils/__tests__/query.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect } from 'vitest'
+import { findNodes, findNode, findNodesBy, findParent } from '../src/ast/query'
+import type { Root, Paragraph, Text, Heading, Strong } from 'mdast'
+
+describe('findNodes', () => {
+  const createAst = (): Root => ({
+    type: 'root',
+    children: [
+      {
+        type: 'heading',
+        depth: 1,
+        children: [{ type: 'text', value: 'Title' }],
+      } as Heading,
+      {
+        type: 'paragraph',
+        children: [
+          { type: 'text', value: 'Hello ' },
+          {
+            type: 'strong',
+            children: [{ type: 'text', value: 'world' }],
+          } as Strong,
+        ],
+      } as Paragraph,
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: 'Subtitle' }],
+      } as Heading,
+    ],
+  })
+
+  it('should find all nodes of specified type', () => {
+    const ast = createAst()
+    const headings = findNodes<Heading>(ast, 'heading')
+
+    expect(headings).toHaveLength(2)
+    expect(headings[0].depth).toBe(1)
+    expect(headings[1].depth).toBe(2)
+  })
+
+  it('should find nested nodes', () => {
+    const ast = createAst()
+    const texts = findNodes<Text>(ast, 'text')
+
+    expect(texts).toHaveLength(4)
+    expect(texts.map((t) => t.value)).toEqual([
+      'Title',
+      'Hello ',
+      'world',
+      'Subtitle',
+    ])
+  })
+
+  it('should return empty array when no matches', () => {
+    const ast = createAst()
+    const codes = findNodes(ast, 'code')
+
+    expect(codes).toEqual([])
+  })
+})
+
+describe('findNode', () => {
+  const createAst = (): Root => ({
+    type: 'root',
+    children: [
+      {
+        type: 'heading',
+        depth: 1,
+        children: [{ type: 'text', value: 'First' }],
+      } as Heading,
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: 'Second' }],
+      } as Heading,
+    ],
+  })
+
+  it('should find first matching node', () => {
+    const ast = createAst()
+    const heading = findNode<Heading>(ast, 'heading')
+
+    expect(heading).toBeDefined()
+    expect(heading!.depth).toBe(1)
+  })
+
+  it('should return undefined when no match', () => {
+    const ast = createAst()
+    const code = findNode(ast, 'code')
+
+    expect(code).toBeUndefined()
+  })
+})
+
+describe('findNodesBy', () => {
+  const createAst = (): Root => ({
+    type: 'root',
+    children: [
+      {
+        type: 'heading',
+        depth: 1,
+        children: [{ type: 'text', value: 'H1' }],
+      } as Heading,
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: 'H2' }],
+      } as Heading,
+      {
+        type: 'heading',
+        depth: 1,
+        children: [{ type: 'text', value: 'Another H1' }],
+      } as Heading,
+    ],
+  })
+
+  it('should find nodes matching predicate', () => {
+    const ast = createAst()
+    const h1s = findNodesBy<Heading>(
+      ast,
+      (node) => node.type === 'heading' && (node as Heading).depth === 1
+    )
+
+    expect(h1s).toHaveLength(2)
+    expect(h1s[0].children[0]).toHaveProperty('value', 'H1')
+    expect(h1s[1].children[0]).toHaveProperty('value', 'Another H1')
+  })
+})
+
+describe('findParent', () => {
+  it('should find parent of a node', () => {
+    const textNode: Text = { type: 'text', value: 'Hello' }
+    const paragraph: Paragraph = {
+      type: 'paragraph',
+      children: [textNode],
+    }
+    const ast: Root = {
+      type: 'root',
+      children: [paragraph],
+    }
+
+    const parent = findParent(ast, textNode)
+    expect(parent).toBe(paragraph)
+  })
+
+  it('should return undefined for root node', () => {
+    const ast: Root = {
+      type: 'root',
+      children: [],
+    }
+
+    const parent = findParent(ast, ast)
+    expect(parent).toBeUndefined()
+  })
+})

package/packages/utils/__tests__/sanitize.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest'
+import { escapeHtml, sanitizeHtml, stripHtml } from '../src/string/sanitize'
+
+describe('escapeHtml', () => {
+  it('should escape ampersand', () => {
+    expect(escapeHtml('foo & bar')).toBe('foo & bar')
+  })
+
+  it('should escape less than', () => {
+    expect(escapeHtml('a < b')).toBe('a &lt; b')
+  })
+
+  it('should escape greater than', () => {
+    expect(escapeHtml('a > b')).toBe('a &gt; b')
+  })
+
+  it('should escape double quotes', () => {
+    expect(escapeHtml('say "hello"')).toBe('say &quot;hello&quot;')
+  })
+
+  it('should escape single quotes', () => {
+    expect(escapeHtml("it's")).toBe('it&#39;s')
+  })
+
+  it('should escape multiple characters', () => {
+    expect(escapeHtml('<script>alert("xss")</script>')).toBe(
+      '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;'
+    )
+  })
+
+  it('should preserve safe text', () => {
+    expect(escapeHtml('Hello World 123')).toBe('Hello World 123')
+  })
+})
+
+describe('sanitizeHtml', () => {
+  it('should remove script tags', () => {
+    expect(sanitizeHtml('<script>alert("xss")</script>')).toBe('')
+  })
+
+  it('should remove event handlers', () => {
+    expect(sanitizeHtml('<div onclick="alert(1)">text</div>')).toBe(
+      '<div>text</div>'
+    )
+  })
+
+  it('should remove javascript: URLs', () => {
+    expect(sanitizeHtml('<a href="javascript:alert(1)">click</a>')).toBe(
+      '<a href="">click</a>'
+    )
+  })
+
+  it('should preserve allowed tags', () => {
+    expect(sanitizeHtml('<p>Hello <strong>world</strong></p>')).toBe(
+      '<p>Hello <strong>world</strong></p>'
+    )
+  })
+
+  it('should preserve allowed attributes', () => {
+    expect(sanitizeHtml('<a href="https://example.com" title="link">text</a>')).toBe(
+      '<a href="https://example.com" title="link">text</a>'
+    )
+  })
+
+  it('should remove disallowed tags', () => {
+    expect(sanitizeHtml('<iframe src="evil.com"></iframe>')).toBe('')
+  })
+
+  it('should remove disallowed attributes', () => {
+    expect(sanitizeHtml('<div data-evil="bad">text</div>')).toBe('<div>text</div>')
+  })
+
+  it('should handle nested script content', () => {
+    expect(
+      sanitizeHtml('<div><script>bad()</script>safe</div>')
+    ).toBe('<div>safe</div>')
+  })
+})
+
+describe('stripHtml', () => {
+  it('should remove all HTML tags', () => {
+    expect(stripHtml('<p>Hello <strong>world</strong></p>')).toBe('Hello world')
+  })
+
+  it('should handle self-closing tags', () => {
+    expect(stripHtml('Hello<br/>World')).toBe('HelloWorld')
+  })
+
+  it('should preserve text content', () => {
+    expect(stripHtml('No tags here')).toBe('No tags here')
+  })
+
+  it('should handle nested tags', () => {
+    expect(stripHtml('<div><p><span>Deep</span></p></div>')).toBe('Deep')
+  })
+})

package/packages/utils/__tests__/slugify.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest'
+import { slugify, uniqueSlugify } from '../src/string/slugify'
+
+describe('slugify', () => {
+  it('should convert text to lowercase', () => {
+    expect(slugify('Hello World')).toBe('hello-world')
+  })
+
+  it('should replace spaces with hyphens', () => {
+    expect(slugify('hello world')).toBe('hello-world')
+  })
+
+  it('should replace underscores with hyphens', () => {
+    expect(slugify('hello_world')).toBe('hello-world')
+  })
+
+  it('should remove special characters', () => {
+    expect(slugify('Hello! World?')).toBe('hello-world')
+  })
+
+  it('should handle multiple consecutive spaces', () => {
+    expect(slugify('hello   world')).toBe('hello-world')
+  })
+
+  it('should remove leading and trailing hyphens', () => {
+    expect(slugify('  hello world  ')).toBe('hello-world')
+  })
+
+  it('should preserve Chinese characters', () => {
+    expect(slugify('你好世界')).toBe('你好世界')
+  })
+
+  it('should handle mixed Chinese and English', () => {
+    expect(slugify('Hello 你好 World')).toBe('hello-你好-world')
+  })
+
+  it('should handle Japanese characters', () => {
+    expect(slugify('こんにちは')).toBe('こんにちは')
+  })
+
+  it('should return empty string for only special characters', () => {
+    expect(slugify('!@#$%')).toBe('')
+  })
+
+  it('should handle numbers', () => {
+    expect(slugify('Chapter 1')).toBe('chapter-1')
+  })
+})
+
+describe('uniqueSlugify', () => {
+  it('should return base slug when no duplicates', () => {
+    const existing = new Set<string>()
+    expect(uniqueSlugify('Hello World', existing)).toBe('hello-world')
+  })
+
+  it('should add counter for duplicates', () => {
+    const existing = new Set(['hello-world'])
+    expect(uniqueSlugify('Hello World', existing)).toBe('hello-world-1')
+  })
+
+  it('should increment counter for multiple duplicates', () => {
+    const existing = new Set(['hello-world', 'hello-world-1', 'hello-world-2'])
+    expect(uniqueSlugify('Hello World', existing)).toBe('hello-world-3')
+  })
+
+  it('should add generated slug to existing set', () => {
+    const existing = new Set<string>()
+    uniqueSlugify('Hello World', existing)
+    expect(existing.has('hello-world')).toBe(true)
+  })
+})

package/packages/utils/__tests__/traverse.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi } from 'vitest'
+import { traverseAst, traverseAstWithCallbacks } from '../src/ast/traverse'
+import type { Root, Paragraph, Text, Heading } from 'mdast'
+
+describe('traverseAst', () => {
+  const createSimpleAst = (): Root => ({
+    type: 'root',
+    children: [
+      {
+        type: 'heading',
+        depth: 1,
+        children: [{ type: 'text', value: 'Title' }],
+      } as Heading,
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'Content' }],
+      } as Paragraph,
+    ],
+  })
+
+  it('should visit all nodes in depth-first order', () => {
+    const ast = createSimpleAst()
+    const visited: string[] = []
+
+    traverseAst(ast, (node) => {
+      visited.push(node.type)
+    })
+
+    expect(visited).toEqual(['root', 'heading', 'text', 'paragraph', 'text'])
+  })
+
+  it('should skip children when visitor returns false', () => {
+    const ast = createSimpleAst()
+    const visited: string[] = []
+
+    traverseAst(ast, (node) => {
+      visited.push(node.type)
+      if (node.type === 'heading') {
+        return false // Skip children of heading
+      }
+    })
+
+    expect(visited).toEqual(['root', 'heading', 'paragraph', 'text'])
+  })
+
+  it('should provide correct index and parent', () => {
+    const ast = createSimpleAst()
+    const visitor = vi.fn()
+
+    traverseAst(ast, visitor)
+
+    // Root has no index and no parent
+    expect(visitor).toHaveBeenNthCalledWith(1, ast, undefined, undefined)
+
+    // Heading is at index 0 with root as parent
+    expect(visitor).toHaveBeenNthCalledWith(2, ast.children[0], 0, ast)
+  })
+
+  it('should handle empty children', () => {
+    const ast: Root = {
+      type: 'root',
+      children: [],
+    }
+    const visited: string[] = []
+
+    traverseAst(ast, (node) => {
+      visited.push(node.type)
+    })
+
+    expect(visited).toEqual(['root'])
+  })
+})
+
+describe('traverseAstWithCallbacks', () => {
+  const createSimpleAst = (): Root => ({
+    type: 'root',
+    children: [
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'Hello' }],
+      } as Paragraph,
+    ],
+  })
+
+  it('should call enter and leave in correct order', () => {
+    const ast = createSimpleAst()
+    const events: string[] = []
+
+    traverseAstWithCallbacks(ast, {
+      enter: (node) => {
+        events.push(`enter:${node.type}`)
+      },
+      leave: (node) => {
+        events.push(`leave:${node.type}`)
+      },
+    })
+
+    expect(events).toEqual([
+      'enter:root',
+      'enter:paragraph',
+      'enter:text',
+      'leave:text',
+      'leave:paragraph',
+      'leave:root',
+    ])
+  })
+
+  it('should skip children when enter returns false', () => {
+    const ast = createSimpleAst()
+    const events: string[] = []
+
+    traverseAstWithCallbacks(ast, {
+      enter: (node) => {
+        events.push(`enter:${node.type}`)
+        if (node.type === 'paragraph') {
+          return false
+        }
+      },
+      leave: (node) => {
+        events.push(`leave:${node.type}`)
+      },
+    })
+
+    expect(events).toEqual([
+      'enter:root',
+      'enter:paragraph',
+      'leave:paragraph',
+      'leave:root',
+    ])
+  })
+})

package/packages/utils/dist/ast/query.d.ts

@@ -0,0 +1,36 @@
+import type { Node } from 'unist';
+import type { MdNode, Parent } from '../types';
+/**
+ * Find all nodes of a specific type in the AST
+ *
+ * @param node - Root node to search from
+ * @param type - Node type to find
+ * @returns Array of matching nodes
+ */
+export declare function findNodes<T extends Node = MdNode>(node: Node, type: string): T[];
+/**
+ * Find the first node of a specific type in the AST
+ *
+ * @param node - Root node to search from
+ * @param type - Node type to find
+ * @returns The first matching node or undefined
+ */
+export declare function findNode<T extends Node = MdNode>(node: Node, type: string): T | undefined;
+/**
+ * Find all nodes matching a predicate
+ *
+ * @param node - Root node to search from
+ * @param predicate - Function to test each node
+ * @returns Array of matching nodes
+ */
+export declare function findNodesBy<T extends Node = MdNode>(node: Node, predicate: (node: Node) => boolean): T[];
+/**
+ * Get the parent of a node in the AST
+ * Note: This requires traversing from root, use sparingly
+ *
+ * @param root - Root node of the AST
+ * @param target - Node to find parent of
+ * @returns Parent node or undefined if not found or is root
+ */
+export declare function findParent(root: Node, target: Node): Parent | undefined;
+//# sourceMappingURL=query.d.ts.map

package/packages/utils/dist/ast/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/ast/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AACjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAG9C;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,EAC/C,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,GACX,CAAC,EAAE,CAiBL;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,EAC9C,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,SAAS,CAsBf;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,EACjD,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACjC,CAAC,EAAE,CAiBL;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAsBvE"}

package/packages/utils/dist/ast/traverse.d.ts

@@ -0,0 +1,22 @@
+import type { Node } from 'unist';
+import type { MdNode, Visitor } from '../types';
+/**
+ * Traverse AST in depth-first order
+ *
+ * @param node - Root node to start traversal
+ * @param visitor - Visitor function called for each node
+ *                  Return `false` to skip children of current node
+ *                  Return `true` or `undefined` to continue
+ */
+export declare function traverseAst<T extends Node = MdNode>(node: T, visitor: Visitor<T>): void;
+/**
+ * Traverse AST with enter and leave callbacks
+ *
+ * @param node - Root node to start traversal
+ * @param callbacks - Object with optional enter and leave functions
+ */
+export declare function traverseAstWithCallbacks<T extends Node = MdNode>(node: T, callbacks: {
+    enter?: Visitor<T>;
+    leave?: Visitor<T>;
+}): void;
+//# sourceMappingURL=traverse.d.ts.map

package/packages/utils/dist/ast/traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../src/ast/traverse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AACjC,OAAO,KAAK,EAAU,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGvD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,EACjD,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAClB,IAAI,CAsBN;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,EAC9D,IAAI,EAAE,CAAC,EACP,SAAS,EAAE;IACT,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CACnB,GACA,IAAI,CAqBN"}