gerdur-core 1.0.4 → 2.0.0

package/dist/metadata-writer/id3.js

@@ -6,114 +6,121 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeMetadataMp3 = void 0;
 // @ts-ignore
 const browser_id3_writer_1 = __importDefault(require("browser-id3-writer"));
-const writeMetadataMp3 = (buffer, track, album, cover) => {
-    const writer = new browser_id3_writer_1.default(buffer);
-    const RELEASE_DATES = album && album.release_date.split('-');
-    writer
-        .setFrame('TIT2', track.SNG_TITLE)
-        .setFrame('TALB', track.ALB_TITLE)
-        .setFrame('TPE1', track.ARTISTS.map((a) => a.ART_NAME))
-        .setFrame('TLEN', Number(track.DURATION) * 1000)
-        .setFrame('TSRC', track.ISRC);
-    if (album) {
-        if (album.genres.data.length > 0) {
-            writer.setFrame('TCON', album.genres.data.map((g) => g.name));
-        }
-        if (RELEASE_DATES) {
-            writer.setFrame('TYER', RELEASE_DATES[0]).setFrame('TDAT', RELEASE_DATES[2] + RELEASE_DATES[1]);
-        }
-        writer
-            .setFrame('TPE2', album.artist.name)
-            .setFrame('TXXX', {
-            description: 'RELEASETYPE',
-            value: album.record_type,
-        })
-            .setFrame('TXXX', {
-            description: 'BARCODE',
-            value: album.upc,
-        })
-            .setFrame('TXXX', {
-            description: 'LABEL',
-            value: album.label,
-        })
-            .setFrame('TXXX', {
-            description: 'COMPILATION',
-            value: album.artist.name.match(/various/i) ? '1' : '0',
-        });
+const join = (arr) => arr.filter(Boolean).join('; ');
+/**
+ * Write an ID3v2.3 tag from the canonical model. `browser-id3-writer` is a v2.3
+ * writer, so there is no `SYLT` (synced lyrics) or `TDRC`/`TDOR` — synced lyrics
+ * ship as a `.lrc` sidecar from the CLI, and dates use `TYER`/`TDAT` plus
+ * `TXXX:ORIGINALDATE`.
+ */
+const writeMetadataMp3 = (buffer, m) => {
+    const w = new browser_id3_writer_1.default(buffer);
+    const txxx = (description, value) => {
+        const v = Array.isArray(value) ? join(value) : value;
+        if (v)
+            w.setFrame('TXXX', { description, value: v });
+    };
+    w.setFrame('TIT2', m.title);
+    if (m.subtitle)
+        w.setFrame('TIT3', m.subtitle);
+    w.setFrame('TALB', m.album);
+    if (m.artists.length)
+        w.setFrame('TPE1', m.artists);
+    if (m.albumArtist)
+        w.setFrame('TPE2', m.albumArtist);
+    if (m.composers.length)
+        w.setFrame('TCOM', m.composers);
+    if (m.lyricists.length)
+        w.setFrame('TEXT', join(m.lyricists));
+    if (m.mixers.length)
+        w.setFrame('TPE4', join(m.mixers));
+    if (m.genres.length)
+        w.setFrame('TCON', m.genres);
+    if (m.label)
+        w.setFrame('TPUB', m.label);
+    if (m.isrc)
+        w.setFrame('TSRC', m.isrc);
+    if (m.durationMs)
+        w.setFrame('TLEN', m.durationMs);
+    if (m.bpm)
+        w.setFrame('TBPM', Math.round(m.bpm));
+    w.setFrame('TMED', 'Digital Media');
+    if (m.trackNumber) {
+        w.setFrame('TRCK', m.trackTotal ? `${m.trackNumber}/${m.trackTotal}` : String(m.trackNumber));
     }
-    writer
-        .setFrame('TMED', 'Digital Media')
-        .setFrame('TXXX', {
-        description: 'SOURCE',
-        value: 'Deezer',
-    })
-        .setFrame('TXXX', {
-        description: 'SOURCEID',
-        value: track.SNG_ID,
-    });
-    if (track.DISK_NUMBER) {
-        const TRACK_NUMBER = track.TRACK_NUMBER.toLocaleString('en-US', { minimumIntegerDigits: 2 });
-        writer.setFrame('TPOS', track.DISK_NUMBER).setFrame('TRCK', album
-            ? `${TRACK_NUMBER}/${album.nb_tracks.toLocaleString('en-US', {
-                minimumIntegerDigits: 2,
-            })}`
-            : TRACK_NUMBER);
+    if (m.discNumber) {
+        w.setFrame('TPOS', m.discTotal ? `${m.discNumber}/${m.discTotal}` : String(m.discNumber));
     }
-    if (track.SNG_CONTRIBUTORS && !Array.isArray(track.SNG_CONTRIBUTORS)) {
-        if (track.SNG_CONTRIBUTORS.main_artist) {
-            writer.setFrame('TCOP', `${RELEASE_DATES ? RELEASE_DATES[0] + ' ' : ''}${track.SNG_CONTRIBUTORS.main_artist[0]}`);
-        }
-        if (track.SNG_CONTRIBUTORS.publisher) {
-            writer.setFrame('TPUB', track.SNG_CONTRIBUTORS.publisher.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.composer) {
-            writer.setFrame('TCOM', track.SNG_CONTRIBUTORS.composer);
-        }
-        if (track.SNG_CONTRIBUTORS.writer) {
-            writer.setFrame('TXXX', {
-                description: 'LYRICIST',
-                value: track.SNG_CONTRIBUTORS.writer.join(', '),
-            });
-        }
-        if (track.SNG_CONTRIBUTORS.author) {
-            writer.setFrame('TXXX', {
-                description: 'AUTHOR',
-                value: track.SNG_CONTRIBUTORS.author.join(', '),
-            });
-        }
-        if (track.SNG_CONTRIBUTORS.mixer) {
-            writer.setFrame('TXXX', {
-                description: 'MIXARTIST',
-                value: track.SNG_CONTRIBUTORS.mixer.join(', '),
-            });
-        }
-        if (track.SNG_CONTRIBUTORS.producer && track.SNG_CONTRIBUTORS.engineer) {
-            writer.setFrame('TXXX', {
-                description: 'INVOLVEDPEOPLE',
-                value: track.SNG_CONTRIBUTORS.producer.concat(track.SNG_CONTRIBUTORS.engineer).join(', '),
-            });
-        }
+    if (m.year)
+        w.setFrame('TYER', Number(m.year));
+    if (m.date && /^\d{4}-\d{2}-\d{2}$/.test(m.date)) {
+        const [, mm, dd] = m.date.split('-');
+        w.setFrame('TDAT', Number(dd + mm));
     }
-    if (track.LYRICS) {
-        writer.setFrame('USLT', {
-            description: '',
-            lyrics: track.LYRICS.LYRICS_TEXT,
-        });
+    if (m.copyright)
+        w.setFrame('TCOP', m.copyright);
+    // v2.3 has no native frames for these — user-defined text, Picard-compatible keys
+    txxx('DATE', m.date || '');
+    txxx('ORIGINALDATE', m.originalDate || '');
+    txxx('ORIGINALYEAR', m.originalYear || '');
+    txxx('BARCODE', m.barcode || '');
+    if (m.bpm)
+        txxx('BPM', String(m.bpm));
+    txxx('RELEASETYPE', m.releaseType || '');
+    txxx('COMPILATION', m.isCompilation ? '1' : '0');
+    txxx('ITUNESADVISORY', String(m.itunesAdvisory));
+    if (m.explicit !== 'unknown')
+        txxx('EXPLICIT', m.explicit === 'explicit' ? '1' : '0');
+    if (m.replayGainTrackGain)
+        txxx('REPLAYGAIN_TRACK_GAIN', m.replayGainTrackGain);
+    if (m.artists.length > 1)
+        txxx('ARTISTS', m.artists);
+    if (m.featuredArtists.length)
+        txxx('FEATURING', m.featuredArtists);
+    txxx('PRODUCER', m.producers);
+    txxx('MIXER', m.mixers);
+    txxx('PUBLISHER', m.publishers);
+    if (m.engineers.length) {
+        txxx('ENGINEER', m.engineers.map((e) => e.name));
+        txxx('INVOLVEDPEOPLE', m.engineers.map((e) => `${e.name} (${e.role})`));
     }
-    if (track.EXPLICIT_LYRICS) {
-        writer.setFrame('TXXX', {
-            description: 'EXPLICIT',
-            value: track.EXPLICIT_LYRICS,
-        });
+    if (m.performers.length) {
+        txxx('PERFORMER', m.performers.map((p) => `${p.name} (${p.role})`));
     }
-    if (cover) {
-        writer.setFrame('APIC', {
-            type: 3,
-            data: cover,
-            description: '',
-        });
+    if (m.lyricsWriters)
+        txxx('LYRICIST', m.lyricsWriters);
+    if (m.lyricsCopyright)
+        txxx('LYRICS_COPYRIGHT', m.lyricsCopyright);
+    if (m.producerLine)
+        txxx('PRODUCERLINE', m.producerLine);
+    if (m.rank !== undefined)
+        txxx('DEEZER_RANK', String(m.rank));
+    txxx('SOURCE', 'Deezer');
+    if (m.ids.deezerTrack) {
+        txxx('SOURCEID', m.ids.deezerTrack);
+        txxx('DEEZER_TRACK_ID', m.ids.deezerTrack);
+        w.setFrame('WOAS', `https://www.deezer.com/track/${m.ids.deezerTrack}`);
     }
-    writer.addTag();
-    return Buffer.isBuffer(writer.arrayBuffer) ? writer.arrayBuffer : Buffer.from(writer.arrayBuffer);
+    if (m.ids.deezerAlbum)
+        txxx('DEEZER_ALBUM_ID', m.ids.deezerAlbum);
+    if (m.ids.deezerArtist) {
+        txxx('DEEZER_ARTIST_ID', m.ids.deezerArtist);
+        w.setFrame('WOAR', `https://www.deezer.com/artist/${m.ids.deezerArtist}`);
+    }
+    if (m.ids.labelId)
+        txxx('DEEZER_LABEL_ID', m.ids.labelId);
+    if (m.ids.providerId)
+        txxx('DEEZER_PROVIDER_ID', m.ids.providerId);
+    if (m.lyrics) {
+        w.setFrame('USLT', { description: '', lyrics: m.lyrics, language: 'eng' });
+    }
+    if (m.cover) {
+        w.setFrame('APIC', { type: 3, data: m.cover, description: 'Front cover' });
+    }
+    if (m.artistImage) {
+        w.setFrame('APIC', { type: 8, data: m.artistImage, description: 'Artist' });
+    }
+    w.addTag();
+    return Buffer.isBuffer(w.arrayBuffer) ? w.arrayBuffer : Buffer.from(w.arrayBuffer);
 };
 exports.writeMetadataMp3 = writeMetadataMp3;

package/dist/metadata-writer/index.d.ts

@@ -1,9 +1,63 @@
 /// <reference types="node" />
-import type { trackType } from '../types';
+import type { TrackTagModel } from './model';
+import type { RichAlbum } from './rich-album';
+import type { lyricsType, trackType, trackTypePublicApi } from '../types';
+export { normalizeContributors } from './contributors';
+export type { NormalizedContributors } from './contributors';
+export { toLrc } from './lrc';
+export { getRichAlbum } from './rich-album';
+export type { RichAlbum } from './rich-album';
+export { buildTagModel } from './model';
+export type { TrackTagModel, Person } from './model';
+export { downloadAlbumCover, downloadArtistImage, MAX_COVER_SIZE } from './abumCover';
+export interface AddTrackTagsOptions {
+    /** embedded cover size in px, 56–1800 (default 1000) */
+    coverSize?: number;
+    /** pre-fetched album cover; skips the download when provided (`null` = none) */
+    cover?: Buffer | null;
+    /** pre-fetched artist image */
+    artistImage?: Buffer | null;
+    /** pre-fetched merged album info; skips `getRichAlbum` (fetch once per album, pass here) */
+    album?: RichAlbum | null;
+    /** pre-fetched lyrics (`song.getLyrics` shape); skips the lyrics fetch */
+    lyrics?: lyricsType | null;
+    /** pre-fetched public `/track/` payload (BPM source) */
+    publicTrack?: trackTypePublicApi | null;
+    /** embed front cover art. default true */
+    embedCover?: boolean;
+    /** embed the artist photo as a second picture. default true */
+    embedArtistImage?: boolean;
+    /** fetch + embed lyrics. default true */
+    writeLyrics?: boolean;
+    /** embed synced LRC (FLAC Vorbis comment only; MP3 has no v2.3 synced frame). default true */
+    embedSyncedLyrics?: boolean;
+    /**
+     * hydrate `SNG_CONTRIBUTORS` / `VERSION` / `GAIN` from `song.getData` when the
+     * track came from an album/playlist listing (which omits them), and pull BPM
+     * from the public API. default true.
+     */
+    richCredits?: boolean;
+    /** write `DEEZER_*_ID`, url slug, provider/label ids. default true */
+    deezerIds?: boolean;
+    /** write popularity rank. default true */
+    includeRank?: boolean;
+}
+export interface TaggedTrack {
+    /** the audio with tags written */
+    buffer: Buffer;
+    /** everything gerdur pulled together for this track — use `model.lyricsSynced` for a `.lrc` sidecar */
+    model: TrackTagModel;
+}
 /**
- * Add metdata to the mp3
- * @param {Buffer} trackBuffer decrypted track buffer
- * @param {Object} track json containing track infos
- * @param {Number} albumCoverSize album cover size in pixel
+ * Pull together everything Deezer has for a track and write it into the audio.
+ *
+ * Sniffs `fLaC` vs MP3 and dispatches to the FLAC / ID3 writer. Fetches album
+ * info, lyrics, cover and (for album/playlist tracks) full credits + BPM in
+ * parallel — every call is memoised and in-flight-coalesced, so tagging all
+ * tracks of one album hits each metadata endpoint once. Pass any of
+ * `options.{album,lyrics,cover,publicTrack}` to skip the corresponding fetch.
+ *
+ * @returns `{buffer, model}` — `model` carries the structured metadata and,
+ *   when available, `model.lyricsSynced` (an LRC document for a sidecar file).
  */
-export declare const addTrackTags: (trackBuffer: Buffer, track: trackType, albumCoverSize?: number) => Promise<Buffer>;
+export declare const addTrackTags: (trackBuffer: Buffer, trackInput: trackType, options?: AddTrackTagsOptions) => Promise<TaggedTrack>;

package/dist/metadata-writer/index.js

@@ -1,44 +1,115 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addTrackTags = void 0;
+exports.addTrackTags = exports.MAX_COVER_SIZE = exports.downloadArtistImage = exports.downloadAlbumCover = exports.buildTagModel = exports.getRichAlbum = exports.toLrc = exports.normalizeContributors = void 0;
 const abumCover_1 = require("./abumCover");
 const getTrackLyrics_1 = require("./getTrackLyrics");
 const id3_1 = require("./id3");
 const flacmetata_1 = require("./flacmetata");
+const rich_album_1 = require("./rich-album");
+const model_1 = require("./model");
 const api_1 = require("../api");
-const albumInfo = async (track) => {
+var contributors_1 = require("./contributors");
+Object.defineProperty(exports, "normalizeContributors", { enumerable: true, get: function () { return contributors_1.normalizeContributors; } });
+var lrc_1 = require("./lrc");
+Object.defineProperty(exports, "toLrc", { enumerable: true, get: function () { return lrc_1.toLrc; } });
+var rich_album_2 = require("./rich-album");
+Object.defineProperty(exports, "getRichAlbum", { enumerable: true, get: function () { return rich_album_2.getRichAlbum; } });
+var model_2 = require("./model");
+Object.defineProperty(exports, "buildTagModel", { enumerable: true, get: function () { return model_2.buildTagModel; } });
+var abumCover_2 = require("./abumCover");
+Object.defineProperty(exports, "downloadAlbumCover", { enumerable: true, get: function () { return abumCover_2.downloadAlbumCover; } });
+Object.defineProperty(exports, "downloadArtistImage", { enumerable: true, get: function () { return abumCover_2.downloadArtistImage; } });
+Object.defineProperty(exports, "MAX_COVER_SIZE", { enumerable: true, get: function () { return abumCover_2.MAX_COVER_SIZE; } });
+const DEFAULTS = {
+    coverSize: 1000,
+    embedCover: true,
+    embedArtistImage: true,
+    writeLyrics: true,
+    embedSyncedLyrics: true,
+    richCredits: true,
+    deezerIds: true,
+    includeRank: true,
+};
+const hydrate = async (track) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (track.SNG_CONTRIBUTORS !== undefined && track.VERSION !== undefined && track.GAIN !== undefined) {
+        return track;
+    }
     try {
-        return await (0, api_1.getAlbumInfoPublicApi)(track.ALB_ID);
+        const full = await (0, api_1.getTrackInfo)(track.SNG_ID);
+        return {
+            ...full,
+            ...track,
+            SNG_CONTRIBUTORS: (_a = full.SNG_CONTRIBUTORS) !== null && _a !== void 0 ? _a : track.SNG_CONTRIBUTORS,
+            VERSION: (_b = full.VERSION) !== null && _b !== void 0 ? _b : track.VERSION,
+            GAIN: (_c = track.GAIN) !== null && _c !== void 0 ? _c : full.GAIN,
+            RANK: (_d = track.RANK) !== null && _d !== void 0 ? _d : full.RANK,
+            URL_REWRITING: (_e = track.URL_REWRITING) !== null && _e !== void 0 ? _e : full.URL_REWRITING,
+            PROVIDER_ID: (_f = track.PROVIDER_ID) !== null && _f !== void 0 ? _f : full.PROVIDER_ID,
+            EXPLICIT_TRACK_CONTENT: (_g = track.EXPLICIT_TRACK_CONTENT) !== null && _g !== void 0 ? _g : full.EXPLICIT_TRACK_CONTENT,
+            ART_PICTURE: track.ART_PICTURE || full.ART_PICTURE,
+        };
     }
-    catch (err) {
-        return null;
+    catch {
+        return track;
     }
 };
 /**
- * Add metdata to the mp3
- * @param {Buffer} trackBuffer decrypted track buffer
- * @param {Object} track json containing track infos
- * @param {Number} albumCoverSize album cover size in pixel
+ * Pull together everything Deezer has for a track and write it into the audio.
+ *
+ * Sniffs `fLaC` vs MP3 and dispatches to the FLAC / ID3 writer. Fetches album
+ * info, lyrics, cover and (for album/playlist tracks) full credits + BPM in
+ * parallel — every call is memoised and in-flight-coalesced, so tagging all
+ * tracks of one album hits each metadata endpoint once. Pass any of
+ * `options.{album,lyrics,cover,publicTrack}` to skip the corresponding fetch.
+ *
+ * @returns `{buffer, model}` — `model` carries the structured metadata and,
+ *   when available, `model.lyricsSynced` (an LRC document for a sidecar file).
  */
-const addTrackTags = async (trackBuffer, track, albumCoverSize = 1000) => {
-    const [cover, lyrics, album] = await Promise.all([
-        (0, abumCover_1.downloadAlbumCover)(track, albumCoverSize),
-        (0, getTrackLyrics_1.getTrackLyrics)(track),
-        albumInfo(track),
+const addTrackTags = async (trackBuffer, trackInput, options = {}) => {
+    const opt = { ...DEFAULTS, ...options };
+    const track = opt.richCredits ? await hydrate(trackInput) : trackInput;
+    const [album, lyrics, publicTrack, cover, artistImage] = await Promise.all([
+        options.album !== undefined ? Promise.resolve(options.album) : (0, rich_album_1.getRichAlbum)(track.ALB_ID).catch(() => null),
+        options.lyrics !== undefined
+            ? Promise.resolve(options.lyrics)
+            : opt.writeLyrics
+                ? (0, getTrackLyrics_1.getTrackLyrics)(track).catch(() => null)
+                : Promise.resolve(null),
+        options.publicTrack !== undefined
+            ? Promise.resolve(options.publicTrack)
+            : opt.richCredits
+                ? (0, api_1.getTrackInfoPublicApi)(track.SNG_ID).catch(() => null)
+                : Promise.resolve(null),
+        options.cover !== undefined
+            ? Promise.resolve(options.cover)
+            : opt.embedCover
+                ? (0, abumCover_1.downloadAlbumCover)(track, opt.coverSize)
+                : Promise.resolve(null),
+        options.artistImage !== undefined
+            ? Promise.resolve(options.artistImage)
+            : opt.embedArtistImage
+                ? (0, abumCover_1.downloadArtistImage)(track).catch(() => null)
+                : Promise.resolve(null),
     ]);
-    if (lyrics) {
-        track.LYRICS = lyrics;
-    }
-    if (track.ART_NAME.toLowerCase() === 'various') {
+    if (track.ART_NAME && track.ART_NAME.toLowerCase() === 'various') {
         track.ART_NAME = 'Various Artists';
     }
-    if (album && album.record_type) {
-        album.record_type =
-            album.record_type === 'ep' ? 'EP' : album.record_type.charAt(0).toUpperCase() + album.record_type.slice(1);
-    }
+    const model = (0, model_1.buildTagModel)({
+        track,
+        album: album || undefined,
+        publicTrack,
+        lyrics,
+        cover: opt.embedCover ? cover : null,
+        artistImage: opt.embedArtistImage ? artistImage : null,
+        coverSize: opt.coverSize,
+        deezerIds: opt.deezerIds,
+        includeRank: opt.includeRank,
+    });
     const isFlac = trackBuffer.slice(0, 4).toString('ascii') === 'fLaC';
-    return isFlac
-        ? (0, flacmetata_1.writeMetadataFlac)(trackBuffer, track, album, albumCoverSize, cover)
-        : (0, id3_1.writeMetadataMp3)(trackBuffer, track, album, cover);
+    const buffer = isFlac
+        ? (0, flacmetata_1.writeMetadataFlac)(trackBuffer, model, { embedSyncedLyrics: opt.embedSyncedLyrics })
+        : (0, id3_1.writeMetadataMp3)(trackBuffer, model);
+    return { buffer, model };
 };
 exports.addTrackTags = addTrackTags;

package/dist/metadata-writer/lrc.d.ts

@@ -0,0 +1,16 @@
+import type { lyricsSync } from '../types';
+export interface LrcMeta {
+    title?: string;
+    artist?: string;
+    album?: string;
+    writers?: string;
+    length?: number;
+}
+/**
+ * Render Deezer's `LYRICS_SYNC_JSON` as a standard LRC document.
+ *
+ * Deezer already gives each line an `lrc_timestamp` like `[00:52.64]`; we trust
+ * `milliseconds` and re-stamp so the output is well-formed even when a line has
+ * an empty timestamp (section breaks come through as `{line: ""}`).
+ */
+export declare const toLrc: (sync: lyricsSync[] | undefined, meta?: LrcMeta) => string | null;

package/dist/metadata-writer/lrc.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLrc = void 0;
+const stamp = (ms) => {
+    const cs = Math.round(ms / 10);
+    const m = Math.floor(cs / 6000);
+    const s = Math.floor((cs % 6000) / 100);
+    const c = cs % 100;
+    return `${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}.${String(c).padStart(2, '0')}`;
+};
+/**
+ * Render Deezer's `LYRICS_SYNC_JSON` as a standard LRC document.
+ *
+ * Deezer already gives each line an `lrc_timestamp` like `[00:52.64]`; we trust
+ * `milliseconds` and re-stamp so the output is well-formed even when a line has
+ * an empty timestamp (section breaks come through as `{line: ""}`).
+ */
+const toLrc = (sync, meta = {}) => {
+    if (!sync || !sync.length) {
+        return null;
+    }
+    const head = [];
+    if (meta.artist)
+        head.push(`[ar:${meta.artist}]`);
+    if (meta.title)
+        head.push(`[ti:${meta.title}]`);
+    if (meta.album)
+        head.push(`[al:${meta.album}]`);
+    if (meta.writers)
+        head.push(`[au:${meta.writers}]`);
+    if (meta.length)
+        head.push(`[length:${stamp(meta.length * 1000)}]`);
+    head.push('[re:gerdur]');
+    const lines = sync
+        .filter((l) => l.line && l.line.trim().length)
+        .map((l) => {
+        const ms = Number(l.milliseconds);
+        const ts = l.milliseconds && Number.isFinite(ms) ? `[${stamp(ms)}]` : l.lrc_timestamp || '';
+        return `${ts}${l.line}`;
+    });
+    return [...head, ...lines].join('\n') + '\n';
+};
+exports.toLrc = toLrc;

package/dist/metadata-writer/model.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import type { RichAlbum } from './rich-album';
+import type { lyricsType, trackType, trackTypePublicApi } from '../types';
+export interface TagModelInput {
+    track: trackType;
+    album?: RichAlbum;
+    /** public `/track/` payload — the only source of BPM */
+    publicTrack?: trackTypePublicApi | null;
+    lyrics?: lyricsType | null;
+    cover?: Buffer | null;
+    artistImage?: Buffer | null;
+    coverSize: number;
+    /** write `DEEZER_*_ID`, `URL_REWRITING` slug, provider/label ids */
+    deezerIds: boolean;
+    /** write popularity rank */
+    includeRank: boolean;
+}
+export interface Person {
+    role: string;
+    name: string;
+}
+export interface TrackTagModel {
+    title: string;
+    subtitle?: string;
+    album: string;
+    artists: string[];
+    mainArtists: string[];
+    featuredArtists: string[];
+    albumArtist: string;
+    composers: string[];
+    lyricists: string[];
+    producers: string[];
+    engineers: Person[];
+    mixers: string[];
+    performers: Person[];
+    publishers: string[];
+    trackNumber: number;
+    trackTotal?: number;
+    discNumber: number;
+    discTotal?: number;
+    isrc?: string;
+    barcode?: string;
+    durationMs: number;
+    bpm?: number;
+    genres: string[];
+    label?: string;
+    releaseType?: string;
+    isCompilation: boolean;
+    date?: string;
+    year?: string;
+    originalDate?: string;
+    originalYear?: string;
+    copyright?: string;
+    producerLine?: string;
+    replayGainTrackGain?: string;
+    explicit: 'explicit' | 'clean' | 'unknown';
+    itunesAdvisory: number;
+    lyrics?: string;
+    lyricsSynced?: string;
+    lyricsWriters?: string;
+    lyricsCopyright?: string;
+    ids: {
+        deezerTrack?: string;
+        deezerAlbum?: string;
+        deezerArtist?: string;
+        slug?: string;
+        labelId?: string;
+        providerId?: string;
+    };
+    rank?: number;
+    cover?: Buffer | null;
+    coverSize: number;
+    artistImage?: Buffer | null;
+}
+export declare const buildTagModel: (input: TagModelInput) => TrackTagModel;