@primeui-devkit/markdown-core 0.1.0-rc.3 → 0.1.0-rc.5

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { ComarkElement as MarkdownElement, ComarkNode as MarkdownNode, ParseOptions as MarkdownParseOptions, ComarkParseFn as MarkdownParser, ComarkPlugin as MarkdownPlugin, NodeRenderData as MarkdownRenderData, ComarkTree as MarkdownTree, autoCloseMarkdown, createParse as createMarkdownParser, defineComarkPlugin as defineMarkdownPlugin, parseFrontmatter, parse as parseMarkdown } from 'comark';
+export { ElementNode as MarkdownElement, Node as MarkdownNode, ParserOptions as MarkdownParseOptions, ComarkParseFn as MarkdownParser, ComarkPlugin as MarkdownPlugin, NodeRenderData as MarkdownRenderData, MarkdownDocument as MarkdownTree, autoCloseMarkdown, createMarkdownParser, defineComarkPlugin as defineMarkdownPlugin, parseFrontmatter, parseMarkdown } from 'comark';
 export { pascalCase, resolveAttributes } from 'comark/utils';
 export { HeadingSection, TocItem, childrenOf, descriptionFromTree, headingSections, isElement, propsOf, tagOf, textOf, titleFromTree, tocFromTree, walkTree } from './tree.js';
+export { SanitizeOptions, componentMap, defaultAllowedProtocols, defaultBlockedTags, isPrototypeKey, isSafeAttribute, sanitizeOptions, sanitizeTree } from './plugins/sanitize.js';

package/dist/index.js

@@ -1 +1 @@
-import{childrenOf as e,descriptionFromTree as t,headingSections as n,isElement as r,propsOf as i,tagOf as a,textOf as o,titleFromTree as s,tocFromTree as c,walkTree as l}from"./tree.js";import{autoCloseMarkdown as u,createParse as d,defineComarkPlugin as f,parse as p,parseFrontmatter as m}from"comark";import{pascalCase as h,resolveAttributes as g}from"comark/utils";export{u as autoCloseMarkdown,e as childrenOf,d as createMarkdownParser,f as defineMarkdownPlugin,t as descriptionFromTree,n as headingSections,r as isElement,m as parseFrontmatter,p as parseMarkdown,h as pascalCase,i as propsOf,g as resolveAttributes,a as tagOf,o as textOf,s as titleFromTree,c as tocFromTree,l as walkTree};
+import{childrenOf as e,descriptionFromTree as t,headingSections as n,isElement as r,propsOf as i,tagOf as a,textOf as o,titleFromTree as s,tocFromTree as c,walkTree as l}from"./tree.js";import{componentMap as u,defaultAllowedProtocols as d,defaultBlockedTags as f,isPrototypeKey as p,isSafeAttribute as m,sanitizeOptions as h,sanitizeTree as g}from"./plugins/sanitize.js";import{autoCloseMarkdown as _,createMarkdownParser as v,defineComarkPlugin as y,parseFrontmatter as b,parseMarkdown as x}from"comark";import{pascalCase as S,resolveAttributes as C}from"comark/utils";export{_ as autoCloseMarkdown,e as childrenOf,u as componentMap,v as createMarkdownParser,d as defaultAllowedProtocols,f as defaultBlockedTags,y as defineMarkdownPlugin,t as descriptionFromTree,n as headingSections,r as isElement,p as isPrototypeKey,m as isSafeAttribute,b as parseFrontmatter,x as parseMarkdown,S as pascalCase,i as propsOf,C as resolveAttributes,h as sanitizeOptions,g as sanitizeTree,a as tagOf,o as textOf,s as titleFromTree,c as tocFromTree,l as walkTree};

package/dist/llms.d.ts

@@ -3,9 +3,9 @@ interface LlmsPage {
     route: string;
     /** Raw markdown source of the page. */
     markdown: string;
-    /** Optional explicit title; defaults to the first `# ` heading. */
+    /** Explicit title; defaults to the first `# ` heading. */
     title?: string;
-    /** Optional one-line description, appended to index links and full sections. */
+    /** One-line description, appended to index links and full sections. */
     description?: string;
 }
 interface LlmsIndexOptions {
@@ -15,11 +15,7 @@ interface LlmsIndexOptions {
     description?: string;
     /** Absolute origin used in links, e.g. 'https://vue.example.dev'. */
     siteUrl: string;
-    /**
-     * How each link points at a page, given its route:
-     * - 'page' (default): `${siteUrl}/${route}`
-     * - 'raw': `${siteUrl}/raw/${route}.md`
-     */
+    /** Link target: 'page' (default) is `${siteUrl}/${route}`, 'raw' is `${siteUrl}/raw/${route}.md`. */
     linkTarget?: 'page' | 'raw';
     /** Heading above the link list. @default 'Documentation' */
     heading?: string;
@@ -33,9 +29,9 @@ interface LlmsFullOptions {
     transform?: (page: LlmsPage) => string;
 }
 declare function pageTitle(page: LlmsPage): string;
-/** llms.txt — the index document: site summary plus one link per page. */
+/** Renders llms.txt: site summary plus one link per page. */
 declare function renderLlmsIndex(pages: LlmsPage[], options: LlmsIndexOptions): string;
-/** llms-full.txt — every page's markdown concatenated into one document. */
+/** Renders llms-full.txt: every page's markdown in one document. */
 declare function renderLlmsFull(pages: LlmsPage[], options: LlmsFullOptions): string;
 /** File plan for the raw markdown mirror: [route, content]. */
 declare function rawMarkdownFiles(pages: LlmsPage[], options?: {

package/dist/plugins/highlight.d.ts

@@ -1,30 +1,6 @@
-import { ComarkPlugin, ComarkTree } from 'comark';
+import { ComarkPlugin, MarkdownDocument } from 'comark';
 
-/**
- * NOTE ON THE OPTIONAL PEER — importing this subpath without `shiki` installed fails at
- * module load with `Cannot find package 'shiki'`, thrown from inside the backend rather
- * than from here. That cannot be caught: the failing import is the static one above, which
- * runs before any code in this file. Making it dynamic would push the cost onto every
- * caller and would still not help {@link default}, which is synchronous by contract.
- *
- * So the message stays as it is, and the requirement is documented instead: the README and
- * the package's `peerDependenciesMeta` both state that highlighting needs `shiki`.
- */
-/**
- * Syntax highlighting for code blocks.
- *
- * The options below are this package's own. The backend exposes the highlighting engine's
- * types directly — themes, language registrations, transformers — and re-exporting those
- * would tie every caller to that engine through a package whose whole purpose is to keep
- * it out of sight.
- */
-/**
- * A theme, either by name or as a full definition.
- *
- * The definition form is deliberately opaque: describing it would pull the highlighting
- * engine's types into this package's public surface, which is what it exists to avoid.
- * Pass the value a `shiki/themes/*` module default-exports.
- */
+/** A theme name, or a definition as a `shiki/themes/*` module default-exports. */
 type HighlightTheme = string | (object & {
     name?: string;
 });
@@ -33,27 +9,14 @@ type HighlightLanguage = object;
 /** A code-block transformer, as `@shikijs/transformers` returns. */
 type HighlightTransformer = object;
 interface HighlightOptions {
-    /**
-     * Themes to render with. Both are emitted, so a page can switch between light and dark
-     * without highlighting anything again.
-     *
-     * A registered name works, as does a theme definition — pass the latter to use a theme
-     * the backend does not ship. Names are checked first, because a name the backend does
-     * not know leaves every block unhighlighted without reporting anything.
-     */
+    /** Light and dark themes, both emitted. Unknown theme names throw. */
     themes?: {
         light: HighlightTheme;
         dark: HighlightTheme;
     };
-    /**
-     * Languages to preload. Left unset, languages load on demand, which needs the backend's
-     * full bundle; preloading keeps a build to the grammars it actually uses.
-     */
+    /** Languages to preload. Unset loads them on demand from the full bundle. */
     languages?: HighlightLanguage[];
-    /**
-     * Transformers applied to every block — line markers such as `[!code highlight]` come
-     * from these.
-     */
+    /** Transformers applied to every block, e.g. for `[!code highlight]` markers. */
     transformers?: HighlightTransformer[];
     /** Whether to inline the theme's background and colour on the block. Defaults to `false`. */
     inlineStyles?: boolean;
@@ -66,9 +29,7 @@ declare const defaultThemes: {
 /** Themes available without registering any of your own. */
 declare function availableThemes(): Promise<string[]>;
 /**
- * Highlight every code block in a parsed tree.
- *
- * Highlighting is asynchronous and happens after parsing, so it runs as its own step:
+ * Highlight every code block in a parsed tree, as an async step after parsing.
  *
  * @example
  * ```ts
@@ -79,14 +40,8 @@ declare function availableThemes(): Promise<string[]>;
  * const tree = await highlightTree(await parse(source));
  * ```
  */
-declare function highlightTree(tree: ComarkTree, options?: HighlightOptions): Promise<ComarkTree>;
-/**
- * The same highlighting as a parser plugin.
- *
- * Kept for parsers that drive the plugin pipeline themselves. Prefer {@link highlightTree}:
- * the plugin form marks blocks as highlighted without tokenising them, because tokenising
- * is asynchronous and the plugin hook is not.
- */
+declare function highlightTree(tree: MarkdownDocument, options?: HighlightOptions): Promise<MarkdownDocument>;
+/** Parser plugin form: tokenises every block while parsing. {@link highlightTree} does the same for a tree parsed earlier or cached. */
 declare function highlight(options?: HighlightOptions): ComarkPlugin<any, any>;
 
 export { availableThemes, highlight as default, defaultThemes, highlightTree };

package/dist/plugins/highlight.js

@@ -1 +1 @@
-import e,{getHighlighter as t,highlightCodeBlocks as n}from"comark/plugins/highlight";import{bundledThemes as r}from"shiki";const i=e=>e?[e.light,e.dark].filter(e=>typeof e==`string`):[],a={light:`material-theme-lighter`,dark:`material-theme-palenight`};async function o(){let e=await t();return[.../* @__PURE__ */ new Set([...Object.keys(r),...e.getLoadedThemes?.()??[]])]}async function s(e,t={}){let{themes:r,languages:a,transformers:s,inlineStyles:c=!1}=t,l=i(r);if(l.length>0){let e=await o(),t=l.filter(t=>!e.includes(t));if(t.length>0)throw Error(`Unknown theme${t.length>1?`s`:``}: ${t.join(`, `)}. Available: ${e.join(`, `)}.`)}return await n(e,{...r?{themes:r}:{},...a?{languages:a}:{},...s?{transformers:s}:{},preStyles:c})}function c(t={}){let{themes:n,languages:r,transformers:i,inlineStyles:a=!1}=t;return e({...n?{themes:n}:{},...r?{languages:r}:{},...i?{transformers:i}:{},preStyles:a})}export{o as availableThemes,c as default,a as defaultThemes,s as highlightTree};
+import e,{getHighlighter as t,highlightCodeBlocks as n}from"comark/plugins/shiki";import{bundledThemes as r}from"shiki";const i=e=>e?[e.light,e.dark].filter(e=>typeof e==`string`):[],a={light:`material-theme-lighter`,dark:`material-theme-palenight`};async function o(){let e=await t();return[.../* @__PURE__ */ new Set([...Object.keys(r),...e.getLoadedThemes?.()??[]])]}async function s(e,t={}){let{themes:r,languages:a,transformers:s,inlineStyles:c=!1}=t,l=i(r);if(l.length>0){let e=await o(),t=l.filter(t=>!e.includes(t));if(t.length>0)throw Error(`Unknown theme${t.length>1?`s`:``}: ${t.join(`, `)}. Available: ${e.join(`, `)}.`)}return await n(e,{...r?{themes:r}:{},...a?{languages:a}:{},...s?{transformers:s}:{},preStyles:c})}function c(t={}){let{themes:n,languages:r,transformers:i,inlineStyles:a=!1}=t;return e({...n?{themes:n}:{},...r?{languages:r}:{},...i?{transformers:i}:{},preStyles:a})}export{o as availableThemes,c as default,a as defaultThemes,s as highlightTree};

package/dist/plugins/sanitize.d.ts

@@ -0,0 +1,43 @@
+import * as comark from 'comark';
+import { Node } from 'comark';
+
+interface SanitizeOptions {
+    /** Tags removed with everything inside them, added to the default list. */
+    blockedTags?: string[];
+    /** Tags taken off the blocked list, e.g. `['iframe']` for embeds you trust or `['form', 'input', 'button']` for a form. */
+    allowedTags?: string[];
+    /**
+     * URL schemes allowed in links and sources. Relative URLs and `data:image/` image sources always pass.
+     * @default ['http', 'https', 'mailto', 'tel']
+     */
+    allowedProtocols?: string[];
+    /** Keeps every inline style. Off, a style keeps only colour and font declarations, which cannot move content or lay it over the page. @default false */
+    allowStyle?: boolean;
+    /** Components the `as` attribute may switch an element to; any other `as` is removed. @default [] */
+    allowedComponents?: string[];
+}
+/** Elements that run code, load another document, change how the page resolves URLs, or submit or capture input. */
+declare const defaultBlockedTags: string[];
+declare const defaultAllowedProtocols: string[];
+/** Whether a name would read Object.prototype from a plain object, `constructor` and `toString` among them. */
+declare function isPrototypeKey(name: string): boolean;
+/** Whether an attribute is safe to write: a plain name, not an event handler, not HTML, not a style unless allowed, not a URL outside `allowedProtocols`. A binding counts only when it is a literal. */
+declare function isSafeAttribute(tag: string, key: string, value: unknown, options?: SanitizeOptions): boolean;
+/** A copy of the tree with what would run script, submit a form, restyle the page or swap in another component removed; for a tree that did not come through the plugin. */
+declare function sanitizeTree<T extends {
+    nodes: Node[];
+}>(tree: T, options?: SanitizeOptions): T;
+/** The `sanitize` option every renderer takes, as options to pass on, or `false` when it is off. Unset means on. */
+declare function sanitizeOptions(setting: boolean | SanitizeOptions | undefined): SanitizeOptions | false;
+/** A component map whose lookups never reach Object.prototype, so a `::constructor` node renders as an element, not as `Object`. */
+/**
+ * Whether a component registered app-wide may render a markdown tag. `Prose*` components restyle the elements sanitizing
+ * already allowed, so they always may; any other one only when sanitizing is off or `allowedComponents` names it.
+ */
+declare function allowsGlobalComponent(setting: boolean | SanitizeOptions | undefined, name: string): boolean;
+declare function componentMap<T>(components: Record<string, T> | null | undefined): Record<string, T>;
+/** Removes blocked elements, event handler, HTML and style attributes, unlisted `as` targets and disallowed URL schemes. Use for untrusted markdown; add it last so it sees what other plugins add. */
+declare const _default: comark.ComarkPluginFactory<SanitizeOptions, {}, {}>;
+
+export { allowsGlobalComponent, componentMap, _default as default, defaultAllowedProtocols, defaultBlockedTags, isPrototypeKey, isSafeAttribute, sanitizeOptions, sanitizeTree };
+export type { SanitizeOptions };

package/dist/plugins/sanitize.js

@@ -0,0 +1 @@
+import{defineComarkPlugin as e}from"comark";const t=[`script`,`style`,`iframe`,`frame`,`frameset`,`object`,`embed`,`applet`,`portal`,`base`,`meta`,`link`,`animate`,`animatemotion`,`animatetransform`,`animatecolor`,`set`,`handler`,`listener`,`form`,`input`,`button`,`textarea`,`select`],n=[`http`,`https`,`mailto`,`tel`],r=/^[a-z_][a-z0-9_.:-]*$/i,i=/^[a-z][a-z0-9_.:-]*$/i,a=/* @__PURE__ */ new Set([`innerhtml`,`outerhtml`,`dangerouslysetinnerhtml`,`srcdoc`]),o=/* @__PURE__ */ new Set([`href`,`src`,`action`,`formaction`,`xlink:href`,`xlinkhref`,`poster`,`background`,`cite`,`data`,`ping`,`lowsrc`,`dynsrc`,`longdesc`,`to`,`url`]),s=/^(?:color|background-color|font-style|font-weight|text-align|text-decoration(?:-line|-color|-style)?|--shiki-[a-z0-9-]+)$/,c=/^[\w\s#%.,()+-]+$/,l=/* @__PURE__ */ new Set([`__proto__`,`constructor`,`prototype`]);function u(e){return Object.prototype.hasOwnProperty.call(Object.prototype,e)}function d(e){return/^on[a-z]+$/.test(e.toLowerCase())||/^on[^a-z]/.test(e)}function f(e){return Number.isInteger(e)&&e>0&&e<=1114111&&(e<55296||e>57343)?String.fromCodePoint(e):`�`}function p(e){return e.replace(/&#x([0-9a-f]+);?/gi,(e,t)=>f(Number.parseInt(t,16))).replace(/&#(\d+);?/g,(e,t)=>f(Number(t))).replace(/&colon;?/gi,`:`).replace(/&tab;?|&newline;?/gi,``).replace(/[\u0000- \u007f-\u009f]/g,``).toLowerCase()}function m(e,t,n,r){let i=p(e),a=/^([a-z][a-z0-9+.-]*):/.exec(i)?.[1];return!a||r.has(a)?!0:a===`data`&&t===`src`&&n===`img`&&i.startsWith(`data:image/`)}const h=e=>e.replace(/[-_]/g,``).toLowerCase();function g(e={}){let r=new Set((e.allowedTags??[]).map(e=>e.toLowerCase()));return{blocked:new Set([...t,...e.blockedTags??[]].map(e=>e.toLowerCase()).filter(e=>!r.has(e))),allowedProtocols:new Set((e.allowedProtocols??n).map(e=>e.toLowerCase().replace(/:$/,``))),allowStyle:e.allowStyle===!0,allowedComponents:new Set((e.allowedComponents??[]).map(h))}}const _=(e,t)=>s.test(e.toLowerCase())&&c.test(t)&&!/url\(|expression|image/i.test(t);function v(e){if(typeof e==`string`){let t=e.split(`;`).map(e=>/^([-a-z0-9]+)\s*:([\s\S]*)$/i.exec(e.trim())).filter(e=>e!==null&&_(e[1],e[2].trim())).map(([,e,t])=>`${e}:${t.trim()}`);return t.length?t.join(`;`):void 0}if(e&&typeof e==`object`&&!Array.isArray(e)){let t=Object.entries(e).filter(([e,t])=>(typeof t==`string`||typeof t==`number`)&&_(e.replace(/[A-Z]/g,e=>`-${e.toLowerCase()}`),String(t)));return t.length?Object.fromEntries(t):void 0}}const y=Symbol(`unknown`);function b(e,t){if(typeof e!=`string`)return e;try{return JSON.parse(e)}catch{}let[n,...r]=e.split(`.`);if(!t||n!==`frontmatter`&&n!==`meta`||r.some(e=>l.has(e)))return y;let i=t[n];for(let e of r){if(!i||typeof i!=`object`||!Object.hasOwn(i,e))return;i=i[e]}return i}function x(e,t){return typeof e==`string`&&!u(e)&&t.allowedComponents.has(h(e))}function S(e,t,n,i,s){let c=t.startsWith(`:`),u=c?t.slice(1):t,f=u.toLowerCase();if(!r.test(u)||d(u)||a.has(f))return;if(f===`style`&&!i.allowStyle){let e=v(c?b(n,s):n);return e===void 0?void 0:c?[t,JSON.stringify(e)]:[t,e]}if((!o.has(f)||f===`data`&&e!==`object`)&&f!==`as`)return c&&typeof n==`string`&&n.split(`.`).some(e=>l.has(e))?void 0:[t,n];let p=c?b(n,s):n;if(p!==y&&typeof p==`string`&&!(f===`as`?!x(p,i):!m(p,f,e,i.allowedProtocols)))return c?[t,JSON.stringify(p)]:[t,n]}function C(e,t,n,r={}){return t===`$`||S(e.toLowerCase(),t,n,g(r))!==void 0}function w(e){let t=`:disabled`in e?e[`:disabled`]===`true`||e[`:disabled`]===!0:e.disabled===``||e.disabled===!0||e.disabled===`disabled`||e.disabled===`true`;return e.type===`checkbox`&&!(`:type`in e)&&t}function T(e,t,n,r){let i={};for(let[a,o]of Object.entries(t)){let t=a===`$`?[a,o]:S(e,a,o,n,r);t&&(i[t[0]]=t[1])}return i}function E(e,t,n){if(!Array.isArray(e))return typeof e==`string`?e:void 0;let[r,a,...o]=e;if(r===null)return e;if(typeof r!=`string`||!i.test(r)||u(r))return;let s=r.toLowerCase(),c=a&&typeof a==`object`?a:{};if(t.blocked.has(s)&&!(s===`input`&&w(c)))return;let l=o.map(e=>E(e,t,n)).filter(e=>e!==void 0);return[r,T(s,c,t,n),...l]}function D(e,t={}){let n=g(t),r=e,i={frontmatter:r.frontmatter??r.data??{},meta:r.meta??{}};return{...e,nodes:(e.nodes??[]).map(e=>E(e,n,i)).filter(e=>e!==void 0)}}function O(e){return e===!1?!1:typeof e==`object`&&e?e:{}}function k(e,t){let n=O(e);return n===!1||/^prose[-_]?/i.test(t)?!0:!u(t)&&g(n).allowedComponents.has(h(t))}function A(e){let t=Object.create(null);for(let e of Object.getOwnPropertyNames(Object.prototype))t[e]=void 0;return Object.assign(t,e??{})}var j=e((e={})=>({name:`primeui:sanitize`,post(t){t.tree.nodes=D(t.tree,e).nodes}}));export{k as allowsGlobalComponent,A as componentMap,j as default,n as defaultAllowedProtocols,t as defaultBlockedTags,u as isPrototypeKey,C as isSafeAttribute,O as sanitizeOptions,D as sanitizeTree};

package/dist/preset.d.ts

@@ -1,12 +1,7 @@
 import { ComarkPlugin, ComarkParseFn } from 'comark';
+import { SanitizeOptions } from './plugins/sanitize.js';
 
-/**
- * Options handed to the parser underneath.
- *
- * Deliberately loose: the parsing backend accepts more than this preset models, and
- * naming its option type here would put its full schema — and its name — into a public
- * signature. Anything valid for the backend passes through.
- */
+/** Options passed through to the underlying parser, kept loose so the backend type stays private. */
 type ParserPassthrough = Record<string, unknown>;
 interface DocsParserOptions {
     /** Heading ids for anchors. @default true */
@@ -17,16 +12,14 @@ interface DocsParserOptions {
     alert?: boolean;
     /** {{ binding }} interpolation. @default true */
     binding?: boolean;
-    /** Extra plugins — e.g. a configured highlight plugin from ./plugins/highlight. */
+    /** Extra plugins, e.g. a configured highlight plugin from ./plugins/highlight. */
     plugins?: ComarkPlugin<any, any>[];
+    /** Strips script, event handlers, styles, form controls and unsafe URLs after every other plugin. Disable only for trusted markdown. @default true */
+    sanitize?: boolean | SanitizeOptions;
     /** Options forwarded to the underlying parser. Plugins are set by this preset. */
     parse?: ParserPassthrough;
 }
-/**
- * Docs-flavored parser preset: the plugin set every showcase/docs app needs,
- * assembled once. Syntax highlighting is intentionally NOT bundled — shiki is
- * heavy and optional; pass a configured highlight plugin via `plugins`.
- */
+/** Docs parser preset. Highlighting is not bundled; pass a configured highlight plugin via `plugins`. */
 declare function createDocsParser(options?: DocsParserOptions): ComarkParseFn<any, any>;
 
 export { createDocsParser };

package/dist/preset.js

@@ -1 +1 @@
-import{createParse as e}from"comark";import t from"comark/plugins/alert";import n from"comark/plugins/binding";import r from"comark/plugins/headings";import i from"comark/plugins/toc";function a(a={}){let o=[];return a.headings!==!1&&o.push(r()),a.toc!==!1&&o.push(i()),a.alert!==!1&&o.push(t()),a.binding!==!1&&o.push(n()),a.plugins&&o.push(...a.plugins),e({...a.parse,plugins:o})}export{a as createDocsParser};
+import e,{sanitizeOptions as t}from"./plugins/sanitize.js";import{createMarkdownParser as n}from"comark";import r from"comark/plugins/alert";import i from"comark/plugins/binding";import a from"comark/plugins/headings";import o from"comark/plugins/toc";function s(s={}){let c=[];s.headings!==!1&&c.push(a()),s.toc!==!1&&c.push(o()),s.alert!==!1&&c.push(r()),s.binding!==!1&&c.push(i()),s.plugins&&c.push(...s.plugins);let l=t(s.sanitize);return l&&c.push(e(l)),n({...s.parse,plugins:c})}export{s as createDocsParser};

package/dist/search.d.ts

@@ -1,9 +1,9 @@
-import { ComarkTree } from 'comark';
+import { MarkdownDocument } from 'comark';
 
 interface SearchPage {
     /** Route of the page, e.g. '/charts/animation'. */
     route: string;
-    tree: ComarkTree;
+    tree: MarkdownDocument;
 }
 interface SearchDocument {
     /** Route plus anchor, e.g. '/charts/animation#easing'. */
@@ -13,18 +13,9 @@ interface SearchDocument {
     heading: string;
     text: string;
 }
-/**
- * Flattens parsed pages into heading-level search documents. The output is
- * plain JSON: ship it to the client for local search, hand it to Algolia, or
- * serve it to agents — same records everywhere.
- */
+/** Flattens parsed pages into heading-level search documents as plain JSON. */
 declare function buildSearchIndex(pages: SearchPage[]): SearchDocument[];
-/**
- * Dependency-free local search over an index: case-insensitive, every term
- * must match, heading/title hits outrank body hits. Good enough for docs-size
- * indexes; swap in Algolia or MiniSearch behind the same SearchDocument shape
- * when the corpus outgrows it.
- */
+/** Case-insensitive local search; every term must match, heading hits rank above body hits. */
 declare function searchDocuments(index: SearchDocument[], query: string, limit?: number): SearchDocument[];
 
 export { buildSearchIndex, searchDocuments };

package/dist/tree.d.ts

@@ -1,5 +1,4 @@
-import { ComarkElement, ComarkNode, ComarkTree } from 'comark';
-import 'comark/utils';
+import { ElementNode, Node, MarkdownDocument } from 'comark';
 
 interface TocItem {
     id: string;
@@ -8,22 +7,19 @@ interface TocItem {
     children?: TocItem[];
 }
 /** Table of contents produced by the toc plugin, normalized to a plain array. */
-declare function tocFromTree(tree: ComarkTree | null | undefined): TocItem[];
+declare function tocFromTree(tree: MarkdownDocument | null | undefined): TocItem[];
 /** Page title: frontmatter wins, then the title the parser derived from the first heading. */
-declare function titleFromTree(tree: ComarkTree | null | undefined): string;
+declare function titleFromTree(tree: MarkdownDocument | null | undefined): string;
 /** Page description from frontmatter, when present. */
-declare function descriptionFromTree(tree: ComarkTree | null | undefined): string;
-declare function isElement(node: ComarkNode): node is ComarkElement;
-declare function tagOf(node: ComarkElement): string;
-declare function propsOf(node: ComarkElement): Record<string, unknown>;
-declare function childrenOf(node: ComarkElement): ComarkNode[];
-/**
- * Depth-first walk over every node in the tree. Return `false` from the
- * visitor to skip a node's children.
- */
-declare function walkTree(tree: ComarkTree, visit: (node: ComarkNode, parent: ComarkElement | null) => void | boolean): void;
-/** Plain-text content of a node (or node list) — markup and components stripped. */
-declare function textOf(node: ComarkNode | ComarkNode[]): string;
+declare function descriptionFromTree(tree: MarkdownDocument | null | undefined): string;
+declare function isElement(node: Node): node is ElementNode;
+declare function tagOf(node: ElementNode): string;
+declare function propsOf(node: ElementNode): Record<string, unknown>;
+declare function childrenOf(node: ElementNode): Node[];
+/** Depth-first walk; return `false` from the visitor to skip a node's children. */
+declare function walkTree(tree: MarkdownDocument, visit: (node: Node, parent: ElementNode | null) => void | boolean): void;
+/** Plain-text content of a node or node list, markup stripped. */
+declare function textOf(node: Node | Node[]): string;
 interface HeadingSection {
     /** Heading id (anchor target); empty for content before the first heading. */
     id: string;
@@ -34,12 +30,8 @@ interface HeadingSection {
     /** Plain text of everything under this heading, code blocks excluded. */
     text: string;
 }
-/**
- * Splits a page into heading-anchored sections of plain text — the natural
- * unit for search indexing and llms excerpts. Code blocks are excluded so
- * indexes stay prose-focused.
- */
-declare function headingSections(tree: ComarkTree): HeadingSection[];
+/** Splits a page into heading-anchored plain-text sections, code blocks excluded. */
+declare function headingSections(tree: MarkdownDocument): HeadingSection[];
 
 export { childrenOf, descriptionFromTree, headingSections, isElement, propsOf, tagOf, textOf, titleFromTree, tocFromTree, walkTree };
 export type { HeadingSection, TocItem };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primeui-devkit/markdown-core",
-  "version": "0.1.0-rc.3",
+  "version": "0.1.0-rc.5",
   "author": "PrimeTek Informatics",
   "description": "Framework-agnostic markdown engine. Parses markdown with component directives into a serializable tree consumed by the framework renderers. The parsing backend is an internal implementation detail.",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -87,7 +87,7 @@
     "README.md"
   ],
   "dependencies": {
-    "comark": "^0.5.1"
+    "comark": "0.7.0"
   },
   "peerDependencies": {
     "shiki": "^4.4.2"
@@ -102,10 +102,10 @@
     "cross-env": "^10.1.0",
     "typescript": "~6.0.0",
     "vitest": "4.1.11",
-    "@primeui-devkit/bundle": "0.1.0-rc.1",
-    "@primeui-devkit/cli": "0.1.0-rc.1",
-    "@primeui-devkit/test-config": "0.1.0-rc.1",
-    "@primeui-devkit/ts-config": "0.1.0-rc.1"
+    "@primeui-devkit/bundle": "0.1.0-rc.2",
+    "@primeui-devkit/cli": "0.1.0-rc.2",
+    "@primeui-devkit/test-config": "0.1.0-rc.2",
+    "@primeui-devkit/ts-config": "0.1.0-rc.2"
   },
   "engines": {
     "node": ">=22.18.0"