@zenera/rag 1.1.8 → 1.1.10

package/dist/docs/files.js

@@ -0,0 +1,80 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { MANIFEST_FILE, readHead } from "../common/manifest.js";
+// ---------------------------------------------------------------------------
+// What a document index is, on disk
+//
+// A directory, written in an order that is the whole crash story: the manifest
+// goes last, so a half-built index has no manifest and reads as "not indexed"
+// rather than as a store that quietly lost half its documents.
+//
+//   manifest.json   what this index is and what built it
+//   outline.json    the headings and tables of every document, read whole
+//   sources/        the documents themselves, verbatim
+//   lance/          the chunks: the search text, the vectors, the filters
+//
+// `sources/` is not a convenience here, the way it is for a schema index — it
+// is where the answers come from. A search returns line ranges, and the lines
+// are read back out of these copies, so what is quoted is the document and not
+// a reconstruction of it. That also makes the index one portable thing: nothing
+// in it names a path outside itself, so it can be moved, shipped, or mounted
+// somewhere else in an agent's sandbox and still answer.
+//
+// It is also why there is no table of lines. The original design kept one row
+// per physical line beside the chunks, carrying the text and its structure. With
+// the document itself sitting in `sources/`, that table would be a second copy
+// of the same bytes; the per-line structure it also held is derivable from the
+// outline, since a section runs from its heading to the next heading at the same
+// depth or shallower. One store, one copy, same answers.
+//
+// `outline.json` is deliberately thin — headings, tables, counts — because it is
+// parsed whole every time anything is asked. It is what makes `list`, `show` and
+// section scoping work with no store, no embedder and no credential.
+// ---------------------------------------------------------------------------
+export const INDEX_VERSION = 1;
+/** How a document index is found, read, and refused. */
+export const DOCS_INDEX = {
+    kind: 'docs',
+    version: INDEX_VERSION,
+    defaultDir: './docs-db',
+    envName: 'ZEN_DOCS_DB',
+};
+export const OUTLINE_FILE = 'outline.json';
+export const LANCE_DIR = 'lance';
+export const SOURCES_DIR = 'sources';
+export const lancePath = (dir) => join(dir, LANCE_DIR);
+export async function writeIndex(dir, index) {
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, OUTLINE_FILE), JSON.stringify(index.outline));
+    for (const [name, text] of Object.entries(index.documents)) {
+        const target = join(dir, SOURCES_DIR, name);
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, text);
+    }
+    await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(index.manifest, null, 4)}\n`);
+}
+export async function openIndex(dir) {
+    const manifest = await readManifest(dir);
+    const outline = JSON.parse(await readFile(join(dir, OUTLINE_FILE), 'utf8'));
+    return { dir, manifest, outline };
+}
+export const readManifest = (dir) => readHead(dir, DOCS_INDEX);
+/**
+ * A document, verbatim, as it was indexed. The name is looked up in the
+ * manifest rather than joined onto the directory, so nothing a caller types
+ * ever reaches the filesystem — and a name that is not in the index is told so
+ * instead of becoming a path that happens not to exist.
+ */
+export async function readSource(index, name) {
+    const record = index.manifest.sources.find((s) => s.name === name);
+    if (!record) {
+        throw new CliError(`${index.dir} holds no document called ${name}`, EXIT.failed, `list them with \`zen rag docs list files\``);
+    }
+    return await readFile(join(index.dir, record.path), 'utf8');
+}
+/** The same document, split the way every line number in the index counts it. */
+export async function readLines(index, name) {
+    return (await readSource(index, name)).split('\n');
+}
+//# sourceMappingURL=files.js.map

package/dist/docs/index.d.ts

@@ -0,0 +1,13 @@
+export * from './assemble.ts';
+export * from './build.ts';
+export * from './chunk.ts';
+export * from './files.ts';
+export * from './load.ts';
+export * from './lookup.ts';
+export * from './parse.ts';
+export * from './readme.ts';
+export * from './render.ts';
+export * from './search.ts';
+export * from './store.ts';
+export * from './tools.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/docs/index.js

@@ -0,0 +1,13 @@
+export * from "./assemble.js";
+export * from "./build.js";
+export * from "./chunk.js";
+export * from "./files.js";
+export * from "./load.js";
+export * from "./lookup.js";
+export * from "./parse.js";
+export * from "./readme.js";
+export * from "./render.js";
+export * from "./search.js";
+export * from "./store.js";
+export * from "./tools.js";
+//# sourceMappingURL=index.js.map

package/dist/docs/load.d.ts

@@ -0,0 +1,28 @@
+import { type Chunk, type ChunkOptions } from './chunk.ts';
+import type { FileOutline } from './files.ts';
+import { type DocFormat, type ParsedDoc } from './parse.ts';
+/** Markdown, and plain text read as paragraphs. Anything else is not a document. */
+export declare const DOC_EXTENSIONS: readonly [".md", ".markdown", ".txt", ".text"];
+export interface LoadedDoc {
+    name: string;
+    file: string;
+    sha256: string;
+    bytes: number;
+    format: DocFormat;
+    /** the document verbatim, CRLF normalized: what goes into `sources/` */
+    text: string;
+    parsed: ParsedDoc;
+    chunks: Chunk[];
+    outline: FileOutline;
+}
+export interface Corpus {
+    docs: LoadedDoc[];
+    /** files that were found and not read, with the reason */
+    skipped: {
+        name: string;
+        reason: string;
+    }[];
+}
+export declare function loadDocuments(inputs: readonly string[], cwd: string, options?: ChunkOptions): Promise<Corpus>;
+export declare const formatOf: (path: string) => DocFormat;
+//# sourceMappingURL=load.d.ts.map

package/dist/docs/load.js

@@ -0,0 +1,212 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { createHash } from 'node:crypto';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { isGlob, wildcard } from "../common/match.js";
+import { chunkDocument } from "./chunk.js";
+import { normalize, parseDocument } from "./parse.js";
+// ---------------------------------------------------------------------------
+// Finding the documents, and reading them
+//
+// What can be named is a file, a directory, or a pattern. A directory is walked,
+// because "index my notes" is the question people actually have and asking them
+// to enumerate it would be answering a different one. Hidden directories and
+// `node_modules` are skipped: a document nobody can see is not one anybody meant
+// to index.
+//
+// Every document is given a NAME, which is its path relative to the common root
+// of everything that was named — so indexing two release trees keeps
+// `nsx_4.1.0/api/routing.md` and `nsx_4.2.0/api/routing.md` apart, and a search
+// can be narrowed to one of them with a pattern over exactly that string. The
+// name is the identity: it is stamped on every chunk, it is what `sources/`
+// files are called, and nothing anywhere records where the file was on the
+// machine that built the index.
+// ---------------------------------------------------------------------------
+/** Markdown, and plain text read as paragraphs. Anything else is not a document. */
+export const DOC_EXTENSIONS = ['.md', '.markdown', '.txt', '.text'];
+/** A file larger than this is a data dump, not something anyone wrote. */
+const MAX_BYTES = 16 * 1024 * 1024;
+/** Enough for a documentation tree; far short of a filesystem. */
+const MAX_FILES = 20_000;
+export async function loadDocuments(inputs, cwd, options = {}) {
+    const found = await discover(inputs, cwd);
+    if (found.length === 0) {
+        throw new CliError('nothing to index', EXIT.invalid, `no ${DOC_EXTENSIONS.join(', ')} files were found under ${inputs.join(', ')}`);
+    }
+    const root = commonRoot(found);
+    const taken = new Set();
+    const docs = [];
+    const skipped = [];
+    for (const absolute of found) {
+        const name = distinct(nameOf(root, absolute), taken);
+        const info = await stat(absolute);
+        if (info.size > MAX_BYTES) {
+            skipped.push({ name, reason: `larger than ${MAX_BYTES / 1024 / 1024} MB` });
+            continue;
+        }
+        const raw = await readFile(absolute);
+        const text = normalize(raw.toString('utf8'));
+        const format = formatOf(absolute);
+        const parsed = parseDocument(text, name, format);
+        const chunks = chunkDocument(parsed, options);
+        docs.push({
+            name,
+            file: basename(absolute),
+            sha256: createHash('sha256').update(raw).digest('hex'),
+            bytes: raw.byteLength,
+            format,
+            text,
+            parsed,
+            chunks,
+            outline: outlineOf(parsed, chunks.length),
+        });
+    }
+    return { docs, skipped };
+}
+export const formatOf = (path) => ['.txt', '.text'].includes(extname(path).toLowerCase()) ? 'text' : 'markdown';
+// ---------------------------------------------------------------------------
+// discovery
+// ---------------------------------------------------------------------------
+async function discover(inputs, cwd) {
+    const out = new Set();
+    for (const input of inputs) {
+        const path = resolve(cwd, input);
+        if (isGlob(input)) {
+            // The pattern is anchored at the deepest directory it names outright,
+            // so a walk of the whole tree is never needed to answer one.
+            const anchor = staticPrefix(path);
+            const match = wildcard(path, { caseSensitive: true });
+            for (const file of await walk(anchor)) {
+                if (match(file)) {
+                    out.add(file);
+                }
+            }
+            continue;
+        }
+        const info = await stat(path).catch(() => undefined);
+        if (!info) {
+            throw new CliError(`no such file or directory: ${input}`, EXIT.invalid);
+        }
+        if (info.isDirectory()) {
+            for (const file of await walk(path)) {
+                out.add(file);
+            }
+        }
+        else {
+            // A file named outright is indexed whatever it is called: someone
+            // who types a name has already decided it is a document.
+            out.add(path);
+        }
+    }
+    return [...out].sort();
+}
+async function walk(root) {
+    const out = [];
+    const queue = [root];
+    while (queue.length > 0 && out.length < MAX_FILES) {
+        const dir = queue.shift();
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules') {
+                continue;
+            }
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(path);
+            }
+            else if (indexable(entry.name)) {
+                out.push(path);
+            }
+        }
+    }
+    return out;
+}
+const indexable = (name) => DOC_EXTENSIONS.includes(extname(name).toLowerCase());
+/** The part of a pattern before the first wildcard, which is a real directory. */
+function staticPrefix(pattern) {
+    const parts = pattern.split(sep);
+    const at = parts.findIndex((part) => isGlob(part));
+    const head = (at === -1 ? parts : parts.slice(0, at)).join(sep);
+    return head && isAbsolute(head) ? head : dirname(pattern.split('*')[0] ?? pattern);
+}
+/**
+ * The deepest directory holding every file, which is what names are taken
+ * relative to. One file is its own directory, so a single document is named by
+ * its basename rather than by an accident of where it was kept.
+ */
+function commonRoot(files) {
+    const parts = files.map((file) => dirname(file).split(sep));
+    const first = parts[0] ?? [];
+    let at = 0;
+    while (at < first.length && parts.every((p) => p[at] === first[at])) {
+        at++;
+    }
+    return first.slice(0, at).join(sep) || sep;
+}
+function nameOf(root, absolute) {
+    const rel = relative(root, absolute);
+    // A file outside the common root cannot happen by construction; if it ever
+    // did, a name climbing out of the index directory must not.
+    return !rel || rel.startsWith('..') || isAbsolute(rel)
+        ? basename(absolute)
+        : rel.split(sep).join('/');
+}
+function distinct(name, taken) {
+    let candidate = name;
+    for (let n = 2; taken.has(candidate); n++) {
+        const dot = name.lastIndexOf('.');
+        candidate = dot === -1 ? `${name}_${n}` : `${name.slice(0, dot)}_${n}${name.slice(dot)}`;
+    }
+    taken.add(candidate);
+    return candidate;
+}
+// ---------------------------------------------------------------------------
+// the outline
+// ---------------------------------------------------------------------------
+/**
+ * Headings and tables, with the line each ends on. That end is what makes the
+ * outline enough on its own: a section runs from its heading to the line before
+ * the next heading at the same depth or shallower, so scoping a search to a
+ * section, listing what is in one, or naming the sections a skipped range
+ * covered are all answerable without reading the document.
+ */
+function outlineOf(doc, chunks) {
+    const sections = doc.sections.filter((s) => s.line !== undefined);
+    const headings = sections.map((section, at) => {
+        const next = sections.findIndex((other, i) => i > at && other.level <= section.level);
+        const end = next === -1 ? doc.lines.length : sections[next].line - 1;
+        return {
+            line: section.line,
+            end,
+            level: section.level,
+            title: section.title,
+            id: section.id,
+            path: section.path,
+        };
+    });
+    const tables = doc.blocks
+        .filter((block) => block.table)
+        .map((block) => {
+        const table = block.table;
+        return {
+            id: block.id,
+            path: block.path,
+            section: block.section.path,
+            line: block.start,
+            end: block.end,
+            columns: table.columns,
+            rows: table.rows.length,
+            caption: table.caption,
+        };
+    });
+    return {
+        name: doc.name,
+        title: doc.title,
+        format: doc.format,
+        lines: doc.lines.length,
+        chunks,
+        headings,
+        tables,
+    };
+}
+//# sourceMappingURL=load.js.map

package/dist/docs/lookup.d.ts

@@ -0,0 +1,80 @@
+import { type MatchOptions } from '../common/match.ts';
+import type { DocsIndex } from './search.ts';
+export interface Listing<T> {
+    found: number;
+    rows: T[];
+    truncated: boolean;
+}
+export interface ListOptions {
+    /** patterns over the document name */
+    files?: readonly string[];
+    exclude_files?: readonly string[];
+    limit?: number;
+}
+export declare const DEFAULT_ROWS = 50;
+export declare const MAX_ROWS = 500;
+export interface FileRow {
+    name: string;
+    title: string;
+    format: string;
+    lines: number;
+    sections: number;
+    tables: number;
+    chunks: number;
+}
+export declare function listFiles(index: DocsIndex, options?: ListOptions): Listing<FileRow>;
+export interface SectionRow {
+    file: string;
+    id: string;
+    path: string;
+    level: number;
+    title: string;
+    line: number;
+    end: number;
+}
+export interface SectionOptions extends ListOptions {
+    /** a heading title, a structure id, or a structure path */
+    section?: readonly string[];
+    /** deepest heading level to report; the default is everything */
+    depth?: number;
+}
+export declare function listSections(index: DocsIndex, options?: SectionOptions): Listing<SectionRow>;
+export interface TableRow {
+    file: string;
+    id: string;
+    section: string;
+    caption: string;
+    columns: string;
+    rows: number;
+    line: number;
+    end: number;
+}
+export declare function listTables(index: DocsIndex, options?: SectionOptions): Listing<TableRow>;
+export interface LineRow {
+    file: string;
+    line: number;
+    text: string;
+    /** the innermost heading the line sits under, so a hit has a place */
+    section: string;
+}
+export interface GrepOptions extends SectionOptions, MatchOptions {
+}
+/**
+ * Lines matching a pattern. Substring by default, glob when it has wildcards,
+ * a regular expression when asked — the same rule every other pattern in this
+ * package follows, so nobody has to remember which flavour a flag takes.
+ */
+export declare function grepLines(index: DocsIndex, pattern: string, options?: GrepOptions): Promise<Listing<LineRow>>;
+export interface Verbatim {
+    file: string;
+    title: string;
+    start: number;
+    end: number;
+    lines: string[];
+    /** the document's length, so a caller can tell what it did not get */
+    total: number;
+}
+/** A named section, verbatim: heading line to the line before the next peer. */
+export declare function readSection(index: DocsIndex, file: string, section: string): Promise<Verbatim>;
+export declare function readRange(index: DocsIndex, file: string, from: number, to: number): Promise<Verbatim>;
+//# sourceMappingURL=lookup.d.ts.map

package/dist/docs/lookup.js

@@ -0,0 +1,147 @@
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { loose } from "../common/match.js";
+import { under } from "./search.js";
+export const DEFAULT_ROWS = 50;
+export const MAX_ROWS = 500;
+export function listFiles(index, options = {}) {
+    const names = new Set(index.resolveFiles(options.files, options.exclude_files));
+    const rows = index.manifest.sources
+        .filter((source) => names.has(source.name))
+        .map((source) => ({
+        name: source.name,
+        title: source.title,
+        format: source.format,
+        lines: source.lines,
+        sections: source.sections,
+        tables: source.tables,
+        chunks: source.chunks,
+    }));
+    return cut(rows, options.limit);
+}
+export function listSections(index, options = {}) {
+    const files = index.resolveFiles(options.files, options.exclude_files);
+    const within = new Set(files);
+    const wanted = options.section?.length
+        ? index.resolveSections(options.section, files).map((h) => h.path)
+        : [];
+    const rows = [];
+    for (const file of index.outline.files) {
+        if (!within.has(file.name)) {
+            continue;
+        }
+        for (const heading of file.headings) {
+            if (under(heading.path, wanted) && heading.level <= (options.depth ?? Infinity)) {
+                rows.push({ file: file.name, ...record(heading) });
+            }
+        }
+    }
+    return cut(rows, options.limit);
+}
+export function listTables(index, options = {}) {
+    const files = index.resolveFiles(options.files, options.exclude_files);
+    const within = new Set(files);
+    const wanted = options.section?.length
+        ? index.resolveSections(options.section, files).map((h) => h.path)
+        : [];
+    const rows = [];
+    for (const file of index.outline.files) {
+        if (!within.has(file.name)) {
+            continue;
+        }
+        for (const table of file.tables) {
+            if (!under(table.path, wanted)) {
+                continue;
+            }
+            rows.push({
+                file: file.name,
+                id: table.id,
+                section: table.section,
+                caption: table.caption,
+                columns: table.columns.join(', '),
+                rows: table.rows,
+                line: table.line,
+                end: table.end,
+            });
+        }
+    }
+    return cut(rows, options.limit);
+}
+/**
+ * Lines matching a pattern. Substring by default, glob when it has wildcards,
+ * a regular expression when asked — the same rule every other pattern in this
+ * package follows, so nobody has to remember which flavour a flag takes.
+ */
+export async function grepLines(index, pattern, options = {}) {
+    const files = index.resolveFiles(options.files, options.exclude_files);
+    const wanted = options.section?.length
+        ? index.resolveSections(options.section, files)
+        : undefined;
+    const match = loose(pattern, { regex: options.regex, caseSensitive: options.caseSensitive });
+    const rows = [];
+    for (const name of files) {
+        const spans = wanted?.filter((h) => index.file(name)?.headings.includes(h));
+        if (wanted && (!spans || spans.length === 0)) {
+            continue;
+        }
+        const lines = await index.lines(name);
+        const headings = index.file(name)?.headings ?? [];
+        for (const [at, text] of lines.entries()) {
+            const line = at + 1;
+            if (spans && !spans.some((span) => line >= span.line && line <= span.end)) {
+                continue;
+            }
+            if (match(text)) {
+                rows.push({ file: name, line, text, section: enclosing(headings, line) });
+            }
+        }
+    }
+    return cut(rows, options.limit);
+}
+/** A named section, verbatim: heading line to the line before the next peer. */
+export async function readSection(index, file, section) {
+    const found = index.resolveSections([section], [file]);
+    const heading = found[0];
+    if (!heading) {
+        throw new CliError(`${file} has no section called ${section}`, EXIT.failed, 'list them with `zen rag docs list sections --file <name>`');
+    }
+    return await readRange(index, file, heading.line, heading.end);
+}
+export async function readRange(index, file, from, to) {
+    const lines = await index.lines(file);
+    const outline = index.file(file);
+    const start = Math.max(1, from);
+    const end = Math.min(lines.length, to);
+    return {
+        file,
+        title: outline?.title ?? file,
+        start,
+        end,
+        lines: lines.slice(start - 1, end),
+        total: lines.length,
+    };
+}
+// ---------------------------------------------------------------------------
+function cut(rows, limit) {
+    const take = Math.min(Math.max(1, limit ?? DEFAULT_ROWS), MAX_ROWS);
+    return { found: rows.length, rows: rows.slice(0, take), truncated: rows.length > take };
+}
+const record = (heading) => ({
+    id: heading.id,
+    path: heading.path,
+    level: heading.level,
+    title: heading.title,
+    line: heading.line,
+    end: heading.end,
+});
+/** The last heading at or above this line, which is the section it is in. */
+function enclosing(headings, line) {
+    let title = '';
+    for (const heading of headings) {
+        if (heading.line > line) {
+            break;
+        }
+        title = heading.title;
+    }
+    return title;
+}
+//# sourceMappingURL=lookup.js.map

package/dist/docs/parse.d.ts

@@ -0,0 +1,95 @@
+/** What a line, a block or a chunk is. The vocabulary is closed on purpose. */
+export type StructureKind = 'heading' | 'paragraph' | 'blockquote' | 'list' | 'list_item' | 'table' | 'table_header' | 'table_row' | 'code' | 'frontmatter' | 'html' | 'hr';
+/** The root of every path: a document is the structure everything else sits in. */
+export declare const ROOT_SEGMENT = "doc";
+export type DocFormat = 'markdown' | 'text';
+/**
+ * A heading and everything under it, until a heading of the same depth or
+ * shallower. mdast has no such node — a heading there is a SIBLING of the
+ * paragraphs that follow it — so the nesting is built here.
+ */
+export interface Section {
+    id: string;
+    path: string;
+    title: string;
+    /** 0 for the document itself, otherwise the heading depth */
+    level: number;
+    /** the heading's own line; absent on the document root */
+    line: number | undefined;
+    parent: Section | undefined;
+}
+export interface TableRowBlock {
+    id: string;
+    path: string;
+    line: number;
+    cells: string[];
+    /** the row as prose, so it carries its own column names */
+    text: string;
+}
+export interface TableBlock {
+    columns: string[];
+    headerLine: number;
+    /** the alignment row; mdast emits no node for it, so it is derived */
+    separatorLine: number | undefined;
+    /** the paragraph before the table, which is the only caption one ever gets */
+    caption: string;
+    /** the column that identifies a row, repeated into every slice of it */
+    keyColumn: number;
+    rows: TableRowBlock[];
+}
+export interface ListItemBlock {
+    id: string;
+    path: string;
+    start: number;
+    end: number;
+    text: string;
+}
+export interface Block {
+    id: string;
+    path: string;
+    kind: StructureKind;
+    /** 1-based, inclusive */
+    start: number;
+    end: number;
+    section: Section;
+    /** normalized, never shown: this is what is embedded and indexed */
+    text: string;
+    items?: ListItemBlock[];
+    table?: TableBlock;
+}
+export interface ParsedDoc {
+    /** the document's name within the index — its path, and its identity */
+    name: string;
+    title: string;
+    format: DocFormat;
+    /** verbatim, CRLF normalized, 1-based when indexed as `lines[n - 1]` */
+    lines: string[];
+    sections: Section[];
+    blocks: Block[];
+}
+/** Every ancestor of a section, the document root first, itself last. */
+export declare function ancestry(section: Section): Section[];
+/** The breadcrumb, which prefixes every chunk of text under this section. */
+export declare const headingPath: (section: Section) => string;
+/** The heading lines a chunk under this section must be rendered with. */
+export declare const headingLines: (section: Section) => number[];
+/**
+ * Everything downstream indexes `lines` by number, and mdast positions refer to
+ * the exact string handed to the parser — so the normalization happens once,
+ * here, and the normalized text is the only version anything ever sees.
+ */
+export declare const normalize: (text: string) => string;
+export declare function parseDocument(source: string, name: string, format: DocFormat): ParsedDoc;
+/**
+ * A data row does not contain its own column names. Stripping the pipes leaves
+ * `V-200-30 3" WCC 98.2`, in which the word `Cv` appears nowhere, so a query
+ * naming a column could only ever match the header line and never a row — and
+ * hybrid search would silently become vector-only for every table in the
+ * corpus. Pairing each cell with its header is what fixes that, and it embeds
+ * better too, because `Cv: 45` is a sentence and `| 45 |` is not.
+ */
+export declare function rowText(columns: readonly string[], cells: readonly string[]): string;
+export declare function cellText(column: string | undefined, cell: string): string;
+/** Soft wraps inside a paragraph are wrapping, not meaning, so they rejoin. */
+export declare const collapse: (text: string) => string;
+//# sourceMappingURL=parse.d.ts.map