@codama/fragments 0.1.0

package/dist/rust.browser.mjs

@@ -0,0 +1,322 @@
+import 'fs';
+import { CodamaError, CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, CODAMA_ERROR__VISITORS__RENDER_MAP_KEY_NOT_FOUND } from '@codama/errors';
+import 'path';
+
+// src/core/casing.ts
+function capitalize(str) {
+  if (str.length === 0) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function titleCase(str) {
+  return str.replace(/([A-Z])/g, " $1").split(/[^a-zA-Z0-9]+/).filter((word) => word.length > 0).map(capitalize).join(" ");
+}
+function pascalCase(str) {
+  return titleCase(str).split(" ").join("");
+}
+function camelCase(str) {
+  if (str.length === 0) return str;
+  const pascalStr = pascalCase(str);
+  return pascalStr.charAt(0).toLowerCase() + pascalStr.slice(1);
+}
+function kebabCase(str) {
+  return titleCase(str).split(" ").join("-").toLowerCase();
+}
+function snakeCase(str) {
+  return titleCase(str).split(" ").join("_").toLowerCase();
+}
+
+// src/core/createFragmentTemplate.ts
+function createFragmentTemplate(template, items, isFragment2, mergeFragments2) {
+  const fragments = items.filter(isFragment2);
+  const zippedItems = items.map((item, i) => {
+    const itemPrefix = template[i];
+    if (typeof item === "undefined") return itemPrefix;
+    if (isFragment2(item)) return itemPrefix + item.content;
+    return itemPrefix + String(item);
+  });
+  return mergeFragments2(fragments, () => zippedItems.join("") + template[template.length - 1]);
+}
+function joinPath(...paths) {
+  {
+    return paths.join("/").replace(/\/+/g, "/");
+  }
+}
+function pathDirectory(path) {
+  {
+    return path.substring(0, path.lastIndexOf("/"));
+  }
+}
+function pathBasename(path) {
+  {
+    const slash = path.lastIndexOf("/");
+    return slash >= 0 ? path.substring(slash + 1) : path;
+  }
+}
+function relativePath(from, to) {
+  {
+    throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: "relative" });
+  }
+}
+
+// src/core/fs.ts
+function createDirectory(path) {
+  {
+    throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: "mkdirSync" });
+  }
+}
+function deleteDirectory(path) {
+  {
+    throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: "rmSync" });
+  }
+}
+function writeFile(path, content) {
+  {
+    throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: "writeFileSync" });
+  }
+}
+function fileExists(path) {
+  {
+    throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: "existsSync" });
+  }
+}
+function readFile(path) {
+  {
+    throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: "readFileSync" });
+  }
+}
+function readJson(path) {
+  return JSON.parse(readFile());
+}
+
+// src/core/setFragmentContent.ts
+function setFragmentContent(fragment2, content) {
+  return Object.freeze({ ...fragment2, content });
+}
+
+// src/core/mapFragmentContent.ts
+function mapFragmentContent(fragment2, mapContent) {
+  return setFragmentContent(fragment2, mapContent(fragment2.content));
+}
+async function mapFragmentContentAsync(fragment2, mapContent) {
+  return setFragmentContent(fragment2, await mapContent(fragment2.content));
+}
+function createRenderMap(pathOrEntries, content) {
+  let entries = [];
+  if (typeof pathOrEntries === "string" && content !== void 0) {
+    entries = [[pathOrEntries, content]];
+  } else if (typeof pathOrEntries === "object" && pathOrEntries !== null) {
+    entries = Object.entries(pathOrEntries).flatMap(
+      ([key, value]) => value === void 0 ? [] : [[key, value]]
+    );
+  }
+  return Object.freeze(new Map(entries));
+}
+function addToRenderMap(renderMap, path, content) {
+  return mergeRenderMaps([renderMap, createRenderMap(path, content)]);
+}
+function removeFromRenderMap(renderMap, path) {
+  const newMap = new Map(renderMap);
+  newMap.delete(path);
+  return Object.freeze(newMap);
+}
+function mergeRenderMaps(renderMaps) {
+  if (renderMaps.length === 0) return createRenderMap();
+  if (renderMaps.length === 1) return renderMaps[0];
+  const merged = new Map(renderMaps[0]);
+  for (const map of renderMaps.slice(1)) {
+    for (const [key, value] of map) {
+      merged.set(key, value);
+    }
+  }
+  return Object.freeze(merged);
+}
+function mapRenderMapFragment(renderMap, fn) {
+  return Object.freeze(new Map([...[...renderMap.entries()].map(([key, value]) => [key, fn(value, key)])]));
+}
+async function mapRenderMapFragmentAsync(renderMap, fn) {
+  return Object.freeze(
+    new Map(
+      await Promise.all([
+        ...[...renderMap.entries()].map(async ([key, value]) => [key, await fn(value, key)])
+      ])
+    )
+  );
+}
+function mapRenderMapContent(renderMap, fn) {
+  return mapRenderMapFragment(
+    renderMap,
+    (fragment2, path) => mapFragmentContent(fragment2, (content) => fn(content, path))
+  );
+}
+async function mapRenderMapContentAsync(renderMap, fn) {
+  return await mapRenderMapFragmentAsync(
+    renderMap,
+    (fragment2, path) => mapFragmentContentAsync(fragment2, (content) => fn(content, path))
+  );
+}
+function getFromRenderMap(renderMap, path) {
+  const value = renderMap.get(path);
+  if (value === void 0) {
+    throw new CodamaError(CODAMA_ERROR__VISITORS__RENDER_MAP_KEY_NOT_FOUND, { key: path });
+  }
+  return value;
+}
+function renderMapContains(renderMap, path, value) {
+  const { content } = getFromRenderMap(renderMap, path);
+  return typeof value === "string" ? content.includes(value) : value.test(content);
+}
+function writeRenderMap(renderMap, basePath) {
+  renderMap.forEach(({ content }, relativePath2) => {
+    writeFile(joinPath(basePath, relativePath2));
+  });
+}
+
+// src/rust/ImportMap.ts
+var RUST_CORE_IMPORTS = /* @__PURE__ */ new Set([
+  "alloc",
+  "clippy",
+  "core",
+  "crate",
+  "self",
+  "std",
+  "super"
+]);
+function createImportMap() {
+  return Object.freeze(/* @__PURE__ */ new Map());
+}
+
+// src/rust/mergeImportMaps.ts
+function mergeImportMaps(importMaps) {
+  if (importMaps.length === 0) return createImportMap();
+  if (importMaps.length === 1) return importMaps[0];
+  const merged = new Map(importMaps[0]);
+  for (const map of importMaps.slice(1)) {
+    for (const [path, info] of map) {
+      merged.set(path, info);
+    }
+  }
+  return Object.freeze(merged);
+}
+
+// src/rust/addToImportMap.ts
+function addToImportMap(importMap, paths) {
+  const inputs = typeof paths === "string" ? [paths] : [...paths];
+  if (inputs.length === 0) return importMap;
+  const additions = /* @__PURE__ */ new Map();
+  for (const path of inputs) {
+    if (!additions.has(path) && !importMap.has(path)) {
+      additions.set(path, Object.freeze({ importedPath: path }));
+    }
+  }
+  if (additions.size === 0) return importMap;
+  return mergeImportMaps([importMap, additions]);
+}
+
+// src/rust/addAliasToImportMap.ts
+function addAliasToImportMap(importMap, path, alias) {
+  const next = new Map(importMap);
+  next.set(path, Object.freeze({ alias, importedPath: path }));
+  return Object.freeze(next);
+}
+
+// src/rust/removeFromImportMap.ts
+function removeFromImportMap(importMap, paths) {
+  const targets = typeof paths === "string" ? [paths] : [...paths];
+  if (targets.length === 0) return importMap;
+  const next = new Map(importMap);
+  for (const path of targets) next.delete(path);
+  return Object.freeze(next);
+}
+
+// src/rust/resolveImportMap.ts
+function resolveImportMap(importMap, dependencies) {
+  const prefixes = Object.keys(dependencies);
+  if (prefixes.length === 0 || importMap.size === 0) return importMap;
+  const next = new Map(importMap);
+  let mutated = false;
+  for (const [path, info] of importMap) {
+    const resolvedPath = resolvePath(path, dependencies, prefixes);
+    if (resolvedPath === path) continue;
+    next.delete(path);
+    next.set(resolvedPath, Object.freeze({ ...info, importedPath: resolvedPath }));
+    mutated = true;
+  }
+  return mutated ? Object.freeze(next) : importMap;
+}
+function resolvePath(path, dependencies, prefixes) {
+  for (const prefix of prefixes) {
+    if (path.startsWith(`${prefix}::`)) {
+      return dependencies[prefix] + path.slice(prefix.length);
+    }
+  }
+  return path;
+}
+
+// src/rust/getExternalDependencies.ts
+function getExternalDependencies(importMap, dependencies = {}) {
+  const resolved = resolveImportMap(importMap, dependencies);
+  const crates = /* @__PURE__ */ new Set();
+  for (const path of resolved.keys()) {
+    const root = path.split("::")[0];
+    if (!RUST_CORE_IMPORTS.has(root)) crates.add(root);
+  }
+  return crates;
+}
+
+// src/rust/importMapToString.ts
+function importMapToString(importMap, dependencies = {}) {
+  const resolved = resolveImportMap(importMap, dependencies);
+  return [...resolved.values()].map((info) => info.alias ? `use ${info.importedPath} as ${info.alias};` : `use ${info.importedPath};`).sort((a, b) => a.localeCompare(b)).join("\n");
+}
+
+// src/rust/fragment.ts
+function isFragment(value) {
+  return typeof value === "object" && value !== null && "content" in value && "imports" in value;
+}
+function fragment(template, ...items) {
+  return createFragmentTemplate(template, items, isFragment, mergeFragments);
+}
+function mergeFragments(fragments, mergeContent) {
+  const filtered = fragments.filter((f) => f !== void 0);
+  return Object.freeze({
+    content: mergeContent(filtered.map((f) => f.content)),
+    imports: mergeImportMaps(filtered.map((f) => f.imports))
+  });
+}
+function addFragmentImports(fragment2, paths) {
+  return Object.freeze({
+    ...fragment2,
+    imports: addToImportMap(fragment2.imports, paths)
+  });
+}
+function addFragmentImportAlias(fragment2, path, alias) {
+  return Object.freeze({
+    ...fragment2,
+    imports: addAliasToImportMap(fragment2.imports, path, alias)
+  });
+}
+function mergeFragmentImports(fragment2, importMaps) {
+  return Object.freeze({
+    ...fragment2,
+    imports: mergeImportMaps([fragment2.imports, ...importMaps])
+  });
+}
+function removeFragmentImports(fragment2, paths) {
+  return Object.freeze({
+    ...fragment2,
+    imports: removeFromImportMap(fragment2.imports, paths)
+  });
+}
+
+// src/rust/getDocblockFragment.ts
+function getDocblockFragment(lines, options = {}) {
+  if (!lines || lines.length === 0) return void 0;
+  const prefix = options.internal ? "//!" : "///";
+  const lineJump = options.withLineJump ? "\n" : "";
+  const prefixedLines = lines.map((line) => line ? `${prefix} ${line}` : prefix);
+  return fragment`${prefixedLines.join("\n")}${lineJump}`;
+}
+
+export { RUST_CORE_IMPORTS, addAliasToImportMap, addFragmentImportAlias, addFragmentImports, addToImportMap, addToRenderMap, camelCase, capitalize, createDirectory, createFragmentTemplate, createImportMap, createRenderMap, deleteDirectory, fileExists, fragment, getDocblockFragment, getExternalDependencies, getFromRenderMap, importMapToString, isFragment, joinPath, kebabCase, mapFragmentContent, mapFragmentContentAsync, mapRenderMapContent, mapRenderMapContentAsync, mapRenderMapFragment, mapRenderMapFragmentAsync, mergeFragmentImports, mergeFragments, mergeImportMaps, mergeRenderMaps, pascalCase, pathBasename, pathDirectory, readFile, readJson, relativePath, removeFragmentImports, removeFromImportMap, removeFromRenderMap, renderMapContains, resolveImportMap, setFragmentContent, snakeCase, titleCase, writeFile, writeRenderMap };
+//# sourceMappingURL=rust.browser.mjs.map
+//# sourceMappingURL=rust.browser.mjs.map

package/dist/rust.browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/casing.ts","../src/core/createFragmentTemplate.ts","../src/core/path.ts","../src/core/fs.ts","../src/core/setFragmentContent.ts","../src/core/mapFragmentContent.ts","../src/core/renderMap.ts","../src/rust/ImportMap.ts","../src/rust/mergeImportMaps.ts","../src/rust/addToImportMap.ts","../src/rust/addAliasToImportMap.ts","../src/rust/removeFromImportMap.ts","../src/rust/resolveImportMap.ts","../src/rust/getExternalDependencies.ts","../src/rust/importMapToString.ts","../src/rust/fragment.ts","../src/rust/getDocblockFragment.ts"],"names":["isFragment","mergeFragments","CodamaError","CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE","fragment","relativePath"],"mappings":"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","file":"rust.browser.mjs","sourcesContent":["/**\n * String-casing helpers used by code generators when emitting\n * identifiers. They normalise an arbitrary input string into a\n * conventional shape (camelCase, PascalCase, kebab-case, snake_case,\n * Title Case) by inserting word boundaries before uppercase letters and\n * splitting on any sequence of non-alphanumeric characters.\n *\n * Returned values are plain `string`. This package deliberately does\n * not depend on `@codama/node-types`, so the branded `CamelCaseString`\n * / `PascalCaseString` / … types are not applied here. Consumers that\n * want the brand (e.g. `@codama/nodes`) can wrap these helpers and\n * apply the cast at their own boundary.\n *\n * The implementations all run through {@link titleCase} as a common\n * intermediate form, so a single deterministic word-splitting policy\n * is shared across every output shape.\n */\n\n/**\n * Uppercase the first character and lowercase the rest. Returns the\n * input unchanged when it is empty.\n */\nexport function capitalize(str: string): string {\n    if (str.length === 0) return str;\n    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();\n}\n\n/**\n * Normalise an arbitrary string into Title Case — a space-separated\n * sequence of {@link capitalize}d words. Inserts a space before each\n * uppercase letter, then splits on any run of non-alphanumeric\n * characters and re-joins with single spaces.\n */\nexport function titleCase(str: string): string {\n    return str\n        .replace(/([A-Z])/g, ' $1')\n        .split(/[^a-zA-Z0-9]+/)\n        .filter(word => word.length > 0)\n        .map(capitalize)\n        .join(' ');\n}\n\n/**\n * Normalise an arbitrary string into PascalCase by stripping the\n * spaces from its {@link titleCase} form.\n */\nexport function pascalCase(str: string): string {\n    return titleCase(str).split(' ').join('');\n}\n\n/**\n * Normalise an arbitrary string into camelCase by lowercasing the\n * first character of its {@link pascalCase} form.\n */\nexport function camelCase(str: string): string {\n    if (str.length === 0) return str;\n    const pascalStr = pascalCase(str);\n    return pascalStr.charAt(0).toLowerCase() + pascalStr.slice(1);\n}\n\n/**\n * Normalise an arbitrary string into kebab-case — lowercase words\n * joined with `-` — by replacing the spaces in its {@link titleCase}\n * form.\n */\nexport function kebabCase(str: string): string {\n    return titleCase(str).split(' ').join('-').toLowerCase();\n}\n\n/**\n * Normalise an arbitrary string into snake_case — lowercase words\n * joined with `_` — by replacing the spaces in its {@link titleCase}\n * form.\n */\nexport function snakeCase(str: string): string {\n    return titleCase(str).split(' ').join('_').toLowerCase();\n}\n","import type { BaseFragment } from './BaseFragment';\n\n/**\n * Generic template-tag implementation used by every flavor's `fragment`\n * tagged template.\n *\n * Walks the template/items pair, interpolating fragments verbatim and\n * coercing other values to strings, then defers to the caller-provided\n * `mergeFragments` for combining the surviving sub-fragments. This keeps the\n * fragment shape (imports, features, etc.) opaque to the core layer; each\n * flavor plugs in its own merge logic.\n *\n * Most consumers never call this directly — they use the `fragment` tag\n * exported by `@codama/fragments/javascript` or `@codama/fragments/rust`,\n * which both wrap this helper.\n *\n * @typeParam TFragment - The concrete fragment type. Must extend {@link BaseFragment}.\n * @param template - The template-strings array supplied by the tag call site.\n * @param items - The interpolated values, in order. May be fragments,\n * strings, numbers, booleans, `undefined`, or anything coercible to a string.\n * @param isFragment - A predicate that identifies values of the concrete\n * fragment type so they can be inlined and forwarded to the merger.\n * @param mergeFragments - The flavor-specific merger that knows how to\n * combine fragments' non-content fields (e.g. imports, features). Receives\n * only the sub-fragments found in the template, plus a callback that\n * produces the final merged content string from each sub-fragment's content.\n * @return The fragment produced by `mergeFragments`.\n *\n * @example\n * ```ts\n * import { createFragmentTemplate } from '@codama/fragments';\n *\n * function fragment(template: TemplateStringsArray, ...items: unknown[]) {\n *     return createFragmentTemplate(template, items, isFragment, mergeFragments);\n * }\n * ```\n */\nexport function createFragmentTemplate<TFragment extends BaseFragment>(\n    template: TemplateStringsArray,\n    items: unknown[],\n    isFragment: (value: unknown) => value is TFragment,\n    mergeFragments: (fragments: TFragment[], mergeContent: (contents: string[]) => string) => TFragment,\n): TFragment {\n    const fragments = items.filter(isFragment);\n    const zippedItems = items.map((item, i) => {\n        const itemPrefix = template[i];\n        if (typeof item === 'undefined') return itemPrefix;\n        if (isFragment(item)) return itemPrefix + item.content;\n        return itemPrefix + String(item as string);\n    });\n    return mergeFragments(fragments, () => zippedItems.join('') + template[template.length - 1]);\n}\n","/**\n * Path manipulation helpers used by code generators to assemble output\n * file paths.\n *\n * The {@link Path} type is a thin documentation alias for `string` —\n * any place a generator stores or threads a filesystem-relative path,\n * use this name to communicate intent. The {@link joinPath} and\n * {@link pathDirectory} helpers delegate to `node:path` on Node and\n * fall back to lightweight string manipulation on non-Node platforms.\n */\n\nimport { basename, dirname, join, posix } from 'node:path';\n\nimport { CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, CodamaError } from '@codama/errors';\n\n/** A filesystem path inside the generator's output tree. */\nexport type Path = string;\n\n/**\n * Join two or more path segments together. Uses `node:path`'s\n * platform-aware {@link join} on Node; on other platforms (browser,\n * react-native) falls back to a `/`-joined form with consecutive\n * slashes collapsed.\n */\nexport function joinPath(...paths: Path[]): string {\n    if (!__NODEJS__) {\n        return paths.join('/').replace(/\\/+/g, '/');\n    }\n\n    return join(...paths);\n}\n\n/**\n * Return the directory portion of a path (i.e. everything up to the\n * last `/` segment). Uses `node:path`'s {@link dirname} on Node and a\n * plain `lastIndexOf` fallback on other platforms.\n */\nexport function pathDirectory(path: Path): Path {\n    if (!__NODEJS__) {\n        return path.substring(0, path.lastIndexOf('/'));\n    }\n\n    return dirname(path);\n}\n\n/**\n * Return the trailing segment of a path (everything after the last\n * `/`). Uses `node:path`'s {@link basename} on Node and a plain\n * `lastIndexOf` fallback on other platforms.\n */\nexport function pathBasename(path: Path): Path {\n    if (!__NODEJS__) {\n        const slash = path.lastIndexOf('/');\n        return slash >= 0 ? path.substring(slash + 1) : path;\n    }\n\n    return basename(path);\n}\n\n/**\n * Compute the POSIX-style relative path from `from` to `to`. Both\n * arguments are treated as `/`-separated logical paths regardless of\n * platform, so the result is consistent across operating systems —\n * suitable for emitting into source code as an import specifier.\n *\n * Node only: non-Node platforms throw {@link CodamaError} because\n * implementing a correct POSIX relative-path algorithm without\n * `node:path` is non-trivial and no current consumer needs it.\n */\nexport function relativePath(from: Path, to: Path): string {\n    if (!__NODEJS__) {\n        throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: 'relative' });\n    }\n\n    return posix.relative(from, to);\n}\n","/**\n * Node-only filesystem helpers used by code generators to write their\n * output to disk. Each function checks the `__NODEJS__` build flag and\n * throws a structured {@link CodamaError} on non-Node platforms so\n * accidental calls from a browser bundle fail loudly rather than\n * silently no-oping.\n */\n\nimport { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';\n\nimport { CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, CodamaError } from '@codama/errors';\n\nimport { Path, pathDirectory } from './path';\n\n/** Create a directory (and any missing parents) at the given path. */\nexport function createDirectory(path: Path): void {\n    if (!__NODEJS__) {\n        throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: 'mkdirSync' });\n    }\n\n    mkdirSync(path, { recursive: true });\n}\n\n/** Recursively delete the directory at the given path, if it exists. */\nexport function deleteDirectory(path: Path): void {\n    if (!__NODEJS__) {\n        throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: 'rmSync' });\n    }\n\n    if (existsSync(path)) {\n        rmSync(path, { recursive: true });\n    }\n}\n\n/**\n * Write `content` to a file at `path`, creating intermediate\n * directories as needed.\n */\nexport function writeFile(path: Path, content: string): void {\n    if (!__NODEJS__) {\n        throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: 'writeFileSync' });\n    }\n\n    const directory = pathDirectory(path);\n    if (!existsSync(directory)) {\n        createDirectory(directory);\n    }\n    writeFileSync(path, content);\n}\n\n/** Check whether a file or directory exists at the given path. */\nexport function fileExists(path: Path): boolean {\n    if (!__NODEJS__) {\n        throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: 'existsSync' });\n    }\n\n    return existsSync(path);\n}\n\n/** Read the file at the given path as a UTF-8 string. */\nexport function readFile(path: Path): string {\n    if (!__NODEJS__) {\n        throw new CodamaError(CODAMA_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE, { fsFunction: 'readFileSync' });\n    }\n\n    return readFileSync(path, 'utf-8');\n}\n\n/**\n * Read the file at the given path as a UTF-8 string and parse it as\n * JSON. The result is typed as the caller-supplied `T`; no runtime\n * validation is performed.\n */\nexport function readJson<T>(path: Path): T {\n    return JSON.parse(readFile(path)) as T;\n}\n","import type { BaseFragment } from './BaseFragment';\n\n/**\n * Return a new frozen fragment whose `content` field has been replaced with\n * `content`, preserving every other field of the input fragment.\n *\n * The output keeps the input's exact concrete type (`TFragment`) so callers\n * never lose any extra fields a flavored fragment may carry (imports,\n * features, etc.).\n *\n * @typeParam TFragment - The concrete fragment type. Must extend {@link BaseFragment}.\n * @param fragment - The source fragment to copy.\n * @param content - The new code string.\n * @return A frozen fragment of the same shape as `fragment` with `content` replaced.\n *\n * @example\n * ```ts\n * import { setFragmentContent } from '@codama/fragments';\n *\n * const next = setFragmentContent(prev, prev.content.toUpperCase());\n * ```\n */\nexport function setFragmentContent<TFragment extends BaseFragment>(fragment: TFragment, content: string): TFragment {\n    return Object.freeze({ ...fragment, content });\n}\n","import type { BaseFragment } from './BaseFragment';\nimport { setFragmentContent } from './setFragmentContent';\n\n/**\n * Apply a synchronous transformation to a fragment's `content`, returning a\n * new fragment with every other field preserved.\n *\n * @typeParam TFragment - The concrete fragment type. Must extend {@link BaseFragment}.\n * @param fragment - The source fragment.\n * @param mapContent - A function that receives the current content and\n * returns the new content.\n * @return A frozen fragment with the transformed content.\n *\n * @example\n * ```ts\n * import { mapFragmentContent } from '@codama/fragments';\n *\n * const trimmed = mapFragmentContent(fragment, c => c.trimEnd());\n * ```\n *\n * @see {@link mapFragmentContentAsync} for the async variant.\n */\nexport function mapFragmentContent<TFragment extends BaseFragment>(\n    fragment: TFragment,\n    mapContent: (content: string) => string,\n): TFragment {\n    return setFragmentContent(fragment, mapContent(fragment.content));\n}\n\n/**\n * Async variant of {@link mapFragmentContent}: apply an async transformation\n * to a fragment's `content`.\n *\n * @typeParam TFragment - The concrete fragment type. Must extend {@link BaseFragment}.\n * @param fragment - The source fragment.\n * @param mapContent - An async function that receives the current content\n * and returns a promise resolving to the new content.\n * @return A promise that resolves to a frozen fragment with the transformed\n * content.\n *\n * @example\n * ```ts\n * import { mapFragmentContentAsync } from '@codama/fragments';\n *\n * const formatted = await mapFragmentContentAsync(fragment, formatWithPrettier);\n * ```\n *\n * @see {@link mapFragmentContent} for the sync variant.\n */\nexport async function mapFragmentContentAsync<TFragment extends BaseFragment>(\n    fragment: TFragment,\n    mapContent: (content: string) => Promise<string>,\n): Promise<TFragment> {\n    return setFragmentContent(fragment, await mapContent(fragment.content));\n}\n","/**\n * A `RenderMap` is the in-memory data structure a code generator builds\n * up before writing anything to disk: a frozen `ReadonlyMap` keyed by\n * output path, with a `BaseFragment` (or a concrete subtype carrying\n * imports / features / …) as the value. The helpers in this module are\n * pure data operations — they construct, merge, transform, and query\n * render maps without touching the filesystem.\n *\n * {@link writeRenderMap} is the single filesystem-touching entry point\n * here: it walks a finished map and writes every entry. Renderers that\n * tie a render map to a `Visitor` (see `@codama/renderers-core`) layer\n * that on top.\n */\n\nimport { CODAMA_ERROR__VISITORS__RENDER_MAP_KEY_NOT_FOUND, CodamaError } from '@codama/errors';\n\nimport type { BaseFragment } from './BaseFragment';\nimport { writeFile } from './fs';\nimport { mapFragmentContent, mapFragmentContentAsync } from './mapFragmentContent';\nimport { joinPath, type Path } from './path';\n\n/**\n * A frozen map keyed by output {@link Path}, with each entry holding a\n * fragment that will be written to that path. `TFragment` defaults to\n * {@link BaseFragment} but generators typically pass a richer flavor\n * (e.g. `Fragment` from `@codama/fragments/javascript`) to carry\n * imports and other per-file metadata.\n */\nexport type RenderMap<TFragment extends BaseFragment> = ReadonlyMap<Path, TFragment>;\n\nexport function createRenderMap<TFragment extends BaseFragment = BaseFragment>(): RenderMap<TFragment>;\nexport function createRenderMap<TFragment extends BaseFragment>(path: Path, content: TFragment): RenderMap<TFragment>;\nexport function createRenderMap<TFragment extends BaseFragment>(\n    entries: Record<Path, TFragment | undefined>,\n): RenderMap<TFragment>;\nexport function createRenderMap<TFragment extends BaseFragment>(\n    pathOrEntries?: Path | Record<Path, TFragment | undefined>,\n    content?: TFragment,\n): RenderMap<TFragment> {\n    let entries: [Path, TFragment][] = [];\n    if (typeof pathOrEntries === 'string' && content !== undefined) {\n        entries = [[pathOrEntries, content]];\n    } else if (typeof pathOrEntries === 'object' && pathOrEntries !== null) {\n        entries = Object.entries(pathOrEntries).flatMap(([key, value]) =>\n            value === undefined ? [] : ([[key, value]] as const),\n        );\n    }\n    return Object.freeze(new Map(entries));\n}\n\n/** Add or overwrite a single `(path, fragment)` entry. */\nexport function addToRenderMap<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    path: Path,\n    content: TFragment,\n): RenderMap<TFragment> {\n    return mergeRenderMaps([renderMap, createRenderMap(path, content)]);\n}\n\n/** Remove the entry at `path`, returning a new frozen map. */\nexport function removeFromRenderMap<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    path: Path,\n): RenderMap<TFragment> {\n    const newMap = new Map(renderMap);\n    newMap.delete(path);\n    return Object.freeze(newMap);\n}\n\n/**\n * Combine multiple render maps into one. Later maps overwrite earlier\n * entries at the same path.\n */\nexport function mergeRenderMaps<TFragment extends BaseFragment>(\n    renderMaps: RenderMap<TFragment>[],\n): RenderMap<TFragment> {\n    if (renderMaps.length === 0) return createRenderMap();\n    if (renderMaps.length === 1) return renderMaps[0];\n    const merged = new Map(renderMaps[0]);\n    for (const map of renderMaps.slice(1)) {\n        for (const [key, value] of map) {\n            merged.set(key, value);\n        }\n    }\n    return Object.freeze(merged);\n}\n\n/** Transform every fragment in the map, preserving the keys. */\nexport function mapRenderMapFragment<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    fn: (fragment: TFragment, path: Path) => TFragment,\n): RenderMap<TFragment> {\n    return Object.freeze(new Map([...[...renderMap.entries()].map(([key, value]) => [key, fn(value, key)] as const)]));\n}\n\n/** Async variant of {@link mapRenderMapFragment}. */\nexport async function mapRenderMapFragmentAsync<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    fn: (fragment: TFragment, path: Path) => Promise<TFragment>,\n): Promise<RenderMap<TFragment>> {\n    return Object.freeze(\n        new Map(\n            await Promise.all([\n                ...[...renderMap.entries()].map(async ([key, value]) => [key, await fn(value, key)] as const),\n            ]),\n        ),\n    );\n}\n\n/** Transform the `content` of every fragment in the map. */\nexport function mapRenderMapContent<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    fn: (content: string, path: Path) => string,\n): RenderMap<TFragment> {\n    return mapRenderMapFragment(renderMap, (fragment, path) =>\n        mapFragmentContent(fragment, content => fn(content, path)),\n    );\n}\n\n/** Async variant of {@link mapRenderMapContent}. */\nexport async function mapRenderMapContentAsync<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    fn: (content: string, path: Path) => Promise<string>,\n): Promise<RenderMap<TFragment>> {\n    return await mapRenderMapFragmentAsync(renderMap, (fragment, path) =>\n        mapFragmentContentAsync(fragment, content => fn(content, path)),\n    );\n}\n\n/**\n * Look up the fragment at `path`, throwing a structured\n * {@link CodamaError} when the key is missing.\n */\nexport function getFromRenderMap<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    path: Path,\n): TFragment {\n    const value = renderMap.get(path);\n    if (value === undefined) {\n        throw new CodamaError(CODAMA_ERROR__VISITORS__RENDER_MAP_KEY_NOT_FOUND, { key: path });\n    }\n    return value;\n}\n\n/**\n * Test whether the fragment at `path` contains `value`. Accepts either\n * a plain substring or a regular expression.\n */\nexport function renderMapContains<TFragment extends BaseFragment>(\n    renderMap: RenderMap<TFragment>,\n    path: Path,\n    value: RegExp | string,\n): boolean {\n    const { content } = getFromRenderMap(renderMap, path);\n    return typeof value === 'string' ? content.includes(value) : value.test(content);\n}\n\n/**\n * Walk the render map and write every entry to disk, rooted at\n * `basePath`. Each path is joined with `basePath` via {@link joinPath}\n * and written via {@link writeFile}; the directory structure is\n * created on demand.\n */\nexport function writeRenderMap<TFragment extends BaseFragment>(renderMap: RenderMap<TFragment>, basePath: Path): void {\n    renderMap.forEach(({ content }, relativePath) => {\n        writeFile(joinPath(basePath, relativePath), content);\n    });\n}\n","/**\n * Rust crate keywords that should never be reported as external dependencies.\n *\n * {@link getExternalDependencies} filters these out when computing the\n * package's Cargo dependencies from the imports actually used. They\n * correspond to paths that resolve inside the crate or to the standard\n * library.\n */\nexport const RUST_CORE_IMPORTS: ReadonlySet<string> = new Set([\n    'alloc',\n    'clippy',\n    'core',\n    'crate',\n    'self',\n    'std',\n    'super',\n]);\n\n/**\n * The fully-qualified Rust path of an imported item — e.g.\n * `'solana_program::pubkey::Pubkey'` or `'crate::generated::accounts::AccountNode'`.\n *\n * Symbolic prefixes (e.g. `'generated::accounts::Foo'`) are accepted too;\n * they are resolved into concrete paths by {@link resolveImportMap} just\n * before stringification.\n */\nexport type ImportPath = string;\n\n/** The local name an imported path is bound to (the right-hand side of `as`). */\nexport type Alias = string;\n\n/** A parsed Rust import. */\nexport interface ImportInfo {\n    readonly alias?: Alias;\n    readonly importedPath: ImportPath;\n}\n\n/**\n * The data model used by `@codama/fragments/rust` to track imports\n * symbolically until they are stringified into actual `use foo::Bar;` lines.\n *\n * Unlike the JavaScript flavor, Rust's `use` statement always references a\n * single fully-qualified path. There is no per-module identifier list, so\n * the map is flat: keyed by the imported path, with optional alias info as\n * the value.\n *\n * The map is frozen and its operations are pure functions (no methods, no\n * mutation), matching the JavaScript subpath's paradigm.\n */\nexport type ImportMap = ReadonlyMap<ImportPath, ImportInfo>;\n\n/**\n * Construct an empty, frozen import map.\n *\n * @return A new {@link ImportMap} with no entries.\n *\n * @example\n * ```ts\n * import { createImportMap } from '@codama/fragments/rust';\n *\n * const empty = createImportMap();\n * ```\n */\nexport function createImportMap(): ImportMap {\n    return Object.freeze(new Map<ImportPath, ImportInfo>());\n}\n","import type { ImportMap } from './ImportMap';\nimport { createImportMap } from './ImportMap';\n\n/**\n * Merge multiple import maps into one. Paths from later maps are layered\n * over earlier ones; if the same path appears in multiple maps, the\n * latest occurrence's alias info wins.\n *\n * The merge is a pure function: input maps are not mutated. The returned\n * map is frozen.\n *\n * @param importMaps - The import maps to merge, in priority order.\n * @return A frozen import map containing every entry from every input.\n *\n * @example\n * ```ts\n * import { addToImportMap, createImportMap, mergeImportMaps } from '@codama/fragments/rust';\n *\n * const a = addToImportMap(createImportMap(), ['borsh::BorshDeserialize']);\n * const b = addToImportMap(createImportMap(), ['solana_program::pubkey::Pubkey']);\n * const merged = mergeImportMaps([a, b]);\n * ```\n */\nexport function mergeImportMaps(importMaps: readonly ImportMap[]): ImportMap {\n    if (importMaps.length === 0) return createImportMap();\n    if (importMaps.length === 1) return importMaps[0];\n    const merged = new Map(importMaps[0]);\n    for (const map of importMaps.slice(1)) {\n        for (const [path, info] of map) {\n            merged.set(path, info);\n        }\n    }\n    return Object.freeze(merged);\n}\n","import type { ImportMap, ImportPath } from './ImportMap';\nimport { mergeImportMaps } from './mergeImportMaps';\n\n/**\n * Append imports to an import map, returning a new frozen map. The input\n * map is not mutated.\n *\n * Aliases are not added by this function — call\n * {@link addAliasToImportMap} separately when the import needs an `as`\n * clause.\n *\n * @param importMap - The import map to extend.\n * @param paths - The Rust paths to add. May be a single string, an array,\n * or a {@link Set}. An empty array short-circuits and returns `importMap`\n * unchanged.\n * @return A frozen import map that includes the new entries.\n *\n * @example\n * ```ts\n * import { addToImportMap, createImportMap } from '@codama/fragments/rust';\n *\n * const map = addToImportMap(createImportMap(), [\n *     'borsh::BorshDeserialize',\n *     'borsh::BorshSerialize',\n * ]);\n * ```\n */\nexport function addToImportMap(\n    importMap: ImportMap,\n    paths: ReadonlySet<string> | string | readonly string[],\n): ImportMap {\n    const inputs = typeof paths === 'string' ? [paths] : [...paths];\n    if (inputs.length === 0) return importMap;\n    const additions = new Map<ImportPath, { importedPath: ImportPath }>();\n    for (const path of inputs) {\n        if (!additions.has(path) && !importMap.has(path)) {\n            additions.set(path, Object.freeze({ importedPath: path }));\n        }\n    }\n    if (additions.size === 0) return importMap;\n    return mergeImportMaps([importMap, additions]);\n}\n","import type { Alias, ImportMap, ImportPath } from './ImportMap';\n\n/**\n * Record an alias (`use foo::Bar as Baz;`) for an imported path. If the\n * path isn't yet in the map, it is added; if it's already present, the\n * alias is set or replaced. The input map is not mutated.\n *\n * @param importMap - The import map to extend.\n * @param path - The full Rust path being aliased (e.g. `'foo::Bar'`).\n * @param alias - The local name to use (e.g. `'Baz'`).\n * @return A new frozen import map with the alias recorded.\n *\n * @example\n * ```ts\n * import { addAliasToImportMap, createImportMap } from '@codama/fragments/rust';\n *\n * const map = addAliasToImportMap(\n *     createImportMap(),\n *     'solana_program::program_error::ProgramError',\n *     'ProgError',\n * );\n * ```\n */\nexport function addAliasToImportMap(importMap: ImportMap, path: ImportPath, alias: Alias): ImportMap {\n    const next = new Map(importMap);\n    next.set(path, Object.freeze({ alias, importedPath: path }));\n    return Object.freeze(next);\n}\n","import type { ImportMap, ImportPath } from './ImportMap';\n\n/**\n * Drop one or more imported paths from an import map. Paths that aren't\n * present are silently ignored. The input map is not mutated.\n *\n * @param importMap - The import map to trim.\n * @param paths - The Rust paths to remove. May be a single string, an\n * array, or a {@link Set}.\n * @return A new frozen import map without those entries.\n *\n * @example\n * ```ts\n * import { addToImportMap, createImportMap, removeFromImportMap } from '@codama/fragments/rust';\n *\n * let map = addToImportMap(createImportMap(), ['foo::A', 'foo::B']);\n * map = removeFromImportMap(map, 'foo::A');\n * ```\n */\nexport function removeFromImportMap(\n    importMap: ImportMap,\n    paths: ImportPath | ReadonlySet<string> | readonly ImportPath[],\n): ImportMap {\n    const targets = typeof paths === 'string' ? [paths] : [...paths];\n    if (targets.length === 0) return importMap;\n    const next = new Map(importMap);\n    for (const path of targets) next.delete(path);\n    return Object.freeze(next);\n}\n","import type { ImportMap, ImportPath } from './ImportMap';\n\n/**\n * Rewrite the symbolic prefixes of an import map's paths against a\n * dependency map.\n *\n * Resolution is by prefix match on the `::` separator: an import\n * `'generated::accounts::AccountNode'` against\n * `{ generated: 'crate::generated' }` becomes\n * `'crate::generated::accounts::AccountNode'`. Paths that don't match any\n * prefix are kept unchanged. Aliases follow their path.\n *\n * Renderers typically pre-define a base set of symbolic modules\n * (`generated → crate::generated`, `mplToolbox → mpl_toolbox`, etc.) and\n * pass them through this function just before calling\n * {@link importMapToString} or {@link getExternalDependencies}.\n *\n * @param importMap - The import map to resolve.\n * @param dependencies - A record mapping symbolic prefixes to resolved\n * Rust paths.\n * @return A new frozen import map with all paths resolved.\n *\n * @example\n * ```ts\n * import { addToImportMap, createImportMap, resolveImportMap } from '@codama/fragments/rust';\n *\n * const map = addToImportMap(createImportMap(), 'generated::accounts::AccountNode');\n * const resolved = resolveImportMap(map, { generated: 'crate::generated' });\n * // resolved has 'crate::generated::accounts::AccountNode'\n * ```\n */\nexport function resolveImportMap(importMap: ImportMap, dependencies: Record<string, string>): ImportMap {\n    const prefixes = Object.keys(dependencies);\n    if (prefixes.length === 0 || importMap.size === 0) return importMap;\n    const next = new Map(importMap);\n    let mutated = false;\n    for (const [path, info] of importMap) {\n        const resolvedPath = resolvePath(path, dependencies, prefixes);\n        if (resolvedPath === path) continue;\n        next.delete(path);\n        next.set(resolvedPath, Object.freeze({ ...info, importedPath: resolvedPath }));\n        mutated = true;\n    }\n    return mutated ? Object.freeze(next) : importMap;\n}\n\nfunction resolvePath(path: ImportPath, dependencies: Record<string, string>, prefixes: readonly string[]): ImportPath {\n    for (const prefix of prefixes) {\n        if (path.startsWith(`${prefix}::`)) {\n            return dependencies[prefix] + path.slice(prefix.length);\n        }\n    }\n    return path;\n}\n","import type { ImportMap } from './ImportMap';\nimport { RUST_CORE_IMPORTS } from './ImportMap';\nimport { resolveImportMap } from './resolveImportMap';\n\n/**\n * Compute the top-level crate names actually imported, with\n * {@link RUST_CORE_IMPORTS} excluded. Useful for syncing a renderer's\n * generated `Cargo.toml` from the imports it ends up emitting.\n *\n * Imports are first resolved against the dependency map (so symbolic\n * prefixes like `'generated::…'` are expanded before crate names are\n * extracted), then the leading `::` segment of each path is collected.\n *\n * @param importMap - The import map to inspect.\n * @param dependencies - The dependency map to apply before extracting\n * crate names. Defaults to no resolution.\n * @return A {@link Set} of external crate names.\n *\n * @example\n * ```ts\n * import { addToImportMap, createImportMap, getExternalDependencies } from '@codama/fragments/rust';\n *\n * const map = addToImportMap(createImportMap(), [\n *     'borsh::BorshSerialize',\n *     'std::collections::HashMap',\n *     'generated::accounts::A',\n * ]);\n * getExternalDependencies(map, { generated: 'crate::generated' });\n * // → Set { 'borsh' }\n * ```\n */\nexport function getExternalDependencies(importMap: ImportMap, dependencies: Record<string, string> = {}): Set<string> {\n    const resolved = resolveImportMap(importMap, dependencies);\n    const crates = new Set<string>();\n    for (const path of resolved.keys()) {\n        const root = path.split('::')[0];\n        if (!RUST_CORE_IMPORTS.has(root)) crates.add(root);\n    }\n    return crates;\n}\n","import type { ImportMap } from './ImportMap';\nimport { resolveImportMap } from './resolveImportMap';\n\n/**\n * Render an import map as a block of `use foo::Bar;` (and `use foo::Bar as Baz;`)\n * statements.\n *\n * The map is first resolved against `dependencies` so symbolic prefixes\n * like `'generated::…'` expand to concrete crate paths. The output is\n * sorted alphabetically by path for stable, reviewable diffs.\n *\n * @param importMap - The import map to render.\n * @param dependencies - The dependency map to apply before rendering.\n * Defaults to no resolution.\n * @return The block of `use` statements joined by newlines, or the empty\n * string if the map is empty.\n *\n * @example\n * ```ts\n * import { addAliasToImportMap, addToImportMap, createImportMap, importMapToString } from '@codama/fragments/rust';\n *\n * let map = createImportMap();\n * map = addToImportMap(map, ['borsh::BorshSerialize', 'solana_program::pubkey::Pubkey']);\n * map = addAliasToImportMap(map, 'solana_program::program_error::ProgramError', 'ProgError');\n * importMapToString(map);\n * // use borsh::BorshSerialize;\n * // use solana_program::program_error::ProgramError as ProgError;\n * // use solana_program::pubkey::Pubkey;\n * ```\n */\nexport function importMapToString(importMap: ImportMap, dependencies: Record<string, string> = {}): string {\n    const resolved = resolveImportMap(importMap, dependencies);\n    return [...resolved.values()]\n        .map(info => (info.alias ? `use ${info.importedPath} as ${info.alias};` : `use ${info.importedPath};`))\n        .sort((a, b) => a.localeCompare(b))\n        .join('\\n');\n}\n","import type { BaseFragment } from '../core/BaseFragment';\nimport { createFragmentTemplate } from '../core/createFragmentTemplate';\nimport { addAliasToImportMap } from './addAliasToImportMap';\nimport { addToImportMap } from './addToImportMap';\nimport type { Alias, ImportMap, ImportPath } from './ImportMap';\nimport { mergeImportMaps } from './mergeImportMaps';\nimport { removeFromImportMap } from './removeFromImportMap';\n\n/**\n * The Rust-flavored fragment shape: {@link BaseFragment} plus a frozen\n * {@link ImportMap} carrying the `use` paths the content depends on.\n *\n * Both the fragment and its import map are immutable. Every operation in\n * this subpath that returns a fragment produces a new frozen wrapper, so\n * fragments compose without aliasing risks.\n */\nexport type Fragment = BaseFragment & Readonly<{ imports: ImportMap }>;\n\n/**\n * Type guard for the Rust-flavored {@link Fragment} shape.\n *\n * @param value - The value to test.\n * @return `true` when `value` is an object carrying both `content` and\n * `imports` fields.\n */\nexport function isFragment(value: unknown): value is Fragment {\n    return typeof value === 'object' && value !== null && 'content' in value && 'imports' in value;\n}\n\n/**\n * Tagged-template helper for composing Rust-flavored fragments.\n * Interpolated values may be:\n *\n *   - A {@link Fragment} — content is inlined and imports propagate.\n *   - `undefined` — rendered as the empty string.\n *   - Anything else — coerced to a string via `String(value)`.\n *\n * Rust does not have a `use(input, module)` shorthand because identifiers\n * can be referenced inline by their full `::`-qualified path; build\n * content with the tag and attach imports separately via\n * {@link addFragmentImports}.\n *\n * @param template - The template-strings array supplied by the tag call site.\n * @param items - The interpolated values, in order.\n * @return A frozen {@link Fragment} with merged content and imports.\n *\n * @example\n * ```ts\n * import { addFragmentImports, fragment } from '@codama/fragments/rust';\n *\n * const body = fragment`pub struct AccountNode { pubkey: Pubkey }`;\n * const withImports = addFragmentImports(body, ['solana_program::pubkey::Pubkey']);\n * ```\n */\nexport function fragment(template: TemplateStringsArray, ...items: unknown[]): Fragment {\n    return createFragmentTemplate(template, items, isFragment, mergeFragments);\n}\n\n/**\n * Combine multiple fragments into one. The merge strategy for content is\n * supplied by the caller (`mergeContent`); imports are merged\n * automatically via {@link mergeImportMaps}. Undefined inputs are skipped.\n *\n * @param fragments - The fragments to merge, in order.\n * @param mergeContent - A function that produces the final content string\n * from each surviving fragment's content.\n * @return A frozen merged {@link Fragment}.\n */\nexport function mergeFragments(\n    fragments: readonly (Fragment | undefined)[],\n    mergeContent: (contents: string[]) => string,\n): Fragment {\n    const filtered = fragments.filter((f): f is Fragment => f !== undefined);\n    return Object.freeze({\n        content: mergeContent(filtered.map(f => f.content)),\n        imports: mergeImportMaps(filtered.map(f => f.imports)),\n    });\n}\n\n/**\n * Append imports to an existing fragment's import map. The fragment's\n * content and any other fields are preserved.\n *\n * @param fragment - The source fragment.\n * @param paths - The Rust paths to add. May be a single string, an array,\n * or a {@link Set}.\n * @return A new frozen fragment with the extended import map.\n *\n * @example\n * ```ts\n * import { addFragmentImports, fragment } from '@codama/fragments/rust';\n *\n * const f = addFragmentImports(fragment`Pubkey`, ['solana_program::pubkey::Pubkey']);\n * ```\n */\nexport function addFragmentImports(\n    fragment: Fragment,\n    paths: ImportPath | ReadonlySet<string> | readonly ImportPath[],\n): Fragment {\n    return Object.freeze({\n        ...fragment,\n        imports: addToImportMap(fragment.imports, paths),\n    });\n}\n\n/**\n * Record an alias for an imported path on the fragment's import map. If\n * the path isn't yet imported, it is added; if it's already present, the\n * alias replaces any existing one. The fragment's content and any other\n * fields are preserved.\n *\n * @param fragment - The source fragment.\n * @param path - The full Rust path being aliased.\n * @param alias - The local name to use.\n * @return A new frozen fragment with the alias recorded.\n *\n * @example\n * ```ts\n * import { addFragmentImportAlias, fragment } from '@codama/fragments/rust';\n *\n * const f = addFragmentImportAlias(\n *     fragment`ProgError::InvalidArgument`,\n *     'solana_program::program_error::ProgramError',\n *     'ProgError',\n * );\n * ```\n */\nexport function addFragmentImportAlias(fragment: Fragment, path: ImportPath, alias: Alias): Fragment {\n    return Object.freeze({\n        ...fragment,\n        imports: addAliasToImportMap(fragment.imports, path, alias),\n    });\n}\n\n/**\n * Merge additional import maps into an existing fragment's import map.\n * The fragment's content and any other fields are preserved.\n *\n * @param fragment - The source fragment.\n * @param importMaps - The maps to merge in.\n * @return A new frozen fragment with the merged import map.\n */\nexport function mergeFragmentImports(fragment: Fragment, importMaps: readonly ImportMap[]): Fragment {\n    return Object.freeze({\n        ...fragment,\n        imports: mergeImportMaps([fragment.imports, ...importMaps]),\n    });\n}\n\n/**\n * Drop paths from a fragment's import map. The fragment's content and any\n * other fields are preserved.\n *\n * @param fragment - The source fragment.\n * @param paths - The Rust paths to remove. May be a single string, an\n * array, or a {@link Set}.\n * @return A new frozen fragment with the trimmed import map.\n */\nexport function removeFragmentImports(\n    fragment: Fragment,\n    paths: ImportPath | ReadonlySet<string> | readonly ImportPath[],\n): Fragment {\n    return Object.freeze({\n        ...fragment,\n        imports: removeFromImportMap(fragment.imports, paths),\n    });\n}\n","import type { Fragment } from './fragment';\nimport { fragment } from './fragment';\n\n/**\n * Build a Rust doc-comment fragment from an array of lines.\n *\n * Empty or `undefined` input returns `undefined` so the helper composes\n * naturally with the {@link fragment} tag's optional-interpolation\n * behavior — a node's `docs` attribute can be threaded straight in\n * without a ternary guard:\n *\n * ```ts\n * fragment`${getDocblockFragment(node.docs)}\\npub struct X;`;\n * ```\n *\n * Each line is prefixed with `///` (outer doc) by default, or `//!`\n * (inner doc) when `internal` is `true`. Empty elements in the array\n * render as a bare prefix line (`///` or `//!` with no trailing space),\n * useful for paragraph breaks inside a doc comment.\n *\n * @param lines - The lines of the doc comment, or `undefined`. Empty\n * array and `undefined` both return `undefined`.\n * @param options - Optional settings.\n * @param options.internal - When `true`, emit inner doc comments (`//!`)\n * instead of outer doc comments (`///`). Useful for module- or crate-level\n * documentation.\n * @param options.withLineJump - When `true`, appends a trailing `\\n` after\n * the last line.\n * @return A {@link Fragment} carrying the rendered doc comment, or\n * `undefined` when `lines` is empty or `undefined`.\n *\n * @example\n * ```ts\n * import { getDocblockFragment } from '@codama/fragments/rust';\n *\n * getDocblockFragment(['Greets the user.'])?.content;\n * // /// Greets the user.\n *\n * getDocblockFragment(['First line.', '', 'Second paragraph.'])?.content;\n * // /// First line.\n * // ///\n * // /// Second paragraph.\n *\n * getDocblockFragment(['Module docs.'], { internal: true })?.content;\n * // //! Module docs.\n *\n * getDocblockFragment(undefined);\n * // undefined\n * ```\n */\nexport function getDocblockFragment(\n    lines: readonly string[] | undefined,\n    options: { internal?: boolean; withLineJump?: boolean } = {},\n): Fragment | undefined {\n    if (!lines || lines.length === 0) return undefined;\n    const prefix = options.internal ? '//!' : '///';\n    const lineJump = options.withLineJump ? '\\n' : '';\n    const prefixedLines = lines.map(line => (line ? `${prefix} ${line}` : prefix));\n    return fragment`${prefixedLines.join('\\n')}${lineJump}`;\n}\n"]}