astro-lilypond 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -1,40 +1,110 @@
 import type { AstroIntegration } from "astro";
-import { type AutoInstallOptions } from "./binary/index.js";
+import { type AstroComponentFactory } from "astro/runtime/server/index.js";
+import type { AutoInstallOptions } from "./binary/index.js";
 import { type PluginOptions } from "./plugins/index.js";
 import { type LilypondDefaults } from "./render.js";
+import { type LilypondMetadata } from "./utils/index.js";
 export declare const LY_EXTENSIONS: readonly [".ly", ".lilypond", ".ily"];
-export type { AutoInstallOptions, LilypondDefaults, PluginOptions as LilypondPluginOptions, };
+export type { AstroComponentFactory, AutoInstallOptions, LilypondDefaults, LilypondMetadata, PluginOptions as LilypondPluginOptions, };
 export interface LilypondPage {
     src: string;
     width?: number;
     height?: number;
 }
-export interface LilypondContent {
+/**
+ * The result of a `.ly`/`.ily`/`.lilypond` import
+ * or `lilypondLoader()` collection entry.
+ */
+export interface LilypondScore {
+    source: string;
+    alt: string;
+    sourceName: string | undefined;
+    includePaths: string[];
+    assetTitle: string;
+    meta: LilypondMetadata;
+}
+export interface RenderOptions {
+    /**
+     * Output format for `Score`.
+     * @default "svg"
+     */
+    format?: "svg" | "png";
+    /**
+     * Crop `Score` to a single tightly-fit image instead of full pages.
+     * @default false
+     */
+    crop?: boolean;
+    /**
+     * Render a downloadable PDF of the same score, returned as `pdf`.
+     * @default false
+     */
+    pdf?: boolean;
+}
+export interface LilypondImageResult {
     pages: LilypondPage[];
     alt?: string;
 }
+export interface LilypondPdfResult {
+    src: string;
+}
+export interface RenderResult {
+    Score: AstroComponentFactory;
+    pageCount: number;
+    pdf?: LilypondPdfResult;
+    meta: LilypondMetadata;
+    raw: string;
+}
+interface ScoreImageProps {
+    pageLimit?: number;
+    class?: string;
+    style?: string;
+    alt?: string;
+}
+/**
+ * Renders a `LilypondScore` (from a `.ly`/`.ily`/`.lilypond` import,
+ * or a `lilypondLoader()` entry) to a renderable `<Score />` component.
+ */
+export declare function render(score: LilypondScore, options?: RenderOptions): Promise<RenderResult>;
+export interface ScoreProps extends ScoreImageProps {
+    /**
+     * A `LilypondScore` from a `.ly`/`.ily`/`.lilypond` import
+     * or a `lilypondLoader()` entry.
+     */
+    content: LilypondScore;
+    /**
+     * @default "svg"
+     */
+    format?: "svg" | "png";
+    /**
+     * @default false
+     */
+    crop?: boolean;
+}
+/**
+ * Renders a `LilypondScore` directly, for the common case where none of
+ * `render()`'s `pageCount`, `meta`, `raw`, or `pdf` are needed. Use
+ * `render()` instead when you need those.
+ */
+export declare const Score: AstroComponentFactory;
+export declare function renderAll(scores: LilypondScore[], options?: RenderOptions): Promise<RenderResult[]>;
 export interface LilypondOptions extends PluginOptions {
     /**
-     * Output format.
+     * Output format used by Markdown fences and `lilypondLoader()` entries.
      * @default "svg"
      */
     format?: "svg" | "png";
     /**
-     * Defaults passed to each score.
-     * Defaults can still be overridden by individual `.ly` files.
+     * Defaults passed to each score; can be overridden at render time.
      */
     defaults?: LilypondDefaults;
     /**
-     * Milliseconds to wait for a single `lilypond` invocation before
-     * aborting it.
+     * Ms to wait for a single `lilypond` invocation before aborting.
      * @default 60000
      */
     timeout?: number;
     /**
      * When no `lilypond` binary is found on `PATH`, download a matching
-     * prebuilt release into a local cache and use that instead. Set to
-     * `false` to only ever use a `PATH` install, or pass an object to pick
-     * which version gets downloaded.
+     * prebuilt release into a local cache and use that instead.
      * @default true
      */
     autoInstall?: boolean | AutoInstallOptions;

package/dist/index.js

@@ -1,52 +1,111 @@
+import { createComponent, renderComponent, renderTemplate, unescapeHTML, } from "astro/runtime/server/index.js";
 import emitAssetIntegration from "astro-emit-asset";
-import { resolveAutoInstallOption, resolveLilypondBinary, } from "./binary/index.js";
 import { rehypePlugin, remarkPlugin, satteriPlugin, } from "./plugins/index.js";
-import { defaultOptions, render, resolveCrop, } from "./render.js";
-import { altTextFor, emitLilypondAsset, includePathsFor, lyTypeDeclarationsFor, parseLyHeader, parseLyImportQuery, prependVersion, RECOGNIZED_QUERY_PARAMS, resolveDefaults, sourceNameFor, titleFor, } from "./utils/index.js";
+import { render as renderScore } from "./render.js";
+import { getRenderState, resolveAndSetRenderState } from "./renderState.js";
+import { altTextFor, emitLilypondAsset, emitLilypondPdfAsset, includePathsFor, lyTypeDeclarationsFor, parseLyHeaderFields, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.js";
 export const LY_EXTENSIONS = [".ly", ".lilypond", ".ily"];
-function lyFilePlugin(options) {
-    return {
-        name: "vite-plugin-astro-lilypond-ly",
-        enforce: "pre",
-        async transform(source, id) {
-            const query = parseLyImportQuery(id);
-            if (!query)
-                return;
-            const { pathname, cropOverride } = query;
-            if (!LY_EXTENSIONS.some((ext) => pathname.endsWith(ext)))
-                return;
-            const { version, resolution, crop: cropSetting, cropScale, } = resolveDefaults(options.defaults);
-            const crop = cropOverride ?? resolveCrop(cropSetting, "component");
-            const src = version ? prependVersion(source, version) : source;
-            const format = options.format ?? defaultOptions.format;
-            const includePaths = includePathsFor(pathname);
-            const sourceName = sourceNameFor(pathname);
-            const title = titleFor(sourceName);
-            const alt = altTextFor(parseLyHeader(source));
+function createScoreComponent(content) {
+    return createComponent((_result, props) => {
+        const alt = props.alt ?? content.alt ?? "";
+        const html = renderedHtml(content.pages, alt, {
+            class: props.class,
+            style: props.style,
+            pageLimit: props.pageLimit,
+        });
+        return renderTemplate `${unescapeHTML(html)}`;
+    });
+}
+/**
+ * Renders a `LilypondScore` (from a `.ly`/`.ily`/`.lilypond` import,
+ * or a `lilypondLoader()` entry) to a renderable `<Score />` component.
+ */
+export async function render(score, options = {}) {
+    const state = getRenderState();
+    const { resolution, cropScale } = resolveDefaults(state.defaults);
+    const format = options.format ?? "svg";
+    const crop = options.crop ?? false;
+    const [{ Score, pageCount }, pdf] = await Promise.all([
+        (async () => {
             const pages = await emitLilypondAsset({
-                title,
+                title: score.assetTitle,
                 format,
-                source: src,
+                source: score.source,
                 resolution,
                 crop,
                 sizeScale: crop ? cropScale : 1,
-                binaryPath: options.binaryPath,
-                render: () => render(src, {
+                binaryPath: state.binaryPath,
+                render: () => renderScore(score.source, {
                     format,
                     crop,
-                    defaults: options.defaults,
-                    timeout: options.timeout,
-                    binaryPath: options.binaryPath,
-                    includePaths,
-                    sourceName,
+                    defaults: state.defaults,
+                    timeout: state.timeout,
+                    binaryPath: state.binaryPath,
+                    includePaths: score.includePaths,
+                    sourceName: score.sourceName,
                 }),
             });
-            const content = {
-                pages,
+            return {
+                Score: createScoreComponent({ pages, alt: score.alt }),
+                pageCount: pages.length,
+            };
+        })(),
+        options.pdf
+            ? emitLilypondPdfAsset({
+                title: score.assetTitle,
+                source: score.source,
+                binaryPath: state.binaryPath,
+                render: () => renderScore(score.source, {
+                    format: "pdf",
+                    crop: false,
+                    defaults: state.defaults,
+                    timeout: state.timeout,
+                    binaryPath: state.binaryPath,
+                    includePaths: score.includePaths,
+                    sourceName: score.sourceName,
+                }),
+            })
+            : Promise.resolve(undefined),
+    ]);
+    return { Score, pageCount, pdf, meta: score.meta, raw: score.source };
+}
+/**
+ * Renders a `LilypondScore` directly, for the common case where none of
+ * `render()`'s `pageCount`, `meta`, `raw`, or `pdf` are needed. Use
+ * `render()` instead when you need those.
+ */
+export const Score = createComponent(async (result, props) => {
+    const { content, format, crop, ...imageProps } = props;
+    const { Score: ContentScore } = await render(content, { format, crop });
+    return renderTemplate `${renderComponent(result, "Score", ContentScore, imageProps)}`;
+});
+export async function renderAll(scores, options = {}) {
+    return Promise.all(scores.map((score) => render(score, options)));
+}
+function lyFilePlugin(options) {
+    return {
+        name: "vite-plugin-astro-lilypond-ly",
+        enforce: "pre",
+        async transform(source, id) {
+            if (!LY_EXTENSIONS.some((ext) => id.endsWith(ext)))
+                return;
+            const { version } = resolveDefaults(options.defaults);
+            const src = version ? prependVersion(source, version) : source;
+            const includePaths = includePathsFor(id);
+            const sourceName = sourceNameFor(id);
+            const assetTitle = titleFor(sourceName);
+            const meta = toLilypondMetadata(parseLyHeaderFields(source));
+            const alt = altTextFor(meta);
+            const score = {
+                source: src,
                 alt,
+                sourceName,
+                includePaths,
+                assetTitle,
+                meta,
             };
             return {
-                code: `export default ${JSON.stringify(content)}`,
+                code: `export default ${JSON.stringify(score)}`,
             };
         },
     };
@@ -56,10 +115,11 @@ export default function lilypond(options = {}) {
         name: "astro-lilypond",
         hooks: {
             "astro:config:setup": async ({ config, updateConfig, logger }) => {
-                options.binaryPath = await resolveLilypondBinary({
-                    ...resolveAutoInstallOption(options.autoInstall),
-                    log: (message) => logger?.info(message),
-                    warn: (message) => logger?.warn(message),
+                options.binaryPath = await resolveAndSetRenderState({
+                    autoInstall: options.autoInstall,
+                    defaults: options.defaults,
+                    timeout: options.timeout,
+                    logger,
                 });
                 updateConfig({
                     integrations: [emitAssetIntegration()],
@@ -120,7 +180,7 @@ export default function lilypond(options = {}) {
             "astro:config:done": ({ injectTypes }) => {
                 injectTypes({
                     filename: "ly-types.d.ts",
-                    content: lyTypeDeclarationsFor(LY_EXTENSIONS, RECOGNIZED_QUERY_PARAMS),
+                    content: lyTypeDeclarationsFor(LY_EXTENSIONS),
                 });
             },
         },

package/dist/loader.d.ts

@@ -1,9 +1,8 @@
 import type { Loader } from "astro/loaders";
 import { z } from "astro/zod";
-import { type AutoInstallOptions } from "./binary/index.js";
-import { type LilypondContent } from "./index.js";
-import type { PluginOptions } from "./plugins/index.js";
-import { type KnownLyHeaderFields } from "./utils/index.js";
+import type { AutoInstallOptions } from "./binary/index.js";
+import { type LilypondScore } from "./index.js";
+import type { LilypondDefaults } from "./render.js";
 export interface GenerateIdOptions {
     /** The path to the entry file, relative to `base`. */
     entry: string;
@@ -12,7 +11,7 @@ export interface GenerateIdOptions {
     /** The entry's parsed `\header` fields (see `parseLyHeaderFields`). */
     header: Record<string, string>;
 }
-export interface LilypondLoaderOptions extends PluginOptions {
+export interface LilypondLoaderOptions {
     /**
      * Glob pattern(s) matching score files, relative to `base`.
      * @default "**\/*.{ly,ily,lilypond}"
@@ -28,6 +27,18 @@ export interface LilypondLoaderOptions extends PluginOptions {
      * @default the file's path relative to `base`, POSIX-separated, with its extension stripped.
      */
     generateId?: (options: GenerateIdOptions) => string;
+    /**
+     * Defaults used when `render()` is later called on one of this
+     * collection's entries.
+     */
+    defaults?: LilypondDefaults;
+    /**
+     * Milliseconds to wait for a single `lilypond` invocation before
+     * aborting it, when `render()` is later called on one of this
+     * collection's entries.
+     * @default 60000
+     */
+    timeout?: number;
     /**
      * When no `lilypond` binary is found on `PATH`, download a matching
      * prebuilt release into a local cache and use that instead. Set to
@@ -37,33 +48,33 @@ export interface LilypondLoaderOptions extends PluginOptions {
      */
     autoInstall?: boolean | AutoInstallOptions;
 }
-export interface LilypondHeaderData extends KnownLyHeaderFields {
-    /** Header fields outside LilyPond's standard set (e.g. `mutopiacomposer`). */
-    extra: Record<string, string>;
-}
-export interface LilypondCollectionEntry extends LilypondContent, LilypondHeaderData {
-}
+/**
+ * A collection entry is itself a `LilypondScore` (its `meta` carries the
+ * file's `\header` fields) — pass `entry.data` directly to the exported
+ * `render()`, exactly as you would a plain `.ly` import.
+ */
+export type LilypondCollectionEntry = LilypondScore;
 export declare const lilypondEntrySchema: z.ZodObject<{
-    pages: z.ZodArray<z.ZodObject<{
-        src: z.ZodString;
-        width: z.ZodOptional<z.ZodNumber>;
-        height: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    alt: z.ZodOptional<z.ZodString>;
-    dedication: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    subtitle: z.ZodOptional<z.ZodString>;
-    subsubtitle: z.ZodOptional<z.ZodString>;
-    instrument: z.ZodOptional<z.ZodString>;
-    poet: z.ZodOptional<z.ZodString>;
-    composer: z.ZodOptional<z.ZodString>;
-    meter: z.ZodOptional<z.ZodString>;
-    arranger: z.ZodOptional<z.ZodString>;
-    piece: z.ZodOptional<z.ZodString>;
-    opus: z.ZodOptional<z.ZodString>;
-    copyright: z.ZodOptional<z.ZodString>;
-    tagline: z.ZodOptional<z.ZodString>;
-    extra: z.ZodRecord<z.ZodString, z.ZodString>;
+    source: z.ZodString;
+    alt: z.ZodString;
+    sourceName: z.ZodOptional<z.ZodString>;
+    includePaths: z.ZodArray<z.ZodString>;
+    assetTitle: z.ZodString;
+    meta: z.ZodObject<{
+        arranger: z.ZodOptional<z.ZodString>;
+        composer: z.ZodOptional<z.ZodString>;
+        copyright: z.ZodOptional<z.ZodString>;
+        dedication: z.ZodOptional<z.ZodString>;
+        instrument: z.ZodOptional<z.ZodString>;
+        meter: z.ZodOptional<z.ZodString>;
+        opus: z.ZodOptional<z.ZodString>;
+        piece: z.ZodOptional<z.ZodString>;
+        poet: z.ZodOptional<z.ZodString>;
+        subsubtitle: z.ZodOptional<z.ZodString>;
+        subtitle: z.ZodOptional<z.ZodString>;
+        tagline: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodString>>;
 }, z.core.$strip>;
 /**
  * Content Loader to turn a directory of `.ly` files into a content collection.

package/dist/loader.js

@@ -2,32 +2,24 @@ import { glob, readFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "astro/zod";
-import { resolveAutoInstallOption, resolveLilypondBinary, } from "./binary/index.js";
 import { LY_EXTENSIONS } from "./index.js";
-import { defaultOptions, render, resolveCrop } from "./render.js";
-import { altTextFor, emitLilypondAsset, includePathsFor, parseLyHeaderFields, prependVersion, resolveDefaults, sourceNameFor, splitHeaderFields, titleFor, } from "./utils/index.js";
+import { resolveAndSetRenderState } from "./renderState.js";
+import { altTextFor, includePathsFor, parseLyHeaderFields, prependVersion, resolveDefaults, STANDARD_HEADER_FIELDS, sourceNameFor, titleFor, toLilypondMetadata, } from "./utils/index.js";
 const DEFAULT_PATTERN = `**/*.{${LY_EXTENSIONS.map((ext) => ext.slice(1)).join(",")}}`;
+// Built from the same `STANDARD_HEADER_FIELDS` list `KnownLyHeaderFields` is
+// derived from, so the two can't drift. `.catchall()` lets any other header
+// field (e.g. `mutopiacomposer`) sit alongside the standard ones, typed as
+// `string` — matching `LilypondMetadata`'s index signature.
+const lilypondMetadataSchema = z
+    .object(Object.fromEntries(STANDARD_HEADER_FIELDS.map((field) => [field, z.string().optional()])))
+    .catchall(z.string());
 export const lilypondEntrySchema = z.object({
-    pages: z.array(z.object({
-        src: z.string(),
-        width: z.number().optional(),
-        height: z.number().optional(),
-    })),
-    alt: z.string().optional(),
-    dedication: z.string().optional(),
-    title: z.string().optional(),
-    subtitle: z.string().optional(),
-    subsubtitle: z.string().optional(),
-    instrument: z.string().optional(),
-    poet: z.string().optional(),
-    composer: z.string().optional(),
-    meter: z.string().optional(),
-    arranger: z.string().optional(),
-    piece: z.string().optional(),
-    opus: z.string().optional(),
-    copyright: z.string().optional(),
-    tagline: z.string().optional(),
-    extra: z.record(z.string(), z.string()),
+    source: z.string(),
+    alt: z.string(),
+    sourceName: z.string().optional(),
+    includePaths: z.array(z.string()),
+    assetTitle: z.string(),
+    meta: lilypondMetadataSchema,
 });
 function stripLyExtension(entryPath) {
     for (const ext of LY_EXTENSIONS) {
@@ -55,10 +47,8 @@ function posixRelative(from, to) {
  * Content Loader to turn a directory of `.ly` files into a content collection.
  */
 export function lilypondLoader(options) {
-    const { pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, format, defaults, timeout, autoInstall, } = options;
+    const { pattern = DEFAULT_PATTERN, base, generateId = defaultGenerateId, defaults, timeout, autoInstall, } = options;
     const resolved = resolveDefaults(defaults);
-    const crop = resolveCrop(resolved.crop, "component");
-    const resolvedFormat = format ?? defaultOptions.format;
     return {
         name: "astro-lilypond-loader",
         schema: lilypondEntrySchema,
@@ -67,10 +57,14 @@ export function lilypondLoader(options) {
             const rootDir = fileURLToPath(config.root);
             const baseUrl = resolveBaseUrl(base, config.root);
             const baseDir = fileURLToPath(baseUrl);
-            const binaryPath = await resolveLilypondBinary({
-                ...resolveAutoInstallOption(autoInstall),
-                log: (message) => logger.info(message),
-                warn: (message) => logger.warn(message),
+            // Populates the shared render() state, so this collection's entries
+            // can be rendered even when the `lilypond()` integration itself
+            // isn't registered.
+            await resolveAndSetRenderState({
+                autoInstall,
+                defaults,
+                timeout,
+                logger,
             });
             async function syncEntry(entry) {
                 const filePath = join(baseDir, entry);
@@ -88,34 +82,18 @@ export function lilypondLoader(options) {
                 const src = prependVersion(source, resolved.version);
                 const includePaths = includePathsFor(filePath);
                 const sourceName = sourceNameFor(filePath);
-                const title = titleFor(sourceName);
-                const pages = await emitLilypondAsset({
-                    title,
-                    format: resolvedFormat,
-                    source: src,
-                    resolution: resolved.resolution,
-                    crop,
-                    sizeScale: crop ? resolved.cropScale : 1,
-                    binaryPath,
-                    render: () => render(src, {
-                        format: resolvedFormat,
-                        crop,
-                        defaults,
-                        timeout,
-                        binaryPath,
-                        includePaths,
-                        sourceName,
-                    }),
-                });
+                const assetTitle = titleFor(sourceName);
+                const meta = toLilypondMetadata(headerFields);
+                const alt = altTextFor(meta);
                 const data = await parseData({
                     id,
                     data: {
-                        pages,
-                        alt: altTextFor({
-                            title: headerFields.title,
-                            composer: headerFields.composer,
-                        }),
-                        ...splitHeaderFields(headerFields),
+                        source: src,
+                        alt,
+                        sourceName,
+                        includePaths,
+                        assetTitle,
+                        meta,
                     },
                     filePath,
                 });

package/dist/plugins/rehype.js

@@ -1,5 +1,5 @@
 import { visit } from "unist-util-visit";
-import { defaultOptions, render, resolveCrop } from "../render.js";
+import { defaultOptions, render } from "../render.js";
 import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 // Typed loosely so it's assignable to both RehypePlugin and the unified
 // Plugin generic regardless of which @types/hast version the host project pins.
@@ -30,22 +30,21 @@ export function rehypePlugin(options) {
                 .filter((c) => c.type === "text")
                 .map((c) => c.value)
                 .join("");
-            const { version, resolution, crop: cropSetting, cropScale, } = resolveDefaults(options.defaults);
+            const { version, resolution, cropScale } = resolveDefaults(options.defaults);
             const source = version ? prependVersion(raw, version) : raw;
             const format = options.format ?? defaultOptions.format;
-            const crop = resolveCrop(cropSetting, "markdown");
             const alt = altTextForBlock(codeNode.data?.meta, raw);
             const promise = emitLilypondAsset({
                 title,
                 format,
                 source,
                 resolution,
-                crop,
-                sizeScale: crop ? cropScale : 1,
+                crop: true,
+                sizeScale: cropScale,
                 binaryPath: options.binaryPath,
                 render: () => render(source, {
                     format,
-                    crop,
+                    crop: true,
                     defaults: options.defaults,
                     timeout: options.timeout,
                     binaryPath: options.binaryPath,

package/dist/plugins/remark.js

@@ -1,5 +1,5 @@
 import { visit } from "unist-util-visit";
-import { defaultOptions, render, resolveCrop } from "../render.js";
+import { defaultOptions, render } from "../render.js";
 import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 export const remarkPlugin = (options) => {
     return async (tree, file) => {
@@ -10,22 +10,21 @@ export const remarkPlugin = (options) => {
         visit(tree, "code", (node, index, parent) => {
             if (!isLilypondLang(node.lang) || index === undefined || !parent)
                 return;
-            const { version, resolution, crop: cropSetting, cropScale, } = resolveDefaults(options.defaults);
+            const { version, resolution, cropScale } = resolveDefaults(options.defaults);
             const source = version ? prependVersion(node.value, version) : node.value;
             const format = options.format ?? defaultOptions.format;
-            const crop = resolveCrop(cropSetting, "markdown");
             const alt = altTextForBlock(node.meta, node.value);
             const promise = emitLilypondAsset({
                 title,
                 format,
                 source,
                 resolution,
-                crop,
-                sizeScale: crop ? cropScale : 1,
+                crop: true,
+                sizeScale: cropScale,
                 binaryPath: options.binaryPath,
                 render: () => render(source, {
                     format,
-                    crop,
+                    crop: true,
                     defaults: options.defaults,
                     timeout: options.timeout,
                     binaryPath: options.binaryPath,

package/dist/plugins/satteri.js

@@ -1,4 +1,4 @@
-import { defaultOptions, render, resolveCrop } from "../render.js";
+import { defaultOptions, render } from "../render.js";
 import { altTextForBlock, emitLilypondAsset, includePathsFor, isLilypondLang, prependVersion, renderedHtml, resolveDefaults, sourceNameFor, titleFor, } from "../utils/index.js";
 export function satteriPlugin(options) {
     return {
@@ -9,25 +9,24 @@ export function satteriPlugin(options) {
         async code(node, ctx) {
             if (!isLilypondLang(node.lang))
                 return undefined;
-            const { version, resolution, crop: cropSetting, cropScale, } = resolveDefaults(options.defaults);
+            const { version, resolution, cropScale } = resolveDefaults(options.defaults);
             const source = version ? prependVersion(node.value, version) : node.value;
             const format = options.format ?? defaultOptions.format;
             const includePaths = includePathsFor(ctx.fileURL);
             const sourceName = sourceNameFor(ctx.fileURL);
             const title = titleFor(sourceName);
-            const crop = resolveCrop(cropSetting, "markdown");
             const alt = altTextForBlock(node.meta, node.value);
             const pages = await emitLilypondAsset({
                 title,
                 format,
                 source,
                 resolution,
-                crop,
-                sizeScale: crop ? cropScale : 1,
+                crop: true,
+                sizeScale: cropScale,
                 binaryPath: options.binaryPath,
                 render: () => render(source, {
                     format,
-                    crop,
+                    crop: true,
                     defaults: options.defaults,
                     timeout: options.timeout,
                     binaryPath: options.binaryPath,

package/dist/readOutputFile.js

@@ -20,14 +20,13 @@ function byPageNumber(a, b) {
     return Number(a[1]) - Number(b[1]);
 }
 /**
- * Multi-page naming convention per format: SVG (and PDF/PS/EPS, should they
- * be added to `FORMATS`) uses `<base>-1.<ext>`; PNG uses `<base>-page1.<ext>`.
- * Listed explicitly so adding a format means stating its convention here,
- * not guessing among known patterns.
+ * Multi-page naming convention per format: SVG uses `<base>-1.<ext>`; PNG
+ * uses `<base>-page1.<ext>`. `pdf` always renders to one `<base>.pdf`.
  */
 const PAGE_NUMBER_INFIX = {
     svg: "-",
     png: "-page",
+    pdf: "-",
 };
 export async function readOutputFile(base, format, crop) {
     // --define-default crop writes <base>.cropped.<format> alongside <base>.<format>
@@ -39,9 +38,7 @@ export async function readOutputFile(base, format, crop) {
             throw new Error(`expected cropped output at ${base}.cropped.${format} but it was not found: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    // Regular output: single page → <base>.<format>; multi-page → numbered
-    // per `PAGE_NUMBER_INFIX`. List the directory once so the full page
-    // count is known up front, rather than probing paths one at a time.
+    // Single page → <base>.<format>; multi-page → numbered per PAGE_NUMBER_INFIX.
     const dir = dirname(base);
     const prefix = basename(base);
     const entries = await readdir(dir);

package/dist/render.d.ts

@@ -1,27 +1,8 @@
 import type { LilypondVersion } from "./types/lilypondVersion.js";
-export declare const FORMATS: readonly ["png", "svg"];
+export declare const FORMATS: readonly ["png", "svg", "pdf"];
 export type Format = (typeof FORMATS)[number];
-/**
- * Controls whether rendered output is cropped tightly to the content
- * bounding box, or left as full, potentially multi-page, output.
- *
- * - `true` — crop everywhere: Markdown fences and `<LilyPond>` `.ly` imports.
- * - `false` — never crop by default (a `.ly` import can still opt in with
- *   `?crop`).
- * - `"markdown-only"` — crop Markdown fences, but leave `<LilyPond>` `.ly`
- *   imports uncropped unless the import opts in with `?crop`.
- */
-export type CropSetting = boolean | "markdown-only";
-/** Which kind of consumer is resolving a `CropSetting` — see `resolveCrop`. */
-export type CropContext = "markdown" | "component";
-/**
- * Resolves the three-way `CropSetting` into the plain boolean a given
- * consumer needs, per the semantics documented on `CropSetting`.
- */
-export declare function resolveCrop(cropSetting: CropSetting, context: CropContext): boolean;
 /**
  * Defaults passed to each score for rendering.
- * Individual instances can override.
  */
 export interface LilypondDefaults {
     /**
@@ -35,12 +16,6 @@ export interface LilypondDefaults {
      * @default 144
      */
     resolution?: number;
-    /**
-     * Crop the output tightly to the content bounding box, producing one
-     * continuous image instead of paginated output.
-     * @default "markdown-only"
-     */
-    crop?: CropSetting;
     /**
      * Multiplies the `width`/`height` on a cropped score's `<img>` tag.
      * Helps compensate for LilyPond's internal size units (points/mm)
@@ -53,10 +28,10 @@ export interface LilypondDefaults {
 }
 /**
  * The subset of `LilypondDefaults` that `render()` itself reads. `version`
- * and `crop` are resolved by the caller before reaching `render()`
- * (`version` by prepending it to source text, `crop` via `resolveCrop`).
+ * is resolved by the caller before reaching `render()`, by prepending it to
+ * source text.
  */
-export type RenderDefaults = Omit<LilypondDefaults, "version" | "crop">;
+export type RenderDefaults = Omit<LilypondDefaults, "version">;
 export interface RenderOptions {
     /**
      * Output format.

package/dist/render.js

@@ -4,14 +4,7 @@ import { join } from "node:path";
 import { execLilyPond } from "./execLilyPond.js";
 import { readOutputFile, safeInputFileName } from "./readOutputFile.js";
 import { resolveDefaults } from "./utils/resolveDefaults.js";
-export const FORMATS = ["png", "svg"];
-/**
- * Resolves the three-way `CropSetting` into the plain boolean a given
- * consumer needs, per the semantics documented on `CropSetting`.
- */
-export function resolveCrop(cropSetting, context) {
-    return context === "markdown" ? cropSetting !== false : cropSetting === true;
-}
+export const FORMATS = ["png", "svg", "pdf"];
 export const defaultOptions = {
     format: "svg",
     crop: true,
@@ -20,7 +13,6 @@ export const defaultOptions = {
     defaults: {
         version: "2.26.0",
         resolution: 144,
-        crop: "markdown-only",
         cropScale: 1.5,
     },
 };

package/dist/renderState.d.ts

@@ -0,0 +1,29 @@
+import { type AutoInstallOptions } from "./binary/index.js";
+import type { LilypondDefaults } from "./render.js";
+export interface RenderState {
+    binaryPath: string;
+    defaults: LilypondDefaults | undefined;
+    timeout: number | undefined;
+}
+/** Called by the `lilypond()` integration's `astro:config:setup` hook. */
+export declare function setRenderState(next: RenderState): void;
+/** Read by the public `render()`, called from user code rather than the integration's own closures. */
+export declare function getRenderState(): RenderState;
+/** Test-only: resets the shared singleton between test cases. */
+export declare function resetRenderStateForTests(): void;
+export interface ResolveAndSetRenderStateOptions {
+    autoInstall?: boolean | AutoInstallOptions;
+    defaults?: LilypondDefaults;
+    timeout?: number;
+    logger: {
+        info: (message: string) => void;
+        warn: (message: string) => void;
+    };
+}
+/**
+ * Shared by the `lilypond()` integration's `astro:config:setup` hook and
+ * `lilypondLoader()`'s `load()`: resolves the `lilypond` binary and
+ * populates the render state from it. Returns the resolved binary path for
+ * callers (e.g. Markdown plugins) that also need it directly.
+ */
+export declare function resolveAndSetRenderState(options: ResolveAndSetRenderStateOptions): Promise<string>;

package/dist/renderState.js

@@ -0,0 +1,46 @@
+import { resolveAutoInstallOption, resolveLilypondBinary, } from "./binary/index.js";
+/**
+ * Keyed on `globalThis` rather than module-scope state — some Astro adapters
+ * bundle the render step as a separate chunk with its own copy of this
+ * module, so a plain module `let` wouldn't survive from
+ * `astro:config:setup` into an actual render.
+ */
+const GLOBAL_KEY = "astro-lilypond:renderState";
+function globalStore() {
+    return globalThis;
+}
+/** Called by the `lilypond()` integration's `astro:config:setup` hook. */
+export function setRenderState(next) {
+    globalStore()[GLOBAL_KEY] = next;
+}
+/** Read by the public `render()`, called from user code rather than the integration's own closures. */
+export function getRenderState() {
+    const state = globalStore()[GLOBAL_KEY];
+    if (!state) {
+        throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
+    }
+    return state;
+}
+/** Test-only: resets the shared singleton between test cases. */
+export function resetRenderStateForTests() {
+    globalStore()[GLOBAL_KEY] = undefined;
+}
+/**
+ * Shared by the `lilypond()` integration's `astro:config:setup` hook and
+ * `lilypondLoader()`'s `load()`: resolves the `lilypond` binary and
+ * populates the render state from it. Returns the resolved binary path for
+ * callers (e.g. Markdown plugins) that also need it directly.
+ */
+export async function resolveAndSetRenderState(options) {
+    const binaryPath = await resolveLilypondBinary({
+        ...resolveAutoInstallOption(options.autoInstall),
+        log: (message) => options.logger.info(message),
+        warn: (message) => options.logger.warn(message),
+    });
+    setRenderState({
+        binaryPath,
+        defaults: options.defaults,
+        timeout: options.timeout,
+    });
+    return binaryPath;
+}

package/dist/utils/{emitLilypondAsset.fake.d.ts → __tests__/emitLilypondAsset.fake.d.ts}

@@ -1,5 +1,5 @@
 import type { vi } from "vitest";
-import type { emitLilypondAsset } from "./emitLilypondAsset.js";
+import type { emitLilypondAsset } from "../emitLilypondAsset.js";
 type EmitLilypondAssetMock = ReturnType<typeof vi.mocked<typeof emitLilypondAsset>>;
 export declare function fakeEmitLilypondAsset(mock: EmitLilypondAssetMock, urlBase?: string): void;
 export declare function fakeEmitLilypondAssetPropagatingRenderErrors(mock: EmitLilypondAssetMock): void;

package/dist/utils/__tests__/emitLilypondPdfAsset.fake.d.ts

@@ -0,0 +1,5 @@
+import type { vi } from "vitest";
+import type { emitLilypondPdfAsset } from "../emitLilypondPdfAsset.js";
+type EmitLilypondPdfAssetMock = ReturnType<typeof vi.mocked<typeof emitLilypondPdfAsset>>;
+export declare function fakeEmitLilypondPdfAsset(mock: EmitLilypondPdfAssetMock, urlBase?: string): void;
+export {};

package/dist/utils/__tests__/emitLilypondPdfAsset.fake.js

@@ -0,0 +1,6 @@
+export function fakeEmitLilypondPdfAsset(mock, urlBase = "/_astro") {
+    mock.mockImplementation(async (opts) => {
+        await opts.render();
+        return { src: `${urlBase}/${opts.title}.pdf` };
+    });
+}

package/dist/utils/emitLilypondPdfAsset.d.ts

@@ -0,0 +1,8 @@
+import type { LilypondPdfResult } from "../index.js";
+export interface EmitLilypondPdfAssetOptions {
+    title: string;
+    source: string;
+    binaryPath: string | undefined;
+    render: () => Promise<Buffer[]>;
+}
+export declare function emitLilypondPdfAsset(options: EmitLilypondPdfAssetOptions): Promise<LilypondPdfResult>;

package/dist/utils/emitLilypondPdfAsset.js

@@ -0,0 +1,12 @@
+import { emitAsset } from "astro-emit-asset/emit";
+export async function emitLilypondPdfAsset(options) {
+    if (!options.binaryPath) {
+        throw new Error("astro-lilypond: please add the `lilypond()` integration to your Astro config.");
+    }
+    const { title, source, render } = options;
+    const asset = await emitAsset(`${title}.[hash].pdf`, [source, "pdf"], async () => {
+        const [data] = await render();
+        return { data };
+    });
+    return { src: asset.src };
+}

package/dist/utils/index.d.ts

@@ -1,12 +1,14 @@
 export { altTextFor } from "./altTextFor.js";
 export { altTextForBlock } from "./altTextForBlock.js";
 export { type EmitLilypondAssetOptions, emitLilypondAsset, } from "./emitLilypondAsset.js";
+export { type EmitLilypondPdfAssetOptions, emitLilypondPdfAsset, } from "./emitLilypondPdfAsset.js";
 export { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
 export type { ImageDimensions } from "./imageDimensions.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
 export { includePathsFor } from "./includePathsFor.js";
 export { isLilypondLang } from "./isLilypondLang.js";
-export { parseLyImportQuery, RECOGNIZED_QUERY_PARAMS, } from "./lyImportQuery.js";
+export type { KnownLyHeaderFields, LilypondMetadata, } from "./lilypondMetadata.js";
+export { STANDARD_HEADER_FIELDS, toLilypondMetadata, } from "./lilypondMetadata.js";
 export { lyTypeDeclarationsFor } from "./lyTypeDeclarationsFor.js";
 export { parseFenceMeta } from "./parseFenceMeta.js";
 export type { LyHeaderFields } from "./parseLyHeader.js";
@@ -15,7 +17,5 @@ export { prependVersion } from "./prependVersion.js";
 export { renderedHtml } from "./renderedHtml.js";
 export { resolveDefaults } from "./resolveDefaults.js";
 export { sourceNameFor } from "./sourceNameFor.js";
-export type { KnownLyHeaderFields } from "./splitHeaderFields.js";
-export { STANDARD_HEADER_FIELDS, splitHeaderFields, } from "./splitHeaderFields.js";
 export { titleFor } from "./titleFor.js";
 export { unescapeQuoted } from "./unescapeQuoted.js";

package/dist/utils/index.js

@@ -1,11 +1,12 @@
 export { altTextFor } from "./altTextFor.js";
 export { altTextForBlock } from "./altTextForBlock.js";
 export { emitLilypondAsset, } from "./emitLilypondAsset.js";
+export { emitLilypondPdfAsset, } from "./emitLilypondPdfAsset.js";
 export { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
 export { imageDimensionsFor } from "./imageDimensions.js";
 export { includePathsFor } from "./includePathsFor.js";
 export { isLilypondLang } from "./isLilypondLang.js";
-export { parseLyImportQuery, RECOGNIZED_QUERY_PARAMS, } from "./lyImportQuery.js";
+export { STANDARD_HEADER_FIELDS, toLilypondMetadata, } from "./lilypondMetadata.js";
 export { lyTypeDeclarationsFor } from "./lyTypeDeclarationsFor.js";
 export { parseFenceMeta } from "./parseFenceMeta.js";
 export { extractMarkupText, parseLyHeader, parseLyHeaderFields, } from "./parseLyHeader.js";
@@ -13,6 +14,5 @@ export { prependVersion } from "./prependVersion.js";
 export { renderedHtml } from "./renderedHtml.js";
 export { resolveDefaults } from "./resolveDefaults.js";
 export { sourceNameFor } from "./sourceNameFor.js";
-export { STANDARD_HEADER_FIELDS, splitHeaderFields, } from "./splitHeaderFields.js";
 export { titleFor } from "./titleFor.js";
 export { unescapeQuoted } from "./unescapeQuoted.js";

package/dist/utils/lilypondMetadata.d.ts

@@ -0,0 +1,10 @@
+export declare const STANDARD_HEADER_FIELDS: readonly ["arranger", "composer", "copyright", "dedication", "instrument", "meter", "opus", "piece", "poet", "subsubtitle", "subtitle", "tagline", "title"];
+export type KnownLyHeaderFields = {
+    [K in (typeof STANDARD_HEADER_FIELDS)[number]]?: string;
+};
+/** Header metadata extracted from a score's `\header` block(s). */
+export interface LilypondMetadata extends KnownLyHeaderFields {
+    [field: string]: string | undefined;
+}
+/** Tags a bag of parsed `\header` fields (see `parseLyHeaderFields`) as `LilypondMetadata`. */
+export declare function toLilypondMetadata(fields: Record<string, string>): LilypondMetadata;

package/dist/utils/lilypondMetadata.js

@@ -0,0 +1,19 @@
+export const STANDARD_HEADER_FIELDS = [
+    "arranger",
+    "composer",
+    "copyright",
+    "dedication",
+    "instrument",
+    "meter",
+    "opus",
+    "piece",
+    "poet",
+    "subsubtitle",
+    "subtitle",
+    "tagline",
+    "title",
+];
+/** Tags a bag of parsed `\header` fields (see `parseLyHeaderFields`) as `LilypondMetadata`. */
+export function toLilypondMetadata(fields) {
+    return fields;
+}

package/dist/utils/lyTypeDeclarationsFor.d.ts

@@ -1,6 +1,2 @@
-/**
- * Builds the ambient module declarations injected for `.ly`-family imports,
- * so `import content from "./score.ly"` (and its `?crop`/`?nocrop` query
- * variants) type-check as a default-exported `LilypondContent`.
- */
-export declare function lyTypeDeclarationsFor(extensions: readonly string[], queryParams: readonly string[]): string;
+/** Build the ambient module declarations injected for `.ly`-family imports. */
+export declare function lyTypeDeclarationsFor(extensions: readonly string[]): string;

package/dist/utils/lyTypeDeclarationsFor.js

@@ -1,11 +1,6 @@
-/**
- * Builds the ambient module declarations injected for `.ly`-family imports,
- * so `import content from "./score.ly"` (and its `?crop`/`?nocrop` query
- * variants) type-check as a default-exported `LilypondContent`.
- */
-export function lyTypeDeclarationsFor(extensions, queryParams) {
-    const suffixes = ["", ...queryParams.map((param) => `?${param}`)];
+/** Build the ambient module declarations injected for `.ly`-family imports. */
+export function lyTypeDeclarationsFor(extensions) {
     return extensions
-        .flatMap((ext) => suffixes.map((suffix) => `declare module "*${ext}${suffix}" {\n  const content: import("astro-lilypond").LilypondContent;\n  export default content;\n}`))
+        .map((ext) => `declare module "*${ext}" {\n  const score: import("astro-lilypond").LilypondScore;\n  export default score;\n}`)
         .join("\n");
 }

package/dist/utils/parseLyHeader.js

@@ -209,9 +209,8 @@ function parseFieldValue(body, start) {
             i++;
         if (body[i] !== "{")
             return null;
+        // body is itself a properly-nested brace sequence (see allHeaderBodies), so this `{` always has a matching `}`.
         const end = matchBalancedBraces(body, i);
-        if (end === -1)
-            return null;
         const value = extractMarkupText(body.slice(i + 1, end));
         return value ? { value, end: end + 1 } : null;
     }

package/dist/utils/renderedHtml.d.ts

@@ -1,2 +1,10 @@
 import type { LilypondPage } from "../index.js";
-export declare function renderedHtml(pages: LilypondPage[], alt: string): string;
+export interface RenderedHtmlOptions {
+    /** Class applied to the outer `<img>` or `<ol>` tag. */
+    class?: string;
+    /** Inline styles applied to the outer `<img>` or `<ol>`. */
+    style?: string;
+    /** Render only the first `n` pages. */
+    pageLimit?: number;
+}
+export declare function renderedHtml(pages: LilypondPage[], alt: string, options?: RenderedHtmlOptions): string;

package/dist/utils/renderedHtml.js

@@ -1,16 +1,19 @@
-import { escapeHtmlAttribute } from "./escapeHtmlAttribute.js";
-function imgTag(page, escapedAlt) {
-    const size = page.width !== undefined && page.height !== undefined
-        ? ` width="${page.width}" height="${page.height}"`
-        : "";
-    return `<img data-lilypond-image src="${page.src}"${size} alt="${escapedAlt}">`;
+import { addAttribute } from "astro/runtime/server/index.js";
+function imgTag(page, alt) {
+    return `<img data-lilypond-image${addAttribute(page.src, "src")}${addAttribute(page.width, "width")}${addAttribute(page.height, "height")}${addAttribute(alt, "alt")}>`;
 }
-export function renderedHtml(pages, alt) {
-    const escapedAlt = escapeHtmlAttribute(alt);
-    if (pages.length === 1) {
-        return imgTag(pages[0], escapedAlt);
+export function renderedHtml(pages, alt, options = {}) {
+    const { class: className, style, pageLimit } = options;
+    const limitedPages = pageLimit === undefined ? pages : pages.slice(0, pageLimit);
+    if (limitedPages.length === 0)
+        return "";
+    const classAttr = addAttribute(className, "class");
+    const styleAttr = addAttribute(style, "style");
+    if (limitedPages.length === 1) {
+        const page = limitedPages[0];
+        return `<img data-lilypond-image${classAttr}${addAttribute(page.src, "src")}${addAttribute(page.width, "width")}${addAttribute(page.height, "height")}${addAttribute(alt, "alt")}${styleAttr}>`;
     }
-    return `<ol data-lilypond-group>${pages
-        .map((page) => `<li>${imgTag(page, escapedAlt)}</li>`)
+    return `<ol data-lilypond-group${classAttr}${styleAttr}>${limitedPages
+        .map((page) => `<li>${imgTag(page, alt)}</li>`)
         .join("")}</ol>`;
 }

package/dist/utils/resolveDefaults.js

@@ -1,11 +1,10 @@
 import { defaultOptions } from "../render.js";
 /** Fills in any `defaults` fields left unset with `render.ts`'s own defaults. */
 export function resolveDefaults(defaults) {
-    const { version, resolution, crop, cropScale } = defaultOptions.defaults;
+    const { version, resolution, cropScale } = defaultOptions.defaults;
     return {
         version: defaults?.version ?? version,
         resolution: defaults?.resolution ?? resolution,
-        crop: defaults?.crop ?? crop,
         cropScale: defaults?.cropScale ?? cropScale,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-lilypond",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "An Astro integration for rendering Lilypond markup to music notation.",
   "homepage": "https://lilypond.ky.fyi",
   "author": "Ky Decker",
@@ -17,15 +17,13 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./component": "./components/LilyPond.astro",
     "./loader": {
       "types": "./dist/loader.d.ts",
       "import": "./dist/loader.js"
     }
   },
   "files": [
-    "dist",
-    "components/*.astro"
+    "dist"
   ],
   "keywords": [
     "astro",
@@ -56,6 +54,7 @@
     "@astrojs/markdown-satteri": "^0.3.4",
     "@types/mdast": "^4.0.4",
     "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
     "astro": "^7.0.8",
     "satteri": "^0.9.5",
     "typescript": "^7.0.2",
@@ -66,6 +65,7 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "test": "vitest --project unit",
+    "test:coverage": "vitest run --project unit --coverage",
     "test:integration": "vitest run --project integration"
   }
 }

package/components/LilyPond.astro

@@ -1,52 +0,0 @@
----
-interface Props {
-	content: {
-		pages: { src: string; width?: number; height?: number }[];
-		alt?: string;
-	};
-	pageLimit?: number;
-	class?: string | undefined;
-	style?: string | undefined;
-	alt?: string | undefined;
-}
-
-const {
-	content,
-	pageLimit,
-	class: className,
-	style,
-	alt: altProp,
-} = Astro.props;
-const { alt: contentAlt } = content;
-const pages =
-	pageLimit === undefined ? content.pages : content.pages.slice(0, pageLimit);
-const alt = altProp ?? contentAlt ?? "";
----
-
-{
-  pages.length === 1 ? (
-    <img
-      data-lilypond-image
-      class={className}
-      src={pages[0].src}
-      width={pages[0].width}
-      height={pages[0].height}
-      alt={alt}
-      style={style}
-    />
-  ) : (
-    <ol data-lilypond-group class={className} style={style}>
-      {pages.map((page) => (
-        <li>
-          <img
-            data-lilypond-image
-            src={page.src}
-            width={page.width}
-            height={page.height}
-            alt={alt}
-          />
-        </li>
-      ))}
-    </ol>
-  )
-}

package/dist/utils/lyImportQuery.d.ts

@@ -1,22 +0,0 @@
-/** Query params `lyFilePlugin` recognizes as its own on a `.ly`-family import. */
-export declare const RECOGNIZED_QUERY_PARAMS: readonly ["crop", "nocrop"];
-export interface LyImportQuery {
-    /** The import's module id with any query string stripped. */
-    pathname: string;
-    /**
-     * The crop override the import's query string requests, if any:
-     * `true` for `?crop`, `false` for `?nocrop`, `undefined` if neither is
-     * present (the caller's own default applies).
-     */
-    cropOverride: boolean | undefined;
-}
-/**
- * Parses a Vite module id for a `.ly`/`.lilypond`/`.ily` import into its
- * pathname and this plugin's `?crop`/`?nocrop` override.
- *
- * Returns `undefined` when the id carries a query param this plugin
- * doesn't own (e.g. Vite's built-in `?raw`, `?url`) — such imports aren't
- * ours to render, and the caller should let them fall through to whichever
- * plugin does own them.
- */
-export declare function parseLyImportQuery(id: string): LyImportQuery | undefined;

package/dist/utils/lyImportQuery.js

@@ -1,26 +0,0 @@
-/** Query params `lyFilePlugin` recognizes as its own on a `.ly`-family import. */
-export const RECOGNIZED_QUERY_PARAMS = ["crop", "nocrop"];
-const RECOGNIZED_PARAMS = new Set(RECOGNIZED_QUERY_PARAMS);
-/**
- * Parses a Vite module id for a `.ly`/`.lilypond`/`.ily` import into its
- * pathname and this plugin's `?crop`/`?nocrop` override.
- *
- * Returns `undefined` when the id carries a query param this plugin
- * doesn't own (e.g. Vite's built-in `?raw`, `?url`) — such imports aren't
- * ours to render, and the caller should let them fall through to whichever
- * plugin does own them.
- */
-export function parseLyImportQuery(id) {
-    const queryIndex = id.indexOf("?");
-    const pathname = queryIndex === -1 ? id : id.slice(0, queryIndex);
-    const params = new URLSearchParams(queryIndex === -1 ? "" : id.slice(queryIndex + 1));
-    if ([...params.keys()].some((key) => !RECOGNIZED_PARAMS.has(key))) {
-        return undefined;
-    }
-    const cropOverride = params.has("crop")
-        ? true
-        : params.has("nocrop")
-            ? false
-            : undefined;
-    return { pathname, cropOverride };
-}

package/dist/utils/splitHeaderFields.d.ts

@@ -1,23 +0,0 @@
-/**
- * LilyPond's standard `\header` field names
- */
-export declare const STANDARD_HEADER_FIELDS: readonly ["dedication", "title", "subtitle", "subsubtitle", "instrument", "poet", "composer", "meter", "arranger", "piece", "opus", "copyright", "tagline"];
-export interface KnownLyHeaderFields {
-    dedication?: string;
-    title?: string;
-    subtitle?: string;
-    subsubtitle?: string;
-    instrument?: string;
-    poet?: string;
-    composer?: string;
-    meter?: string;
-    arranger?: string;
-    piece?: string;
-    opus?: string;
-    copyright?: string;
-    tagline?: string;
-}
-/** Splits parsed header fields into LilyPond's standard named fields and everything else (e.g. `mutopiacomposer`, `maintainerEmail`). */
-export declare function splitHeaderFields(fields: Record<string, string>): KnownLyHeaderFields & {
-    extra: Record<string, string>;
-};

package/dist/utils/splitHeaderFields.js

@@ -1,32 +0,0 @@
-/**
- * LilyPond's standard `\header` field names
- */
-export const STANDARD_HEADER_FIELDS = [
-    "dedication",
-    "title",
-    "subtitle",
-    "subsubtitle",
-    "instrument",
-    "poet",
-    "composer",
-    "meter",
-    "arranger",
-    "piece",
-    "opus",
-    "copyright",
-    "tagline",
-];
-/** Splits parsed header fields into LilyPond's standard named fields and everything else (e.g. `mutopiacomposer`, `maintainerEmail`). */
-export function splitHeaderFields(fields) {
-    const known = {};
-    const extra = {};
-    for (const [key, value] of Object.entries(fields)) {
-        if (STANDARD_HEADER_FIELDS.includes(key)) {
-            known[key] = value;
-        }
-        else {
-            extra[key] = value;
-        }
-    }
-    return { ...known, extra };
-}