@p-buddy/parkdown 0.0.0

package/src/include.ts

@@ -0,0 +1,252 @@
+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

@@ -0,0 +1,35 @@
+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;
+};

package/src/region.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "vitest";
+import { dedent } from "ts-dedent";
+import { extractContentWithinRegionSpecifiers, removeContentWithinRegionSpecifiers, replaceContentWithinRegionSpecifier } from "./region";
+
+describe(extractContentWithinRegionSpecifiers.name, () => {
+  test("basic", () => {
+    const code = dedent`
+      /* id-1 */
+      This content should be extracted
+      /* id-1 */
+
+      This content should not be extracted
+    `;
+    const result = extractContentWithinRegionSpecifiers(code, "id-1");
+    expect(result).toEqual("This content should be extracted");
+  });
+
+  test("nested 1", () => {
+    const code = dedent`
+      /* id-1 */
+      This content should be extracted
+      /* id-2 */ This content should also be extracted /* id-2 */
+      /* id-1 */
+
+      This content should not be extracted
+    `;
+
+    expect(extractContentWithinRegionSpecifiers(code, "id-1"))
+      .toEqual("This content should be extracted\n/* id-2 */ This content should also be extracted /* id-2 */");
+
+    expect(extractContentWithinRegionSpecifiers(code, "id-1", "id-2"))
+      .toEqual("This content should be extracted\nThis content should also be extracted");
+
+    expect(extractContentWithinRegionSpecifiers(code, "id-2"))
+      .toEqual("This content should also be extracted");
+  });
+
+  test("nested 2", () => {
+    const code = dedent`
+      /* id-1 */
+      This content should be extracted
+      /* id-2 */
+      This content should also be extracted
+      /* id-2 */
+      /* id-1 */
+
+      This content should not be extracted
+    `;
+    expect(extractContentWithinRegionSpecifiers(code, "id-1"))
+      .toEqual("This content should be extracted\n/* id-2 */\nThis content should also be extracted\n/* id-2 */");
+
+    // NOTE: Nested full-line comments create extra newlines
+    expect(extractContentWithinRegionSpecifiers(code, "id-1", "id-2"))
+      .toEqual("This content should be extracted\nThis content should also be extracted");
+
+    expect(extractContentWithinRegionSpecifiers(code, "id-2"))
+      .toEqual("This content should also be extracted");
+  });
+
+  test("mixed line and in-line", () => {
+    const code = dedent`
+      /* id */
+      const definitions = [
+        "hello",
+        "world",
+      ] /* id */ satisfies string[];`;
+
+    expect(extractContentWithinRegionSpecifiers(code, "id"))
+      .toEqual(dedent`
+        const definitions = [
+          "hello",
+          "world",
+        ]`
+      );
+  })
+
+  test("split", () => {
+    const code = dedent`
+      /* id */
+      hello,
+      /* id */
+
+      /* id */
+      world
+      /* id */
+
+
+      /* id */
+      !
+      /* id */
+    `;
+
+    expect(extractContentWithinRegionSpecifiers(code, "id"))
+      .toEqual(dedent`
+        hello,
+        world
+        !`
+      );
+  })
+});
+
+describe(removeContentWithinRegionSpecifiers.name, () => {
+  test("basic", () => {
+    const codes = [
+      dedent`
+        hello
+        /* id-1 */
+        This content should be removed
+        /* id-1 */
+        world
+      `,
+      dedent`
+        hello
+        /* id-1 */ This content should be removed /* id-1 */
+        world
+      `
+    ];
+    const expected = "hello\nworld";
+    for (const code of codes) {
+      const result = removeContentWithinRegionSpecifiers(code, "id-1");
+      expect(result).toEqual(expected);
+    }
+
+  });
+});
+
+describe(replaceContentWithinRegionSpecifier.name, () => {
+  test("basic", () => {
+    const code = dedent`
+      /* id */
+      hello
+      /* id */
+    `;
+    const result = replaceContentWithinRegionSpecifier(code, "id", "world");
+    expect(result).toEqual("world");
+  })
+
+  test("inline", () => {
+    const code = dedent`
+      func('hello', 'world', /* ... */ 'ignored', /* ... */)
+    `;
+    const result = replaceContentWithinRegionSpecifier(code, "...");
+    expect(result).toEqual("func('hello', 'world', ...)");
+  })
+})  

package/src/region.ts

@@ -0,0 +1,138 @@
+import { dedent } from "ts-dedent";
+import _extractComments from "extract-comments";
+import { Intervals, sanitize } from "./utils"
+import { createParser, numberedParameters, type MethodDefinition } from "./api/";
+
+/** p▼: definition */
+const definitions = [
+  "extract(id: string, 0?: string, 1?: string, 2?: string)",
+  "remove(id: string, 0?: string, 1?: string, 2?: string)",
+  "replace(id: string, with?: string, space?: string)",
+] /** p▼: definition */ satisfies MethodDefinition[];
+
+const parse = createParser(definitions);
+
+type ExtractedComment = {
+  type: 'BlockComment' | 'LineComment',
+  value: string,
+  range: [number, number],
+  loc: {
+    start: { line: number, column: number },
+    end: { line: number, column: number },
+  },
+  raw: string,
+};
+
+const extractComments = (content: string) => (_extractComments as any)(content) as ExtractedComment[];
+
+const getMatchingComments = (content: string, specifier: string) => extractComments(content)
+  .filter(({ value }) => value.includes(specifier))
+  .sort((a, b) => a.range[0] - b.range[0]);
+
+export const extractContentWithinRegionSpecifiers = (content: string, ...specifiers: string[]) => {
+  if (specifiers.length === 0) return content;
+
+  const slice = ([start, end]: ExtractedComment["range"]) => content.slice(start, end);
+
+  const comments = extractComments(content);
+
+  const extraction = new Intervals();
+  const markers = new Intervals();
+
+  for (const specifier of specifiers) {
+    const matching = comments
+      .filter(({ value }) => value.includes(specifier))
+      .sort((a, b) => a.range[0] - b.range[0]);
+
+    for (let i = 0; i < matching.length - 1; i += 2) {
+      const open = matching[i];
+      const close = matching[i + 1];
+      extraction.push(open.range[1], close.range[0]);
+      const [start, ...rest] = slice([open.range[1], close.range[0]]);
+      const last = rest[rest.length - 1];
+      markers.push(open.range[0], open.range[1] + (Boolean(start.trim()) ? 0 : 1));
+      markers.push(close.range[0], close.range[1] + (Boolean(last.trim()) ? 0 : 1));
+    }
+  }
+
+  extraction.collapse();
+  markers.collapse();
+
+  return dedent(
+    extraction.subtract(markers).map(slice).filter(Boolean).join("")
+  ).trim();
+};
+
+export const removeContentWithinRegionSpecifiers = (content: string, ...specifiers: string[]) => {
+  if (specifiers.length === 0) return content;
+
+  const slice = ([start, end]: ExtractedComment["range"]) => content.slice(start, end);
+  const comments = extractComments(content);
+
+  const markers = new Intervals();
+
+  for (const specifier of specifiers) {
+    const matching = comments
+      .filter(({ value }) => value.includes(specifier))
+      .sort((a, b) => a.range[0] - b.range[0]);
+
+    for (let i = 0; i < matching.length - 1; i += 2) {
+      const open = matching[i];
+      const close = matching[i + 1];
+      const end = slice([close.range[1], close.range[1] + 1]).at(-1);
+      markers.push(open.range[0], end === "\n" ? close.range[1] + 1 : close.range[1]);
+    }
+  }
+
+  markers.collapse();
+
+  const fullContent = new Intervals();
+  fullContent.push(0, content.length);
+  fullContent.subtract(markers);
+
+  return dedent(
+    fullContent.collapse().map(slice).filter(Boolean).join("")
+  ).trim();
+};
+
+export const replaceContentWithinRegionSpecifier = (content: string, specifier: string, replacement?: string, space?: string) => {
+  if (!specifier) return content;
+
+  const matching = getMatchingComments(content, specifier);
+
+  if (matching.length < 2) return content;
+
+  let result = '';
+  let lastEnd = 0;
+  for (let i = 0; i < matching.length - 1; i += 2) {
+    const open = matching[i];
+    const close = matching[i + 1];
+    result += content.slice(lastEnd, open.range[1]);
+    result += sanitize(replacement ?? open.value, space);
+    lastEnd = close.range[0];
+  }
+  result += content.slice(lastEnd);
+
+  const fullContent = new Intervals();
+  fullContent.push(0, result.length);
+  fullContent.subtract(
+    getMatchingComments(result, specifier)
+      .reduce((acc, { range }) => (acc.push(...range), acc), new Intervals())
+  );
+
+  return dedent(
+    fullContent.collapse().map(([start, end]) => result.slice(start, end)).filter(Boolean).join("")
+  ).trim();;
+};
+
+export const applyRegion = (content: string, query: string) => {
+  const result = parse(query);
+  switch (result.name) {
+    case "extract":
+      return extractContentWithinRegionSpecifiers(content, result.id, ...numberedParameters(result));
+    case "remove":
+      return removeContentWithinRegionSpecifiers(content, result.id, ...numberedParameters(result));
+    case "replace":
+      return replaceContentWithinRegionSpecifier(content, result.id, result.with, result.space);
+  }
+}

package/src/remap.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect } from "vitest";
+import { dedent } from "ts-dedent";
+import * as regexp from '@flex-development/import-regex';
+describe("remapImports", () => {
+  test("should remap imports", () => {
+    const code = dedent`
+      import { foo } from "bar";
+      import { baz, type Qux } from "qux";
+      import type { Foo as Bar } from "bar";
+
+      const result = () => {
+      }
+    `;
+
+    let value = code;
+
+    [...code.matchAll(regexp.STATIC_IMPORT_REGEX)]
+      .sort((a, b) => a.index - b.index)
+      .reverse()
+      .forEach((match) => {
+        const { index, groups } = match;
+        if (!groups) return;
+        const { type, imports, specifier } = groups;
+        const remapped = ["import", type, imports, "from", "dingo"].filter(Boolean).join(" ");
+        value = value.slice(0, index) + remapped + value.slice(index + match[0].length);
+      });
+
+    /* 
+        const result = code.replace(regexp.STATIC_IMPORT_REGEX, (match) => {
+          const executed = regexp.STATIC_IMPORT_REGEX.exec(code);
+          console.log(executed);
+          const { type, imports, specifier } = executed?.groups ?? {};
+          return `${type ? "import type" : "import"} ${imports} from "${specifier}"`;
+        }); */
+
+  })
+})

package/src/remap.ts

@@ -0,0 +1,72 @@
+import { getAllPositionNodes, nodeSort, parse, replaceWithContent } from "./utils";
+import * as regexp from '@flex-development/import-regex';
+
+export const paramaterized = {
+  local: "$local",
+}
+
+type FromTo = {
+  raw?: Partial<Record<string, string>>;
+  paramaterized?: Partial<Record<"$local", string>>;
+}
+
+const localFilePrefixes = ["./", "../", "$" /** for aliases (will this have unintended consequences?) */];
+const isLocalSpecifier = (specifier: string) => localFilePrefixes.some(prefix => specifier.startsWith(prefix));
+
+export const remapImports = (markdown: string, { raw, paramaterized }: FromTo) => {
+  const ast = parse.md(markdown);
+  const code = getAllPositionNodes(ast, "code").sort(nodeSort);
+
+  const tryRemapSpecifier = (specifier: string) => {
+    if (paramaterized?.$local && isLocalSpecifier(specifier)) return paramaterized.$local;
+    if (raw?.[specifier]) return raw[specifier];
+    return null;
+  }
+
+  for (const node of code.reverse()) {
+    let { value, lang } = node;
+    switch (lang) {
+      case "ts":
+      case "js":
+      case "tsx":
+      case "jsx":
+        value = remapJsTsImports(value, tryRemapSpecifier);
+        break;
+      case "svelte":
+        value = remapSvelteImports(value, tryRemapSpecifier);
+        break;
+    }
+
+    markdown = replaceWithContent(markdown, value, node);
+  }
+
+  return markdown;
+}
+
+type TryRemapSpecifier = (specifier: string) => string | null;
+
+export const remapJsTsImports = (code: string, remapSpecifier: TryRemapSpecifier) =>
+  [...code.matchAll(regexp.STATIC_IMPORT_REGEX)]
+    .sort((a, b) => a.index - b.index)
+    .reverse()
+    .reduce((acc, match) => {
+      const { index, groups } = match;
+      if (!groups) return acc;
+      const specifier = remapSpecifier(groups.specifier);
+      if (!specifier) return acc;
+      const { type, imports } = groups;
+      const remapped = ["import", type, imports, "from", `"${specifier}"`].filter(Boolean).join(" ");
+      return acc.slice(0, index) + remapped + acc.slice(index + match[0].length);
+    }, code);
+
+const scripTagRegex = () =>
+  // Match a script tag with any attributes, capturing the content between opening and closing tags
+  // <script[^>]*>  - Matches opening script tag with any attributes
+  // ([\s\S]*?)     - Captures all content (including newlines) between tags (non-greedy)
+  // <\/script>     - Matches closing script tag
+  // g              - Global flag to match all occurrences
+  /<script[^>]*>([\s\S]*?)<\/script>/g;
+
+export const remapSvelteImports = (code: string, remapSpecifier: TryRemapSpecifier) =>
+  code.replace(scripTagRegex(), (scriptTag, scriptContent) =>
+    scriptTag.replace(scriptContent, remapJsTsImports(scriptContent, remapSpecifier)));