@ericsanchezok/synergy-util 2.4.4

package/dist/note-markdown.js

@@ -0,0 +1,630 @@
+export var NoteMarkdown;
+(function (NoteMarkdown) {
+    const DEFAULT_PREVIEW_BLOCKS = 16;
+    function renderMarks(text, marks) {
+        if (!marks || marks.length === 0)
+            return text;
+        let result = text;
+        for (const mark of marks) {
+            switch (mark.type) {
+                case "bold":
+                    result = `**${result}**`;
+                    break;
+                case "italic":
+                    result = `*${result}*`;
+                    break;
+                case "code":
+                    result = `\`${result}\``;
+                    break;
+                case "strike":
+                    result = `~~${result}~~`;
+                    break;
+                case "link":
+                    result = `[${result}](${mark.attrs?.href ?? ""})`;
+                    break;
+            }
+        }
+        return result;
+    }
+    function renderInline(nodes) {
+        let result = "";
+        for (const node of nodes) {
+            if (node.type === "text") {
+                result += renderMarks(node.text ?? "", node.marks);
+            }
+            else if (node.type === "hardBreak") {
+                result += "\n";
+            }
+            else if (node.type === "inlineMath") {
+                const latex = node.attrs?.latex ?? "";
+                result += node.attrs?.display === "yes" ? `$$\n${latex}\n$$` : `$${latex}$`;
+            }
+            else if (node.type === "image") {
+                const alt = node.attrs?.alt ?? "";
+                const src = node.attrs?.src ?? "";
+                result += `![${alt}](${src})`;
+            }
+        }
+        return result;
+    }
+    function renderBlock(node, indent = "") {
+        switch (node.type) {
+            case "doc":
+                return renderChildren(node.content ?? []);
+            case "paragraph":
+                return indent + renderInline(node.content ?? []);
+            case "heading": {
+                const level = node.attrs?.level ?? 1;
+                const prefix = "#".repeat(level);
+                return `${prefix} ${renderInline(node.content ?? [])}`;
+            }
+            case "bulletList":
+                return (node.content ?? []).map((item) => renderListItem(item, indent, "- ")).join("\n");
+            case "orderedList":
+                return (node.content ?? []).map((item, i) => renderListItem(item, indent, `${i + 1}. `)).join("\n");
+            case "taskList":
+                return (node.content ?? []).map((item) => renderTaskItem(item, indent)).join("\n");
+            case "codeBlock": {
+                const lang = node.attrs?.language ?? "";
+                const code = renderInline(node.content ?? []);
+                return `\`\`\`${lang}\n${code}\n\`\`\``;
+            }
+            case "blockquote":
+                return (node.content ?? [])
+                    .map((child) => renderBlock(child))
+                    .join("\n")
+                    .split("\n")
+                    .map((line) => `> ${line}`)
+                    .join("\n");
+            case "horizontalRule":
+                return "---";
+            case "image": {
+                const alt = node.attrs?.alt ?? "";
+                const src = node.attrs?.src ?? "";
+                return `![${alt}](${src})`;
+            }
+            case "table":
+                return renderTable(node);
+            default:
+                if (node.content)
+                    return renderChildren(node.content);
+                if (node.text)
+                    return renderMarks(node.text, node.marks);
+                return "";
+        }
+    }
+    function renderListItem(node, indent, bullet) {
+        const children = node.content ?? [];
+        const lines = [];
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (i === 0) {
+                lines.push(indent + bullet + renderBlock(child).trimStart());
+            }
+            else {
+                const nested = renderBlock(child, indent + " ".repeat(bullet.length));
+                lines.push(nested);
+            }
+        }
+        return lines.join("\n");
+    }
+    function renderTaskItem(node, indent) {
+        const checked = node.attrs?.checked ? "x" : " ";
+        const children = node.content ?? [];
+        const text = children
+            .map((child) => renderBlock(child))
+            .join("\n")
+            .trimStart();
+        return `${indent}- [${checked}] ${text}`;
+    }
+    function renderTable(node) {
+        const rows = node.content ?? [];
+        if (rows.length === 0)
+            return "";
+        const matrix = [];
+        for (const row of rows) {
+            const cells = (row.content ?? []).map((cell) => {
+                const inner = (cell.content ?? []).map((child) => renderBlock(child)).join(" ");
+                return inner.trim();
+            });
+            matrix.push(cells);
+        }
+        const colCount = Math.max(...matrix.map((r) => r.length));
+        const widths = Array.from({ length: colCount }, () => 3);
+        for (const row of matrix) {
+            for (let i = 0; i < row.length; i++) {
+                widths[i] = Math.max(widths[i], row[i].length);
+            }
+        }
+        const formatRow = (cells) => {
+            const padded = widths.map((w, i) => (cells[i] ?? "").padEnd(w));
+            return `| ${padded.join(" | ")} |`;
+        };
+        const lines = [];
+        lines.push(formatRow(matrix[0] ?? []));
+        lines.push(`| ${widths.map((w) => "-".repeat(w)).join(" | ")} |`);
+        for (let i = 1; i < matrix.length; i++) {
+            lines.push(formatRow(matrix[i]));
+        }
+        return lines.join("\n");
+    }
+    function renderChildren(nodes) {
+        return nodes.map((node) => renderBlock(node)).join("\n\n");
+    }
+    function toMarkdown(content) {
+        if (!content || typeof content !== "object")
+            return "";
+        return renderBlock(content).trim();
+    }
+    NoteMarkdown.toMarkdown = toMarkdown;
+    function fromMarkdown(markdown) {
+        const lines = markdown.split("\n");
+        const blocks = parseBlocks(lines, 0, lines.length);
+        return { type: "doc", content: blocks.length > 0 ? blocks : [{ type: "paragraph" }] };
+    }
+    NoteMarkdown.fromMarkdown = fromMarkdown;
+    function parseBlocks(lines, start, end) {
+        const blocks = [];
+        let i = start;
+        while (i < end) {
+            const line = lines[i];
+            if (line.trim() === "") {
+                i++;
+                continue;
+            }
+            if (/^```/.test(line)) {
+                const lang = line.slice(3).trim();
+                const codeLines = [];
+                i++;
+                while (i < end && !/^```\s*$/.test(lines[i])) {
+                    codeLines.push(lines[i]);
+                    i++;
+                }
+                i++;
+                const node = { type: "codeBlock", content: [{ type: "text", text: codeLines.join("\n") }] };
+                if (lang)
+                    node.attrs = { language: lang };
+                blocks.push(node);
+                continue;
+            }
+            const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
+            if (headingMatch) {
+                blocks.push({
+                    type: "heading",
+                    attrs: { level: headingMatch[1].length },
+                    content: parseInline(headingMatch[2]),
+                });
+                i++;
+                continue;
+            }
+            if (/^---\s*$/.test(line) || /^\*\*\*\s*$/.test(line) || /^___\s*$/.test(line)) {
+                blocks.push({ type: "horizontalRule" });
+                i++;
+                continue;
+            }
+            // Block math: $$ ... $$
+            if (/^\$\$/.test(line)) {
+                const mathLines = [];
+                i++; // skip opening $$
+                while (i < end && !/^\$\$/.test(lines[i])) {
+                    mathLines.push(lines[i]);
+                    i++;
+                }
+                i++; // skip closing $$
+                blocks.push({
+                    type: "paragraph",
+                    content: [
+                        {
+                            type: "inlineMath",
+                            attrs: { latex: mathLines.join("\n").trim(), evaluate: "no", display: "yes" },
+                        },
+                    ],
+                });
+                continue;
+            }
+            if (/^\|/.test(line)) {
+                const tableResult = parseTable(lines, i, end);
+                blocks.push(tableResult.node);
+                i = tableResult.nextIndex;
+                continue;
+            }
+            if (/^>\s?/.test(line)) {
+                const quoteLines = [];
+                while (i < end && /^>\s?/.test(lines[i])) {
+                    quoteLines.push(lines[i].replace(/^>\s?/, ""));
+                    i++;
+                }
+                blocks.push({ type: "blockquote", content: parseBlocks(quoteLines, 0, quoteLines.length) });
+                continue;
+            }
+            if (/^[-*]\s\[[ x]\]\s/.test(line)) {
+                const taskResult = parseTaskList(lines, i, end);
+                blocks.push(taskResult.node);
+                i = taskResult.nextIndex;
+                continue;
+            }
+            if (/^[-*]\s/.test(line)) {
+                const listResult = parseBulletList(lines, i, end);
+                blocks.push(listResult.node);
+                i = listResult.nextIndex;
+                continue;
+            }
+            if (/^\d+\.\s/.test(line)) {
+                const listResult = parseOrderedList(lines, i, end);
+                blocks.push(listResult.node);
+                i = listResult.nextIndex;
+                continue;
+            }
+            const imgMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)\s*$/);
+            if (imgMatch) {
+                blocks.push({ type: "image", attrs: { src: imgMatch[2], alt: imgMatch[1] } });
+                i++;
+                continue;
+            }
+            const paraLines = [line];
+            i++;
+            while (i < end && lines[i].trim() !== "" && !isBlockStart(lines[i])) {
+                paraLines.push(lines[i]);
+                i++;
+            }
+            blocks.push({ type: "paragraph", content: parseInline(paraLines.join("\n")) });
+        }
+        return blocks;
+    }
+    function isBlockStart(line) {
+        if (/^#{1,6}\s/.test(line))
+            return true;
+        if (/^```/.test(line))
+            return true;
+        if (/^\$\$/.test(line))
+            return true;
+        if (/^---\s*$/.test(line) || /^\*\*\*\s*$/.test(line) || /^___\s*$/.test(line))
+            return true;
+        if (/^>\s?/.test(line))
+            return true;
+        if (/^[-*]\s/.test(line))
+            return true;
+        if (/^\d+\.\s/.test(line))
+            return true;
+        if (/^\|/.test(line))
+            return true;
+        if (/^!\[/.test(line))
+            return true;
+        return false;
+    }
+    function parseBulletList(lines, start, end) {
+        const items = [];
+        let i = start;
+        while (i < end && /^[-*]\s/.test(lines[i])) {
+            const text = lines[i].replace(/^[-*]\s/, "");
+            const itemContent = [text];
+            i++;
+            while (i < end && /^\s{2,}/.test(lines[i]) && !/^[-*]\s/.test(lines[i])) {
+                itemContent.push(lines[i].trimStart());
+                i++;
+            }
+            items.push({ type: "listItem", content: [{ type: "paragraph", content: parseInline(itemContent.join("\n")) }] });
+        }
+        return { node: { type: "bulletList", content: items }, nextIndex: i };
+    }
+    function parseOrderedList(lines, start, end) {
+        const items = [];
+        let i = start;
+        while (i < end && /^\d+\.\s/.test(lines[i])) {
+            const text = lines[i].replace(/^\d+\.\s/, "");
+            const itemContent = [text];
+            i++;
+            while (i < end && /^\s{2,}/.test(lines[i]) && !/^\d+\.\s/.test(lines[i])) {
+                itemContent.push(lines[i].trimStart());
+                i++;
+            }
+            items.push({ type: "listItem", content: [{ type: "paragraph", content: parseInline(itemContent.join("\n")) }] });
+        }
+        return { node: { type: "orderedList", content: items }, nextIndex: i };
+    }
+    function parseTaskList(lines, start, end) {
+        const items = [];
+        let i = start;
+        while (i < end && /^[-*]\s\[[ x]\]\s/.test(lines[i])) {
+            const checked = /^[-*]\s\[x\]\s/i.test(lines[i]);
+            const text = lines[i].replace(/^[-*]\s\[[ x]\]\s/i, "");
+            items.push({
+                type: "taskItem",
+                attrs: { checked },
+                content: [{ type: "paragraph", content: parseInline(text) }],
+            });
+            i++;
+        }
+        return { node: { type: "taskList", content: items }, nextIndex: i };
+    }
+    function parseTable(lines, start, end) {
+        const rows = [];
+        let i = start;
+        while (i < end && /^\|/.test(lines[i])) {
+            const cells = lines[i]
+                .replace(/^\|/, "")
+                .replace(/\|$/, "")
+                .split("|")
+                .map((c) => c.trim());
+            if (cells.every((c) => /^-+$/.test(c))) {
+                i++;
+                continue;
+            }
+            const isHeader = rows.length === 0;
+            const cellNodes = cells.map((cell) => ({
+                type: isHeader ? "tableHeader" : "tableCell",
+                content: [{ type: "paragraph", content: parseInline(cell) }],
+            }));
+            rows.push({ type: "tableRow", content: cellNodes });
+            i++;
+        }
+        return { node: { type: "table", content: rows }, nextIndex: i };
+    }
+    function parseInline(text) {
+        if (!text)
+            return [];
+        const nodes = [];
+        const regex = /!\[([^\]]*)\]\(([^)]+)\)|\[([^\]]*)\]\(([^)]+)\)|`([^`]+)`|\*\*\*([^*]+)\*\*\*|\*\*([^*]+)\*\*|\*([^*]+)\*|~~([^~]+)~~|\$([^$]+)\$|(\n)/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            if (match.index > lastIndex) {
+                nodes.push({ type: "text", text: text.slice(lastIndex, match.index) });
+            }
+            if (match[1] !== undefined || match[2] !== undefined) {
+                nodes.push({ type: "image", attrs: { src: match[2], alt: match[1] ?? "" } });
+            }
+            else if (match[3] !== undefined) {
+                nodes.push({ type: "text", text: match[3], marks: [{ type: "link", attrs: { href: match[4] } }] });
+            }
+            else if (match[5] !== undefined) {
+                nodes.push({ type: "text", text: match[5], marks: [{ type: "code" }] });
+            }
+            else if (match[6] !== undefined) {
+                nodes.push({ type: "text", text: match[6], marks: [{ type: "bold" }, { type: "italic" }] });
+            }
+            else if (match[7] !== undefined) {
+                nodes.push({ type: "text", text: match[7], marks: [{ type: "bold" }] });
+            }
+            else if (match[8] !== undefined) {
+                nodes.push({ type: "text", text: match[8], marks: [{ type: "italic" }] });
+            }
+            else if (match[9] !== undefined) {
+                nodes.push({ type: "text", text: match[9], marks: [{ type: "strike" }] });
+            }
+            else if (match[10] !== undefined) {
+                // Inline math: $...$
+                nodes.push({ type: "inlineMath", attrs: { latex: match[10], evaluate: "no", display: "no" } });
+            }
+            else if (match[11] !== undefined) {
+                nodes.push({ type: "hardBreak" });
+            }
+            lastIndex = regex.lastIndex;
+        }
+        if (lastIndex < text.length) {
+            nodes.push({ type: "text", text: text.slice(lastIndex) });
+        }
+        return nodes.length > 0 ? nodes : [{ type: "text", text }];
+    }
+    // --- Safe HTML preview (for metadata thumbnail generation) ---
+    function escapeHtml(text) {
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    }
+    function trustedPreviewImageSrc(src) {
+        if (typeof src !== "string")
+            return undefined;
+        const trimmed = src.trim();
+        if (!trimmed)
+            return undefined;
+        if (/^data:image\/(?:png|jpe?g|gif|webp);base64,/i.test(trimmed))
+            return trimmed;
+        if (trimmed.startsWith("/asset/") || trimmed.startsWith("/assets/"))
+            return trimmed;
+        try {
+            const url = new URL(trimmed);
+            if ((url.protocol === "http:" || url.protocol === "https:") && url.pathname.startsWith("/asset/")) {
+                return trimmed;
+            }
+            if ((url.protocol === "http:" || url.protocol === "https:") && url.pathname.startsWith("/assets/")) {
+                return trimmed;
+            }
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+    function renderPreviewMediaPlaceholder(kind, label) {
+        const detail = label?.trim();
+        return `<div class="note-preview-media-placeholder"><span>${escapeHtml(kind)}</span>${detail ? `<small>${escapeHtml(detail)}</small>` : ""}</div>`;
+    }
+    function normalizePreviewText(text) {
+        return text.replace(/\s+/g, " ").trim().toLowerCase();
+    }
+    function previewPlainText(node) {
+        switch (node.type) {
+            case "paragraph":
+            case "heading":
+                return (node.content ?? []).map(previewPlainText).join("");
+            case "text":
+                return node.text ?? "";
+            case "hardBreak":
+                return " ";
+            case "inlineMath":
+                return node.attrs?.latex ?? "";
+            case "image":
+                return node.attrs?.alt ?? "";
+            default:
+                return "";
+        }
+    }
+    function renderPreviewImage(node, mode) {
+        const src = trustedPreviewImageSrc(node.attrs?.src);
+        const alt = typeof node.attrs?.alt === "string" ? node.attrs.alt : "";
+        if (!src) {
+            return mode === "inline"
+                ? `<span class="note-preview-media-chip">Image</span>`
+                : renderPreviewMediaPlaceholder("Image", alt || "Preview unavailable");
+        }
+        const img = `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}" loading="lazy" decoding="async">`;
+        if (mode === "inline")
+            return `<span class="note-preview-image-inline">${img}</span>`;
+        const caption = alt ? `<figcaption>${escapeHtml(alt)}</figcaption>` : "";
+        return `<figure class="note-preview-figure">${img}${caption}</figure>`;
+    }
+    function renderPreviewInline(nodes) {
+        let result = "";
+        for (const node of nodes) {
+            if (node.type === "text") {
+                let text = escapeHtml(node.text ?? "");
+                if (node.marks) {
+                    for (const mark of node.marks) {
+                        switch (mark.type) {
+                            case "bold":
+                                text = `<strong>${text}</strong>`;
+                                break;
+                            case "italic":
+                                text = `<em>${text}</em>`;
+                                break;
+                            case "code":
+                                text = `<code>${text}</code>`;
+                                break;
+                            case "strike":
+                                text = `<s>${text}</s>`;
+                                break;
+                            case "link":
+                                text = `<span class="note-preview-link">${text}</span>`;
+                                break;
+                        }
+                    }
+                }
+                result += text;
+            }
+            else if (node.type === "hardBreak") {
+                result += "<br>";
+            }
+            else if (node.type === "inlineMath") {
+                const latex = escapeHtml(node.attrs?.latex ?? "");
+                const display = node.attrs?.display === "yes";
+                result += `<span class="${display ? "note-preview-math note-preview-math--display" : "note-preview-math"}">${display ? "$$" : "$"}${latex}${display ? "$$" : "$"}</span>`;
+            }
+            else if (node.type === "image") {
+                result += renderPreviewImage(node, "inline");
+            }
+        }
+        return result;
+    }
+    function renderPreviewCell(node) {
+        if (node.type === "paragraph")
+            return renderPreviewInline(node.content ?? []);
+        const firstChild = node.content?.[0];
+        if (firstChild?.type === "paragraph")
+            return renderPreviewInline(firstChild.content ?? []);
+        if (node.content)
+            return renderPreviewHtml(node.content, 2);
+        return renderPreviewInline([node]);
+    }
+    function renderPreviewTable(node) {
+        const rows = node.content ?? [];
+        const visibleRows = rows.slice(0, 4);
+        const html = visibleRows
+            .map((row) => {
+            const cells = (row.content ?? []).slice(0, 4);
+            return `<tr>${cells
+                .map((cell) => {
+                const tag = cell.type === "tableHeader" ? "th" : "td";
+                return `<${tag}>${renderPreviewCell(cell)}</${tag}>`;
+            })
+                .join("")}</tr>`;
+        })
+            .join("");
+        const overflow = rows.length > visibleRows.length
+            ? `<div class="note-preview-table-more">+${rows.length - visibleRows.length} rows</div>`
+            : "";
+        return `<div class="note-preview-table-wrap"><table>${html}</table>${overflow}</div>`;
+    }
+    function renderPreviewBlock(node) {
+        switch (node.type) {
+            case "paragraph":
+                return `<p>${renderPreviewInline(node.content ?? [])}</p>`;
+            case "heading": {
+                const level = Math.min(node.attrs?.level ?? 1, 6);
+                return `<h${level}>${renderPreviewInline(node.content ?? [])}</h${level}>`;
+            }
+            case "bulletList":
+                return `<ul>${(node.content ?? [])
+                    .map((item) => `<li>${renderPreviewBlock((item.content ?? [])[0] ?? { type: "paragraph", content: [] })}</li>`)
+                    .join("")}</ul>`;
+            case "orderedList":
+                return `<ol>${(node.content ?? [])
+                    .map((item) => `<li>${renderPreviewBlock((item.content ?? [])[0] ?? { type: "paragraph", content: [] })}</li>`)
+                    .join("")}</ol>`;
+            case "taskList":
+                return `<ul class="note-preview-task-list">${(node.content ?? [])
+                    .map((item) => {
+                    const checked = item.attrs?.checked ? " checked" : "";
+                    const inner = renderPreviewBlock((item.content ?? [])[0] ?? { type: "paragraph", content: [] });
+                    return `<li><input type="checkbox"${checked} disabled>${inner}</li>`;
+                })
+                    .join("")}</ul>`;
+            case "blockquote":
+                return `<blockquote>${renderPreviewHtml(node.content ?? [], 10)}</blockquote>`;
+            case "codeBlock": {
+                const rawCode = (node.content ?? []).map((c) => c.text ?? "").join("\n");
+                const lines = rawCode.split("\n");
+                const preview = lines.length > 4 ? [...lines.slice(0, 4), "…"].join("\n") : rawCode;
+                return `<pre><code>${escapeHtml(preview)}</code></pre>`;
+            }
+            case "horizontalRule":
+                return `<hr>`;
+            case "image":
+                return renderPreviewImage(node, "block");
+            case "video":
+                return renderPreviewMediaPlaceholder("Video");
+            case "mermaid": {
+                const firstLine = String(node.attrs?.content ?? "")
+                    .trim()
+                    .split("\n")[0];
+                return `<div class="note-preview-diagram"><span>Diagram</span>${firstLine ? `<code>${escapeHtml(firstLine)}</code>` : ""}</div>`;
+            }
+            case "table":
+                return renderPreviewTable(node);
+            default:
+                if (node.content)
+                    return renderPreviewHtml(node.content, 10);
+                return "";
+        }
+    }
+    function renderPreviewHtml(nodes, maxBlocks, options) {
+        let count = 0;
+        let result = "";
+        const normalizedTitle = normalizePreviewText(options?.title ?? "");
+        for (let index = 0; index < nodes.length; index++) {
+            const node = nodes[index];
+            if (index === 0 && normalizedTitle && normalizePreviewText(previewPlainText(node)) === normalizedTitle) {
+                continue;
+            }
+            if (count >= maxBlocks)
+                break;
+            const html = renderPreviewBlock(node);
+            if (html)
+                count++;
+            result += html;
+        }
+        return result;
+    }
+    /**
+     * Generate safe, escaped HTML snippet from Tiptap JSON for note card thumbnails.
+     * Produces a compact multi-block preview. Text is HTML-escaped, media is limited
+     * to trusted image sources, and no external HTML is rendered.
+     */
+    function toPreviewHtml(content, options) {
+        if (!content || typeof content !== "object")
+            return "";
+        const doc = content;
+        if (doc.type !== "doc")
+            return "";
+        return renderPreviewHtml(doc.content ?? [], options?.maxBlocks ?? DEFAULT_PREVIEW_BLOCKS, { title: options?.title });
+    }
+    NoteMarkdown.toPreviewHtml = toPreviewHtml;
+})(NoteMarkdown || (NoteMarkdown = {}));

package/dist/path.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Extract the last path segment (filename / directory name).
+ * Handles both forward slash and backslash separators.
+ */
+export declare function getFilename(path: string | undefined): string;
+/**
+ * Extract the parent directory of a path, with a trailing separator.
+ * Handles both forward slash and backslash — backslashes are normalized to forward slashes in output.
+ *
+ *   "/home/user/projects" → "/home/user/"
+ *   "C:\\Users\\projects" → "C:/Users/"
+ *   "~" → ""
+ *   "/" → "/"
+ */
+export declare function getDirectory(path: string | undefined): string;
+/**
+ * Return the file extension (last dot-segment), or the full path if no dot exists.
+ */
+export declare function getFileExtension(path: string | undefined): string;
+/**
+ * Parse a user-typed path string into a parent-directory + search-query pair.
+ *
+ * Rules (in order):
+ * 1. Empty input → homeDir with no query
+ * 2. Expand "~" and "~/..." using homeDir
+ * 3. Normalize backslashes to forward slashes
+ * 4. Absolute paths (Unix `/`, Windows `C:/`, UNC `//`) → split on last `/`; Windows drive roots stay rooted at `C:/`
+ * 5. Relative paths → homeDir is the parent, the whole input is the query
+ *
+ *   resolvePathInput("~/projects/myapp", "/home/user") → { path: "/home/user/projects", query: "myapp" }
+ *   resolvePathInput("C:\\Users\\me", "/home/user")    → { path: "C:/Users", query: "me" }
+ *   resolvePathInput("D:\\data", "/home/user")         → { path: "D:/", query: "data" }
+ *   resolvePathInput("D:", "/home/user")               → { path: "D:/", query: "" }
+ *   resolvePathInput("myproject", "/home/user")         → { path: "/home/user", query: "myproject" }
+ */
+export declare function resolvePathInput(input: string, homeDir: string): {
+    path: string;
+    query: string;
+};