@p-buddy/parkdown 0.0.1 → 0.0.3

package/src/include.test.ts

@@ -1,369 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { dedent } from "ts-dedent";
-import { extractContent, getAllPositionNodes, nodeSort, parse } from "./utils";
-import { PsuedoFilesystem, lorem } from "./utils.test";
-import { join } from "node:path";
-import {
-  getReplacementTargets,
-  isSpecialLink,
-  applyHeadingDepth,
-  extendGetRelativePathContent,
-  recursivelyPopulateInclusions,
-  nodeDepthFinder,
-  specialComment,
-  isSpecialComment,
-  getTopLevelCommentBlocks,
-} from "./include";
-
-describe(isSpecialLink.name, () => {
-  const check = (md: string, expectation: boolean) =>
-    getAllPositionNodes(parse.md(md), "link")
-      .forEach(node => expect(isSpecialLink(node)).toBe(expectation));
-
-  const cases = {
-    "non-link": ["test", false],
-    "link has text": ["[test](http://example.com)", false],
-    "link has no text, but unsupported target": ["[](file.md)", false],
-    "web link": ["[](http://example.com)", true],
-    "relative file, same directory": ["[](./file.md)", true],
-    "relative file, different directory": ["[](../file.md)", true],
-  } as const;
-
-  for (const [description, [md, expectation]] of Object.entries(cases))
-    test(description, () => check(md, expectation));
-});
-
-describe(nodeDepthFinder.name, () => {
-  test("find depth in lorem", () => {
-    for (const markdown of lorem.md) {
-      const headings = markdown.split("\n")
-        .map((content, index) => ({ content, line: index + 1 }))
-        .filter(({ content }) => content.startsWith("#"))
-        .map(heading => ({ ...heading, depth: heading.content.match(/^#+/)?.[0].length }));
-      const ast = parse.md(markdown);
-      const findDepth = nodeDepthFinder(ast);
-      let index = headings.length - 1;
-      for (const node of getAllPositionNodes(ast).sort(nodeSort.reverse)) {
-        if (node.position.start.line < headings[index].line) index--;
-        const depth = findDepth(node);
-        expect(depth).toBe(headings[index].depth,);
-      }
-    }
-  });
-});
-
-describe('applyHeadingDepth', () => {
-  test('should increase heading levels by the specified depth', () => {
-    const markdown = "# Heading 1\n\n## Heading 2\n\n### Heading 3";
-    const result = applyHeadingDepth(markdown, 1);
-    expect(result).toBe("## Heading 1\n\n### Heading 2\n\n#### Heading 3");
-  });
-
-  test('should decrease heading levels by the specified depth', () => {
-    const markdown = "### Heading 3\n\n## Heading 2\n\n# Heading 1";
-    const result = applyHeadingDepth(markdown, -1);
-    expect(result).toBe("## Heading 3\n\n# Heading 2\n\n# Heading 1");
-  });
-
-  test('should cap heading levels at 6', () => {
-    const markdown = "#### Heading 4\n\n##### Heading 5\n\n###### Heading 6";
-    const result = applyHeadingDepth(markdown, 2);
-    expect(result).toBe("###### Heading 4\n\n###### Heading 5\n\n###### Heading 6");
-  });
-
-  test('should not modify non-heading content', () => {
-    const markdown = "# Heading 1\n\nSome regular text\n\n## Heading 2\n\n- List item 1\n- List item 2";
-    const result = applyHeadingDepth(markdown, 1);
-    expect(result).toBe("## Heading 1\n\nSome regular text\n\n### Heading 2\n\n- List item 1\n- List item 2");
-  });
-
-  test('should handle headings with different formatting', () => {
-    const markdown = "# *Italic Heading*\n\n## **Bold Heading**\n\n### `Code Heading`";
-    const result = applyHeadingDepth(markdown, 1);
-    expect(result).toBe("## *Italic Heading*\n\n### **Bold Heading**\n\n#### `Code Heading`");
-  });
-
-  test('should handle headings with special characters', () => {
-    const markdown = "# Heading with & special < characters >";
-    const result = applyHeadingDepth(markdown, 2);
-    expect(result).toBe("### Heading with & special < characters >");
-  });
-
-  test('should accept an existing AST as input', () => {
-    const markdown = "# Heading 1\n\n## Heading 2";
-    const ast = parse.md(markdown);
-    const result = applyHeadingDepth(markdown, 2, ast);
-    expect(result).toBe("### Heading 1\n\n#### Heading 2");
-  });
-});
-
-describe(getTopLevelCommentBlocks.name, () => {
-  test("problematic case", () => {
-    const content = dedent`
-      # Main heading
-
-      [](./child/README.md)
-      <!-- p▼ Begin -->
-      ## Child heading
-
-      [](./grandchild/README.md)
-      <!-- p▼ Begin -->
-      ### Grandchild heading
-
-      Hello!
-      <!-- p▼ End -->
-      <!-- p▼ End -->
-
-      End
-    `;
-    const ast = parse.md(content);
-    const openingComments = getAllPositionNodes(ast, "html").filter(isSpecialComment("begin"));
-    const closingComments = getAllPositionNodes(ast, "html").filter(isSpecialComment("end"));
-    expect(openingComments.length).toBe(2);
-    expect(closingComments.length).toBe(2);
-    const blocks = getTopLevelCommentBlocks(openingComments, closingComments);
-    expect(blocks.length).toBe(1);
-    expect(blocks[0].open).toBe(openingComments[0]);
-    expect(blocks[0].close).toBe(closingComments[1]);
-  })
-});
-
-describe(extendGetRelativePathContent.name, () => {
-  test('should call original function with resolved path', () => {
-    const filesystem = new PsuedoFilesystem({
-      root: { base: "", child: { a: "", b: "", nested: { a: "" } } }
-    }, { setContentToPath: true });
-
-    const fromRoot = (path: string) => filesystem.getFileFromAbsolutePath(join("root", path));
-
-    expect(fromRoot("./base")).toBe("root/base");
-    expect(fromRoot("./child/a")).toBe("root/child/a");
-    expect(fromRoot("./child/b")).toBe("root/child/b");
-    expect(fromRoot("./child/nested/a")).toBe("root/child/nested/a");
-
-    const extended = extendGetRelativePathContent(fromRoot, { url: "./child/a" });
-    expect(extended("../base")).toBe("root/base");
-    expect(extended("./a")).toBe("root/child/a");
-    expect(extended("./b")).toBe("root/child/b");
-    expect(extended("./nested/a")).toBe("root/child/nested/a");
-  });
-});
-
-
-
-describe(recursivelyPopulateInclusions.name, () => {
-  test("basic unpopulated", () => {
-    const filesystem = new PsuedoFilesystem({
-      "README.md": dedent`
-        # Main heading
-
-        [](./child/README.md)
-
-        End parent
-      `,
-      child: {
-        "README.md": dedent`
-          # Child heading
-
-          End child
-        `,
-      }
-    });
-
-    const fromRoot = (path: string) => filesystem.getFileFromAbsolutePath(join("", path));
-
-    const result = recursivelyPopulateInclusions(filesystem.getFileFromAbsolutePath("README.md"), 0, fromRoot);
-    expect(result).toBe(dedent`
-      # Main heading
-
-      [](./child/README.md)
-      ${specialComment.begin}
-      ## Child heading
-
-      End child
-      ${specialComment.end}
-
-      End parent
-    `)
-    expect(result).toBe(recursivelyPopulateInclusions(result, 0, fromRoot));
-  });
-
-  test('should apply modifications to all top-level links in a markdown file', () => {
-
-    const filesystem = new PsuedoFilesystem({
-      "README.md": dedent`
-        # Main heading
-
-        [](./child/README.md)
-
-        End
-      `,
-      child: {
-        "README.md": dedent`
-          # Child heading
-
-          [](./grandchild/README.md)
-          ${specialComment.begin}
-          THIS SHOULD BE DELETED 
-          ${specialComment.end}
-        `,
-        grandchild: {
-          "README.md": dedent`
-            # Grandchild heading
-
-            Hello!
-          `,
-        }
-      }
-    });
-
-    const fromRoot = (path: string) => filesystem.getFileFromAbsolutePath(join("", path));
-
-    const result = recursivelyPopulateInclusions(filesystem.getFileFromAbsolutePath("README.md"), 0, fromRoot);
-    expect(result).toBe(recursivelyPopulateInclusions(result, 0, fromRoot));
-  });
-
-  test('with code boundary', () => {
-    const filesystem = new PsuedoFilesystem({
-      "README.md": dedent`
-        # Main heading
-
-        [](./child/file.ts?boundary=boundary)
-
-        End
-      `,
-      child: {
-        "file.ts": dedent`
-          if (true) {
-            /* boundary */
-            const x = 5;
-            /* boundary */
-          }
-        `,
-      }
-    });
-
-    const fromRoot = (path: string) => filesystem.getFileFromAbsolutePath(join("", path));
-
-    const result = recursivelyPopulateInclusions(filesystem.getFileFromAbsolutePath("README.md"), 0, fromRoot);
-    expect(result).toBe(dedent`
-      # Main heading
-
-      [](./child/file.ts?boundary=boundary)
-      ${specialComment.begin}
-      \`\`\`ts
-      const x = 5;
-      \`\`\`
-      ${specialComment.end}
-      
-      End`
-    )
-  })
-
-  test('with wrapped in dropdown', () => {
-    const filesystem = new PsuedoFilesystem({
-      "README.md": dedent`
-        # Main heading
-
-        [](./child/README.md?tag=dropdown('Open-me,-please!'))
-      `,
-      child: {
-        "README.md": dedent`
-          Hello!
-        `,
-      }
-    });
-
-    const fromRoot = (path: string) => filesystem.getFileFromAbsolutePath(join("", path));
-
-    const result = recursivelyPopulateInclusions(filesystem.getFileFromAbsolutePath("README.md"), 0, fromRoot);
-    expect(result).toBe(dedent`
-      # Main heading
-
-      [](./child/README.md?tag=dropdown('Open-me,-please!'))
-      ${specialComment.begin}
-
-      <details>
-      <summary>Open me, please!</summary>
-      
-      Hello!
-      </details>
-
-      ${specialComment.end}`
-    );
-  })
-});
-
-describe(getReplacementTargets.name, () => {
-  test('should return empty array for no special links or comments', () => {
-    const emptyMarkdown = "# Just a heading\n\nNo special links or comments here.";
-    const emptyAst = parse.md(emptyMarkdown);
-    expect(getReplacementTargets(emptyMarkdown, emptyAst)).toEqual([]);
-  });
-
-  test('should handle single unpopulated special link (no closing comment)', () => {
-    const singleLinkMarkdown = "# Heading\n\n[](http://example.com)";
-    const singleLinkAst = parse.md(singleLinkMarkdown);
-    const singleLinkTargets = getReplacementTargets(singleLinkMarkdown, singleLinkAst);
-    expect(singleLinkTargets.length).toBe(1);
-    expect(singleLinkTargets[0].url).toBe("http://example.com");
-    expect(singleLinkTargets[0].headingDepth).toBe(1);
-    expect(extractContent(singleLinkMarkdown, singleLinkTargets[0])).toBe("[](http://example.com)");
-  });
-
-  test('should handle special link with closing comment', () => {
-    const linkWithCommentMarkdown =
-      "# Main heading\n\n" +
-      "## Section\n\n" +
-      "[](./file.md)\n" +
-      specialComment.begin + "\n" +
-      "Some content\n" +
-      specialComment.end;
-    const linkWithCommentAst = parse.md(linkWithCommentMarkdown);
-    const linkWithCommentTargets = getReplacementTargets(linkWithCommentMarkdown, linkWithCommentAst);
-    expect(linkWithCommentTargets.length).toBe(1);
-    expect(linkWithCommentTargets[0].url).toBe("./file.md");
-    expect(linkWithCommentTargets[0].headingDepth).toBe(2);
-    expect(
-      extractContent(linkWithCommentMarkdown, linkWithCommentTargets[0])
-    ).toBe(`[](./file.md)\n${specialComment.begin}\nSome content\n${specialComment.end}`);
-  });
-
-  test('should handle multiple links and comments', () => {
-    const complexMarkdown =
-      "# Main heading\n\n" +
-      "## First section\n\n" +
-      "[](./first.md)\n" +
-      specialComment.begin + "\n" +
-      "Some content\n" +
-      specialComment.end + "\n\n" +
-      "## Second section\n\n" +
-      "[](./second.md)\n" +
-      specialComment.begin + "\n" +
-      "More content\n" +
-      specialComment.end + "\n\n" +
-      "## Third section\n\n" +
-      "[](http://example.com)";
-    const complexAst = parse.md(complexMarkdown);
-    const complexTargets = getReplacementTargets(complexMarkdown, complexAst);
-    expect(complexTargets.length).toBe(3);
-
-    expect(complexTargets[0].url).toBe("./first.md");
-    expect(complexTargets[0].headingDepth).toBe(2);
-    expect(
-      extractContent(complexMarkdown, complexTargets[0])
-    ).toBe(`[](./first.md)\n${specialComment.begin}\nSome content\n${specialComment.end}`);
-
-    expect(complexTargets[1].url).toBe("./second.md");
-    expect(complexTargets[1].headingDepth).toBe(2);
-    expect(
-      extractContent(complexMarkdown, complexTargets[1])
-    ).toBe(`[](./second.md)\n${specialComment.begin}\nMore content\n${specialComment.end}`);
-
-    expect(complexTargets[2].url).toBe("http://example.com");
-    expect(complexTargets[2].headingDepth).toBe(2);
-    expect(
-      extractContent(complexMarkdown, complexTargets[2])
-    ).toBe("[](http://example.com)");
-  });
-});

package/src/include.ts

@@ -1,252 +0,0 @@
-import { URLSearchParams } from "node:url";
-import { getAllPositionNodes, parse, hasPosition, linkHasNoText, lined, spaced, Html, nodeSort, replaceWithContent, getContentInBetween } from "./utils";
-import { type AstRoot, type Link, type PositionNode, type HasPosition, COMMA_NOT_IN_PARENTHESIS } from "./utils"
-import { dirname, join, basename } from "node:path";
-import { wrap } from "./wrap";
-import { applyRegion, extractContentWithinRegionSpecifiers } from "./region";
-
-const specialLinkTargets = ["http", "./", "../"] as const;
-const isSpecialLinkTarget = ({ url }: Link) => specialLinkTargets.some(target => url.startsWith(target));
-
-export type SpecialLink = PositionNode<"link">;
-export const isSpecialLink = (node: Link): node is SpecialLink =>
-  hasPosition(node) && linkHasNoText(node) && isSpecialLinkTarget(node);
-export const specialLinkText = ({ url }: Pick<SpecialLink, "url">, relative?: string) =>
-  `[](${relative ? join(relative, url) : url})` as const;
-
-type CommentType = "begin" | "end";
-
-export const specialComment = {
-  _open: "<!--" as const,
-  _close: "-->" as const,
-  _flag: "p▼" as const,
-  get begin() { return spaced(specialComment._open, specialComment._flag, "BEGIN", specialComment._close) },
-  get end() { return spaced(specialComment._open, specialComment._flag, "END", specialComment._close) },
-};
-
-export type SpecialComment<T extends CommentType = CommentType> = PositionNode<"html"> & { value: typeof specialComment[T] };
-
-export const isSpecialComment = <T extends CommentType>(type: T) =>
-  (node: Html): node is SpecialComment<T> => hasPosition(node) && node.value === specialComment[type];
-
-export type ReplacementTarget = {
-  url: string;
-  headingDepth: number;
-  inline: boolean;
-} & HasPosition;
-
-const replaceUnpopulated = (
-  { position, url, siblingCount }: SpecialLink, headingDepth: number
-): ReplacementTarget => ({ position, url, headingDepth, inline: siblingCount >= 1 })
-
-const replacePopulated = (
-  { position: { start }, url, siblingCount }: SpecialLink, { position: { end } }: SpecialComment<"end">, headingDepth: number
-): ReplacementTarget => ({ position: { start, end }, url, headingDepth, inline: siblingCount >= 1 });
-
-export const getReplacementContent = (target: Pick<ReplacementTarget, "url" | "inline">, content: string, relative?: string) =>
-  target.inline
-    ? `${specialLinkText(target, relative)} ${specialComment.begin} ${content} ${specialComment.end}` as const
-    : lined(specialLinkText(target, relative), specialComment.begin, content, specialComment.end);
-
-export const nodeDepthFinder = (ast: AstRoot) => {
-  const headingDepth = getAllPositionNodes(ast, "heading")
-    .reduce((acc, { position, depth }) => acc.set(position.start.line, depth), new Map<number, number>())
-  return (node: HasPosition) => {
-    for (let i = node.position.start.line; i >= 1; i--) {
-      const depth = headingDepth.get(i);
-      if (depth) return depth;
-    }
-    return 0;
-  }
-}
-
-const error = {
-  openingCommentDoesNotFollowLink: ({ position: { start } }: SpecialComment<"begin">) =>
-    new Error(`Opening comment (@${start.line}:${start.column}) does not follow link`),
-  closingCommentNotMatchedToOpening: ({ position: { start } }: SpecialComment<"end">) =>
-    new Error(`Closing comment (@${start.line}:${start.column}) does not match to opening comment`),
-  openingCommentNotClosed: ({ position: { start } }: SpecialComment<"begin">) =>
-    new Error(`Opening comment (@${start.line}:${start.column}) is not followed by a closing comment`),
-}
-
-export const getTopLevelCommentBlocks = (
-  openingComments: SpecialComment<"begin">[], closingComments: SpecialComment<"end">[]
-) => {
-  const blocks: { open: SpecialComment<"begin">, close: SpecialComment<"end"> }[] = [];
-
-  const combined = [
-    ...openingComments.map(node => ({ node, type: "open" as const })),
-    ...closingComments.map(node => ({ node, type: "close" as const }))
-  ].sort((a, b) => nodeSort(a.node, b.node));
-
-  const stack: (typeof combined[number] & { type: "open" })[] = [];
-
-  for (const item of combined)
-    if (item.type === "open") stack.push(item)
-    else {
-      const close = item.node as SpecialComment<"end">;
-      if (stack.length === 0)
-        throw error.closingCommentNotMatchedToOpening(close);
-      const open = stack.pop()!.node;
-      if (stack.length > 0) continue;
-      blocks.push({ open, close });
-    }
-
-  if (stack.length > 0)
-    throw error.openingCommentNotClosed(stack[0].node);
-
-  return blocks;
-}
-
-type CommentBlocks = ReturnType<typeof getTopLevelCommentBlocks>;
-
-export const matchCommentBlocksToLinks = (
-  markdown: string, links: SpecialLink[], blocks: CommentBlocks
-) => {
-  const linkCandidates = [...links].sort(nodeSort);
-  const results: (SpecialLink | [SpecialLink, CommentBlocks[number]])[] = [];
-
-  [...blocks]
-    .sort((a, b) => nodeSort.reverse(a.open, b.open))
-    .forEach(block => {
-      while (linkCandidates.length > 0) {
-        const link = linkCandidates.pop()!;
-        if (link.position.start.offset < block.open.position.start.offset) {
-          if (getContentInBetween(markdown, link, block.open).trim() !== "")
-            throw error.openingCommentDoesNotFollowLink(block.open);
-          return results.push([link, block]);
-        }
-        results.push(link);
-      }
-      throw error.openingCommentDoesNotFollowLink(block.open);
-    });
-
-  results.push(...linkCandidates.reverse());
-  return results.reverse();
-}
-
-export const getReplacementTargets = (markdwn: string, ast?: AstRoot): ReplacementTarget[] => {
-  ast ??= parse.md(markdwn);
-  const findDepth = nodeDepthFinder(ast);
-  const specialLinks = getAllPositionNodes(ast, "link").filter(isSpecialLink);
-  const htmlNodes = getAllPositionNodes(ast, "html").sort(nodeSort);
-  const openingComments = htmlNodes.filter(isSpecialComment("begin"));
-  const closingComments = htmlNodes.filter(isSpecialComment("end"));
-  const blocks = getTopLevelCommentBlocks(openingComments, closingComments);
-  const resolved = matchCommentBlocksToLinks(markdwn, specialLinks, blocks)
-  return resolved.map(block => Array.isArray(block)
-    ? replacePopulated(block[0], block[1].close, findDepth(block[0]))
-    : replaceUnpopulated(block, findDepth(block)))
-}
-
-export type GetRelativePathContent = (path: string) => string;
-
-export const extendGetRelativePathContent = (
-  getRelativePathContent: GetRelativePathContent, { url }: Pick<ReplacementTarget, "url">
-) => ((path) => getRelativePathContent(join(dirname(url), path))) satisfies GetRelativePathContent;
-
-const clampHeadingSum = (...toSum: number[]) => {
-  const sum = toSum.reduce((a, b) => a + b, 0);
-  return Math.min(Math.max(sum, 1), 6) as 1 | 2 | 3 | 4 | 5 | 6;
-}
-
-export const applyHeadingDepth = (markdown: string, headingDepth: number, ast?: AstRoot) => {
-  if (headingDepth === 0) return markdown;
-  ast ??= parse.md(markdown);
-  const nodes = getAllPositionNodes(ast, "heading");
-  const lines = markdown.split("\n");
-  for (const node of nodes) {
-    const { depth, position: { start, end } } = node;
-    const adjusted = clampHeadingSum(depth, headingDepth);
-    const text = lines[start.line - 1].slice(depth, end.column);
-    const replacement = `#`.repeat(adjusted) + text;
-    lines[start.line - 1] = replacement;
-    node.depth = adjusted;
-  }
-  return lines.join("\n");
-}
-
-export const removePopulatedInclusions = (markdown: string) =>
-  getReplacementTargets(markdown)
-    .reverse()
-    .sort(nodeSort.reverse)
-    .reduce((md, target) => replaceWithContent(md, specialLinkText(target), target), markdown);
-
-export const recursivelyPopulateInclusions = (
-  markdown: string,
-  headingDepth: number,
-  getRelativePathContent: GetRelativePathContent,
-  basePath?: string
-) => {
-  markdown = removePopulatedInclusions(markdown);
-  markdown = applyHeadingDepth(markdown, headingDepth);
-  const ast = parse.md(markdown);
-
-  return getReplacementTargets(markdown, ast)
-    .sort(nodeSort)
-    .reverse()
-    .map(target => {
-      const { url, headingDepth } = target;
-      const [base, ...splitOnMark] = basename(url).split("?");
-      const extension = base.split(".").pop() ?? "";
-      const query = splitOnMark.join("?");
-      const dir = dirname(url);
-      const path = join(dir, base);
-
-      if (url.startsWith("./") || url.startsWith("../")) {
-        let content = getRelativePathContent(path);
-
-        /** p▼: query */
-        const params = new URLSearchParams(query);
-        /** p▼: query */
-
-        /** p▼: query */
-        const regions = params.get("region")?.split(COMMA_NOT_IN_PARENTHESIS);
-        /** p▼: query */
-        content = regions?.reduce((content, region) => applyRegion(content, region), content) ?? content;
-
-        /** p▼: query */
-        const skip = params.has("skip");
-        /** p▼: query */
-
-        /** p▼: query */
-        const headingModfiier = params.get("heading") ?? 0;
-        /** p▼: query */
-
-        /** p▼: query */
-        const inlineOverride = params.has("inline");
-        /** p▼: query */
-
-        let { inline } = target;
-        if (inlineOverride) inline = true;
-
-        if (!skip)
-          /** p▼: Default-Behavior */
-          if (extension === "md") {
-            /** p▼: ... */
-            const getContent = extendGetRelativePathContent(getRelativePathContent, target);
-            const relative = basePath ? join(basePath, dir) : dir;
-            const depth = clampHeadingSum(headingDepth, Number(headingModfiier));
-            /** p▼: ... */
-            content = recursivelyPopulateInclusions(content, /** p▼: ... */ depth, getContent, relative /** p▼: ... */);
-          }
-          else if (/^(js|ts)x?|svelte$/i.test(extension))
-            content = wrap(content, "code", /** p▼: ... */ { extension, inline } /** p▼: ... */);
-        /** p▼: Default-Behavior */
-
-        /** p▼: query */
-        const wraps = params.get("wrap")?.split(COMMA_NOT_IN_PARENTHESIS);
-        /** p▼: query */
-        content = wraps
-          ?.reduce((content, query) => wrap(content, query, { extension, inline }), content)
-          ?? content;
-
-        return { target, content: getReplacementContent(target, content, basePath) };
-      }
-      else if (url.startsWith("http"))
-        throw new Error("External web links are not implemented yet");
-      else
-        throw new Error(`Unsupported link type: ${url}`);
-    })
-    .reduce((acc, { target, content }) => replaceWithContent(acc, content, target), markdown);
-}

package/src/index.ts

@@ -1,35 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { recursivelyPopulateInclusions, removePopulatedInclusions } from "./include";
-import { removeQueryParams } from "./utils";
-
-const read = (path: string) => readFileSync(path, "utf-8");
-
-const tryResolveFile = (file: string) => {
-  const path = resolve(file);
-  const dir = dirname(path);
-  const markdown = read(path);
-  return { markdown, dir, path };
-}
-
-export const populateMarkdownInclusions = (file: string, writeFile = true) => {
-  const { dir, path, markdown } = tryResolveFile(file);
-  const getContent = (relative: string) => read(resolve(dir, removeQueryParams(relative)));
-  const result = recursivelyPopulateInclusions(markdown, 0, getContent);
-  if (writeFile) writeFileSync(path, result);
-  return result;
-};
-
-export const depopulateMarkdownInclusions = (file: string, writeFile = true) => {
-  const { path, markdown } = tryResolveFile(file);
-  const result = removePopulatedInclusions(markdown);
-  if (writeFile) writeFileSync(path, result);
-  return result;
-};
-
-export const remapImportSpecifiers = (file: string, writeFile = true) => {
-  const { path, markdown } = tryResolveFile(file);
-  // const result = remapImports(markdown);
-  // if (writeFile) writeFileSync(path, result);
-  // return result;
-};