@primeui-devkit/markdown-core 0.1.0-beta.1

package/LICENSE.md

@@ -0,0 +1,45 @@
+# PrimeUI License
+
+This package is part of **PrimeUI**, a family of commercial UI libraries by PrimeTek Informatics.
+
+## How PrimeUI May Be Used
+
+PrimeUI may be used under one of two licenses. You choose the one that applies to you based on eligibility.
+
+### Community License (Free)
+
+Free for organizations that meet all of the following criteria:
+
+- Less than $1,000,000 USD in annual gross revenue
+- Fewer than 5 developers
+- Fewer than 10 employees
+- Less than $3,000,000 USD in venture capital or outside funding
+
+Individuals, students, non-profits, and non-commercial open source projects also qualify.
+
+The Community License provides full access to the core libraries and supports up to 4 developers. It requires annual renewal by confirming continued eligibility.
+
+### Commercial License (Paid)
+
+For organizations that do not qualify for the Community License.
+
+Licensed per developer, perpetual, with one year of updates included. Renewal is optional and extends access to new versions. The Commercial Suite also includes PrimeBlocks, Theme Designer, all PrimeUI Pro components, and Premium Support.
+
+## License Key
+
+A valid license key is required to use this software. License verification is performed offline, with no telemetry and no remote connection. A missing, invalid, or expired key may cause the software to display a license notice.
+
+## Full Terms
+
+The complete license terms, eligibility details, and renewal information are available at:
+
+- Community License: <https://primeui.dev/licenses/community>
+- Commercial License: <https://primeui.dev/licenses/commercial>
+
+## Restrictions
+
+This software is distributed as a compiled package. You may not reverse-engineer, decompile, or extract its source code, redistribute it as a component library or development tool, or remove its license mechanisms. Redistributing the software so that third parties can develop with it requires a separate OEM License. See the full terms for details.
+
+---
+
+© 2026 PrimeTek Informatics. All rights reserved.

package/README.md

@@ -0,0 +1,78 @@
+# @primeui-devkit/markdown-core
+
+Framework-agnostic markdown engine. Parses markdown with component directives
+(`::name{props}`) into a serializable AST that every `*-markdown` renderer consumes.
+
+```ts
+import { createDocsParser } from '@primeui-devkit/markdown-core/preset';
+
+const parse = createDocsParser(); // headings + toc + alert + binding
+const tree = await parse('# Hello\n\n::demo-viewer{name="basic"}\n::');
+// the tree is plain JSON — cacheable, serializable, consumable by any renderer
+```
+
+Parsing is asynchronous — plugins may load resources — so the result has to be awaited
+before any of the tree helpers below will accept it.
+
+Lower-level API: `createMarkdownParser`, `parseMarkdown`, `defineMarkdownPlugin`.
+Optional plugins as subpaths: `./plugins/{headings,toc,highlight,alert,binding}`
+(highlight needs the optional `shiki` peer).
+
+Types: `MarkdownTree`, `MarkdownNode`, `MarkdownElement`, `MarkdownPlugin`, `MarkdownParser`.
+
+## Syntax highlighting
+
+The preset deliberately leaves highlighting out. A highlighter is heavy and not every page
+needs one, so it ships as an optional peer:
+
+```bash
+pnpm add shiki
+```
+
+Install it before importing `./plugins/highlight`. Without it that import fails while the
+module is still loading, with `Cannot find package 'shiki'` raised from inside the parsing
+backend — the message names neither this package nor the missing peer, and no `try` around
+the import can catch it.
+
+Highlighting is asynchronous, so it runs as its own step after parsing rather than inside
+it:
+
+```ts
+import { createDocsParser } from '@primeui-devkit/markdown-core/preset';
+import { highlightTree } from '@primeui-devkit/markdown-core/plugins/highlight';
+
+const parse = createDocsParser();
+const tree = await highlightTree(await parse(source));
+```
+
+Both themes are emitted at once, so a page switches between light and dark without
+highlighting anything again.
+
+Only registered themes work. Passing a name the backend does not know produces
+unhighlighted output without reporting anything, so `highlightTree` checks first and
+throws with the list of what is available — `availableThemes()` returns the same list.
+
+```ts
+await highlightTree(tree, { themes: { light: 'material-theme-lighter', dark: 'material-theme-palenight' } });
+```
+
+`@primeui-devkit/highlighter` is a separate package for highlighting a standalone snippet
+to HTML. Neither depends on the other: this one works on a parsed tree, that one on a
+string, and a repository takes whichever it needs.
+
+## Content utilities
+
+Parser-free subpaths for tooling and pipelines — usable in Node scripts, build
+steps, and browsers without pulling the engine in:
+
+- `./tree` — `tocFromTree`, `titleFromTree`, `descriptionFromTree`, `walkTree`, `textOf`, `headingSections`, node helpers (`isElement`, `tagOf`, `propsOf`, `childrenOf`)
+- `./search` — `buildSearchIndex(pages)` → heading-level `SearchDocument[]` (feed a local search, Algolia, or an agent) and `searchDocuments(index, query)` — a dependency-free scorer for docs-sized corpora
+- `./llms` — `renderLlmsIndex`, `renderLlmsFull`, `rawMarkdownFiles` for llms.txt pipelines
+
+```ts
+import { buildSearchIndex } from '@primeui-devkit/markdown-core/search';
+import { renderLlmsIndex } from '@primeui-devkit/markdown-core/llms';
+
+const index = buildSearchIndex(pages.map((p) => ({ route: p.route, tree: p.tree })));
+const llms = renderLlmsIndex(pages, { title: 'Docs', siteUrl: 'https://docs.example.dev' });
+```

package/THIRD-PARTY-NOTICES.txt

@@ -0,0 +1,36 @@
+# Third-Party Notices
+
+This package uses the following third-party open source software.
+Each is provided under its own license, reproduced below.
+
+---
+
+## comark
+
+Copyright (c) 2026 Comark team and contributors
+
+The markdown parsing engine used by this package (https://github.com/comarkdown/comark).
+
+Licensed under the MIT License.
+
+MIT License
+
+Copyright (c) 2026 Comark team and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+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 { pascalCase, resolveAttributes } from 'comark/utils';
+export { HeadingSection, TocItem, childrenOf, descriptionFromTree, headingSections, isElement, propsOf, tagOf, textOf, titleFromTree, tocFromTree, walkTree } from './tree.js';

package/dist/index.js

@@ -0,0 +1 @@
+export{autoCloseMarkdown,createParse as createMarkdownParser,defineComarkPlugin as defineMarkdownPlugin,parseFrontmatter,parse as parseMarkdown}from'comark';export{pascalCase,resolveAttributes}from'comark/utils';function u(e){return e?.meta?.toc?.links??[]}function f(e){return String(e?.frontmatter?.title??e?.meta?.title??"")}function l(e){return String(e?.frontmatter?.description??"")}function a(e){return Array.isArray(e)}function d(e){return e[0]}function m(e){return e[1]??{}}function s(e){return e.slice(2)}function w(e,t){let n=(r,o)=>{if(!(t(r,o)===false||!a(r)))for(let k of s(r))n(k,r);};for(let r of e.nodes??[])n(r,null);}function i(e){return typeof e=="string"?e:Array.isArray(e)&&typeof e[0]!="string"?e.map(t=>i(t)).join(""):a(e)?s(e).map(t=>i(t)).join(""):""}var c=new Set(["h1","h2","h3","h4","h5","h6"]);function p(e){let t=[],n={id:"",heading:"",depth:0,text:""};for(let r of e.nodes??[]){if(a(r)&&c.has(d(r))){(n.text.trim()||n.heading)&&t.push(n),n={id:String(m(r).id??""),heading:i(r),depth:Number(d(r).slice(1)),text:""};continue}if(a(r)&&d(r)==="pre")continue;let o=i(r).trim();o&&(n.text+=(n.text?" ":"")+o);}return (n.text.trim()||n.heading)&&t.push(n),t}export{s as childrenOf,l as descriptionFromTree,p as headingSections,a as isElement,m as propsOf,d as tagOf,i as textOf,f as titleFromTree,u as tocFromTree,w as walkTree};

package/dist/llms.d.ts

@@ -0,0 +1,45 @@
+interface LlmsPage {
+    /** Route/slug of the page, e.g. 'charts/animation' (no leading slash needed). */
+    route: string;
+    /** Raw markdown source of the page. */
+    markdown: string;
+    /** Optional explicit title; defaults to the first `# ` heading. */
+    title?: string;
+    /** Optional one-line description, appended to index links and full sections. */
+    description?: string;
+}
+interface LlmsIndexOptions {
+    /** Site title placed at the top of llms.txt. */
+    title: string;
+    /** One-line site description for the `>` summary. */
+    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`
+     */
+    linkTarget?: 'page' | 'raw';
+    /** Heading above the link list. @default 'Documentation' */
+    heading?: string;
+}
+interface LlmsFullOptions {
+    /** Title placed at the top of llms-full.txt. */
+    title: string;
+    /** One-line description under the title. */
+    description?: string;
+    /** Rewrite a page's markdown before concatenation (e.g. expand demo tags). */
+    transform?: (page: LlmsPage) => string;
+}
+declare function pageTitle(page: LlmsPage): string;
+/** llms.txt — the index document: 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. */
+declare function renderLlmsFull(pages: LlmsPage[], options: LlmsFullOptions): string;
+/** File plan for the raw markdown mirror: [route, content]. */
+declare function rawMarkdownFiles(pages: LlmsPage[], options?: {
+    transform?: (page: LlmsPage) => string;
+}): Array<[string, string]>;
+
+export { type LlmsFullOptions, type LlmsIndexOptions, type LlmsPage, pageTitle, rawMarkdownFiles, renderLlmsFull, renderLlmsIndex };

package/dist/llms.js

@@ -0,0 +1,9 @@
+function i(t){return t.title??t.markdown.match(/^#\s+(.+)$/m)?.[1]??t.route}function l(t,r){let e=t.route.replace(/^\//,"");return r.linkTarget==="raw"?`${r.siteUrl}/raw/${e}.md`:`${r.siteUrl}/${e}`}function a(t,r){return [`# ${r.title}`,"",`> ${r.description??""}`,"",`## ${r.heading??"Documentation"}`,...t.map(n=>`- [${i(n)}](${l(n,r)})${n.description?`: ${n.description}`:""}`)].join(`
+`)}function m(t,r){return [`# ${r.title}`,"",`> ${r.description??""}`,"",...t.map(n=>{let s=r.transform?r.transform(n):n.markdown.trim();return `## ${i(n)}
+
+${n.description?`${n.description}
+
+`:""}${s}`})].join(`
+
+`)}function o(t,r){return t.map(e=>[e.route.replace(/^\//,""),r?.transform?r.transform(e):e.markdown])}
+export{i as pageTitle,o as rawMarkdownFiles,m as renderLlmsFull,a as renderLlmsIndex};

package/dist/plugins/alert.d.ts

@@ -0,0 +1,5 @@
+export * from 'comark/plugins/alert';
+export { default } from 'comark/plugins/alert';
+import 'comark/plugins/binding';
+import 'comark/plugins/headings';
+import 'comark/plugins/toc';

package/dist/plugins/alert.js

@@ -0,0 +1 @@
+export*from'comark/plugins/alert';export{default}from'comark/plugins/alert';

package/dist/plugins/binding.d.ts

@@ -0,0 +1,2 @@
+export * from 'comark/plugins/binding';
+export { default } from 'comark/plugins/binding';

package/dist/plugins/binding.js

@@ -0,0 +1 @@
+export*from'comark/plugins/binding';export{default}from'comark/plugins/binding';

package/dist/plugins/headings.d.ts

@@ -0,0 +1,2 @@
+export * from 'comark/plugins/headings';
+export { default } from 'comark/plugins/headings';

package/dist/plugins/headings.js

@@ -0,0 +1 @@
+export*from'comark/plugins/headings';export{default}from'comark/plugins/headings';

package/dist/plugins/highlight.d.ts

@@ -0,0 +1,67 @@
+import { ComarkPlugin, ComarkTree } 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.
+ */
+interface HighlightOptions {
+    /**
+     * Themes to render with. Both are emitted, so a page can switch between light and dark
+     * without highlighting anything again.
+     *
+     * Only registered themes work. A name the backend does not know leaves every block
+     * unhighlighted without reporting anything, so {@link highlightTree} checks first.
+     */
+    themes?: {
+        light: string;
+        dark: string;
+    };
+    /** Whether to inline the theme's background and colour on the block. Defaults to `false`. */
+    inlineStyles?: boolean;
+}
+/** Themes the backend registers by default. */
+declare const defaultThemes: {
+    readonly light: "material-theme-lighter";
+    readonly dark: "material-theme-palenight";
+};
+/** 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:
+ *
+ * @example
+ * ```ts
+ * import { createDocsParser } from '@primeui-devkit/markdown-core/preset';
+ * import { highlightTree } from '@primeui-devkit/markdown-core/plugins/highlight';
+ *
+ * const parse = createDocsParser();
+ * 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 highlight(options?: HighlightOptions): ComarkPlugin<any, any>;
+
+export { type HighlightOptions, availableThemes, highlight as default, defaultThemes, highlightTree };

package/dist/plugins/highlight.js

@@ -0,0 +1 @@
+import s,{getHighlighter,highlightCodeBlocks}from'comark/plugins/highlight';var c={light:"material-theme-lighter",dark:"material-theme-palenight"};async function g(){return (await getHighlighter()).getLoadedThemes?.()??[]}async function p(t,i={}){let{themes:e,inlineStyles:a=false}=i;if(e){let r=await g(),n=[e.light,e.dark].filter(l=>!r.includes(l));if(n.length>0)throw new Error(`Unknown theme${n.length>1?"s":""}: ${n.join(", ")}. Available: ${r.join(", ")}.`)}return await highlightCodeBlocks(t,{...e?{themes:e}:{},preStyles:a})}function m(t={}){let{themes:i,inlineStyles:e=false}=t;return s({...i?{themes:i}:{},preStyles:e})}export{g as availableThemes,m as default,c as defaultThemes,p as highlightTree};

package/dist/plugins/toc.d.ts

@@ -0,0 +1,2 @@
+export * from 'comark/plugins/toc';
+export { default } from 'comark/plugins/toc';

package/dist/plugins/toc.js

@@ -0,0 +1 @@
+export*from'comark/plugins/toc';export{default}from'comark/plugins/toc';

package/dist/preset.d.ts

@@ -0,0 +1,32 @@
+import { ComarkPlugin, ComarkParseFn } from 'comark';
+
+/**
+ * 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.
+ */
+type ParserPassthrough = Record<string, unknown>;
+interface DocsParserOptions {
+    /** Heading ids for anchors. @default true */
+    headings?: boolean;
+    /** Table of contents in tree.meta.toc. @default true */
+    toc?: boolean;
+    /** ::alert containers. @default true */
+    alert?: boolean;
+    /** {{ binding }} interpolation. @default true */
+    binding?: boolean;
+    /** Extra plugins — e.g. a configured highlight plugin from ./plugins/highlight. */
+    plugins?: ComarkPlugin<any, any>[];
+    /** 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`.
+ */
+declare function createDocsParser(options?: DocsParserOptions): ComarkParseFn<any, any>;
+
+export { type DocsParserOptions, type ParserPassthrough, createDocsParser };

package/dist/preset.js

@@ -0,0 +1 @@
+import {createParse}from'comark';import e from'comark/plugins/alert';import o from'comark/plugins/binding';import s from'comark/plugins/headings';import i from'comark/plugins/toc';function g(r={}){let a=[];return r.headings!==false&&a.push(s()),r.toc!==false&&a.push(i()),r.alert!==false&&a.push(e()),r.binding!==false&&a.push(o()),r.plugins&&a.push(...r.plugins),createParse({...r.parse,plugins:a})}export{g as createDocsParser};

package/dist/prose.d.ts

@@ -0,0 +1,4 @@
+declare const PROSE_COMPONENTS: readonly ["ProseA", "ProseBlockquote", "ProseCode", "ProseEm", "ProseH1", "ProseH2", "ProseH3", "ProseH4", "ProseH5", "ProseH6", "ProseHr", "ProseImg", "ProseLi", "ProseOl", "ProseP", "ProsePre", "ProseStrong", "ProseTable", "ProseTbody", "ProseTd", "ProseTh", "ProseThead", "ProseTr", "ProseUl"];
+type ProseComponentName = (typeof PROSE_COMPONENTS)[number];
+
+export { PROSE_COMPONENTS, type ProseComponentName };

package/dist/prose.js

@@ -0,0 +1 @@
+var e=["ProseA","ProseBlockquote","ProseCode","ProseEm","ProseH1","ProseH2","ProseH3","ProseH4","ProseH5","ProseH6","ProseHr","ProseImg","ProseLi","ProseOl","ProseP","ProsePre","ProseStrong","ProseTable","ProseTbody","ProseTd","ProseTh","ProseThead","ProseTr","ProseUl"];export{e as PROSE_COMPONENTS};

package/dist/search.d.ts

@@ -0,0 +1,30 @@
+import { ComarkTree } from 'comark';
+
+interface SearchPage {
+    /** Route of the page, e.g. '/charts/animation'. */
+    route: string;
+    tree: ComarkTree;
+}
+interface SearchDocument {
+    /** Route plus anchor, e.g. '/charts/animation#easing'. */
+    url: string;
+    route: string;
+    page: string;
+    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.
+ */
+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.
+ */
+declare function searchDocuments(index: SearchDocument[], query: string, limit?: number): SearchDocument[];
+
+export { type SearchDocument, type SearchPage, buildSearchIndex, searchDocuments };

package/dist/search.js

@@ -0,0 +1 @@
+function g(e){return String(e?.frontmatter?.title??e?.meta?.title??"")}function u(e){return Array.isArray(e)}function d(e){return e[0]}function k(e){return e[1]??{}}function w(e){return e.slice(2)}function s(e){return typeof e=="string"?e:Array.isArray(e)&&typeof e[0]!="string"?e.map(o=>s(o)).join(""):u(e)?w(e).map(o=>s(o)).join(""):""}var x=new Set(["h1","h2","h3","h4","h5","h6"]);function l(e){let o=[],n={id:"",heading:"",depth:0,text:""};for(let t of e.nodes??[]){if(u(t)&&x.has(d(t))){(n.text.trim()||n.heading)&&o.push(n),n={id:String(k(t).id??""),heading:s(t),depth:Number(d(t).slice(1)),text:""};continue}if(u(t)&&d(t)==="pre")continue;let i=s(t).trim();i&&(n.text+=(n.text?" ":"")+i);}return (n.text.trim()||n.heading)&&o.push(n),o}function T(e){let o=[];for(let{route:n,tree:t}of e){let i=g(t);for(let r of l(t))o.push({url:r.id?`${n}#${r.id}`:n,route:n,page:i,heading:r.heading||i,text:r.text});}return o}function N(e,o,n=10){let t=o.toLowerCase().split(/\s+/).filter(Boolean);if(!t.length)return [];let i=[];for(let r of e){let c=(r.page+" "+r.heading).toLowerCase(),p=r.text.toLowerCase(),a=0;for(let f of t){let m=c.includes(f),h=p.includes(f);if(!m&&!h){a=0;break}a+=m?5:1;}a>0&&i.push({doc:r,score:a});}return i.sort((r,c)=>c.score-r.score).slice(0,n).map(r=>r.doc)}export{T as buildSearchIndex,N as searchDocuments};

package/dist/tree.d.ts

@@ -0,0 +1,44 @@
+import { ComarkElement, ComarkNode, ComarkTree } from 'comark';
+import 'comark/utils';
+
+interface TocItem {
+    id: string;
+    text: string;
+    depth: number;
+    children?: TocItem[];
+}
+/** Table of contents produced by the toc plugin, normalized to a plain array. */
+declare function tocFromTree(tree: ComarkTree | 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;
+/** 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;
+interface HeadingSection {
+    /** Heading id (anchor target); empty for content before the first heading. */
+    id: string;
+    /** Heading text; empty for content before the first heading. */
+    heading: string;
+    /** Heading depth (1-6); 0 for content before the first heading. */
+    depth: number;
+    /** 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[];
+
+export { type HeadingSection, type TocItem, childrenOf, descriptionFromTree, headingSections, isElement, propsOf, tagOf, textOf, titleFromTree, tocFromTree, walkTree };

package/dist/tree.js

@@ -0,0 +1 @@
+function l(e){return e?.meta?.toc?.links??[]}function k(e){return String(e?.frontmatter?.title??e?.meta?.title??"")}function m(e){return String(e?.frontmatter?.description??"")}function i(e){return Array.isArray(e)}function d(e){return e[0]}function u(e){return e[1]??{}}function s(e){return e.slice(2)}function w(e,r){let t=(n,o)=>{if(!(r(n,o)===false||!i(n)))for(let c of s(n))t(c,n);};for(let n of e.nodes??[])t(n,null);}function a(e){return typeof e=="string"?e:Array.isArray(e)&&typeof e[0]!="string"?e.map(r=>a(r)).join(""):i(e)?s(e).map(r=>a(r)).join(""):""}var f=new Set(["h1","h2","h3","h4","h5","h6"]);function p(e){let r=[],t={id:"",heading:"",depth:0,text:""};for(let n of e.nodes??[]){if(i(n)&&f.has(d(n))){(t.text.trim()||t.heading)&&r.push(t),t={id:String(u(n).id??""),heading:a(n),depth:Number(d(n).slice(1)),text:""};continue}if(i(n)&&d(n)==="pre")continue;let o=a(n).trim();o&&(t.text+=(t.text?" ":"")+o);}return (t.text.trim()||t.heading)&&r.push(t),r}export{s as childrenOf,m as descriptionFromTree,p as headingSections,i as isElement,u as propsOf,d as tagOf,a as textOf,k as titleFromTree,l as tocFromTree,w as walkTree};

package/package.json

@@ -0,0 +1,132 @@
+{
+  "name": "@primeui-devkit/markdown-core",
+  "version": "0.1.0-beta.1",
+  "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.",
+  "author": "PrimeTek Informatics",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "bugs": {
+    "url": "https://support.primeui.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./preset": {
+      "types": "./dist/preset.d.ts",
+      "import": "./dist/preset.js"
+    },
+    "./tree": {
+      "types": "./dist/tree.d.ts",
+      "import": "./dist/tree.js"
+    },
+    "./search": {
+      "types": "./dist/search.d.ts",
+      "import": "./dist/search.js"
+    },
+    "./llms": {
+      "types": "./dist/llms.d.ts",
+      "import": "./dist/llms.js"
+    },
+    "./prose": {
+      "types": "./dist/prose.d.ts",
+      "import": "./dist/prose.js"
+    },
+    "./plugins/headings": {
+      "types": "./dist/plugins/headings.d.ts",
+      "import": "./dist/plugins/headings.js"
+    },
+    "./plugins/toc": {
+      "types": "./dist/plugins/toc.d.ts",
+      "import": "./dist/plugins/toc.js"
+    },
+    "./plugins/highlight": {
+      "types": "./dist/plugins/highlight.d.ts",
+      "import": "./dist/plugins/highlight.js"
+    },
+    "./plugins/alert": {
+      "types": "./dist/plugins/alert.d.ts",
+      "import": "./dist/plugins/alert.js"
+    },
+    "./plugins/binding": {
+      "types": "./dist/plugins/binding.d.ts",
+      "import": "./dist/plugins/binding.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "preset": [
+        "./dist/preset.d.ts"
+      ],
+      "tree": [
+        "./dist/tree.d.ts"
+      ],
+      "search": [
+        "./dist/search.d.ts"
+      ],
+      "llms": [
+        "./dist/llms.d.ts"
+      ],
+      "prose": [
+        "./dist/prose.d.ts"
+      ],
+      "plugins/headings": [
+        "./dist/plugins/headings.d.ts"
+      ],
+      "plugins/toc": [
+        "./dist/plugins/toc.d.ts"
+      ],
+      "plugins/highlight": [
+        "./dist/plugins/highlight.d.ts"
+      ],
+      "plugins/alert": [
+        "./dist/plugins/alert.d.ts"
+      ],
+      "plugins/binding": [
+        "./dist/plugins/binding.d.ts"
+      ]
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "THIRD-PARTY-NOTICES.txt",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "comark": "^0.5.1"
+  },
+  "peerDependencies": {
+    "shiki": "^4.4.2"
+  },
+  "peerDependenciesMeta": {
+    "shiki": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "cross-env": "^10.1.0",
+    "tsup": "^8.5.1",
+    "typescript": "~6.0.0",
+    "vitest": "4.1.10",
+    "@primeui-devkit/test-config": "0.0.0",
+    "@primeui-devkit/bundler": "0.0.0",
+    "@primeui-devkit/ts-config": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm run build:package",
+    "build:package": "pnpm run test && tsup",
+    "type:check": "tsc --noEmit",
+    "test": "cross-env NODE_ENV=test vitest run",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest run --coverage"
+  }
+}