gerdur 0.0.0-probe → 1.0.1

package/dist/src/lib/download-track.d.ts

@@ -0,0 +1,24 @@
+import type { trackType } from 'gerdur-core/types';
+interface downloadTrackProps {
+    track: trackType;
+    quality: string | number;
+    info: {
+        [key: string]: any;
+    };
+    coverSizes: {
+        '128': number;
+        '320': number;
+        flac: number;
+    };
+    path: string;
+    totalTracks: number;
+    trackNumber?: boolean;
+    fallbackTrack?: boolean;
+    fallbackQuality?: boolean;
+    isFallback?: boolean;
+    isQualityFallback?: boolean;
+    overwrite?: boolean;
+    message?: string;
+}
+declare const downloadTrack: ({ track, quality, info, coverSizes, path, totalTracks, trackNumber, fallbackTrack, fallbackQuality, isFallback, isQualityFallback, overwrite, message, }: downloadTrackProps) => Promise<string | undefined>;
+export default downloadTrack;

package/dist/src/lib/download-track.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const got_1 = __importDefault(require("got"));
+const stream_1 = __importDefault(require("stream"));
+const fs_1 = require("fs");
+const util_1 = require("util");
+const path_1 = require("path");
+const gerdur_core_1 = require("gerdur-core");
+const log_update_1 = __importDefault(require("log-update"));
+const chalk_1 = __importDefault(require("chalk"));
+const signale_1 = __importDefault(require("../lib/signale"));
+const util_2 = require("./util");
+const decrypt_1 = require("./decrypt");
+const pipeline = (0, util_1.promisify)(stream_1.default.pipeline);
+const simulate = process.env.SIMULATE;
+const downloadTrack = async ({ track, quality, info, coverSizes, path, totalTracks, trackNumber = true, fallbackTrack = true, fallbackQuality = true, isFallback = false, isQualityFallback = false, overwrite = false, message = '', }) => {
+    (0, log_update_1.default)(signale_1.default.pending(track.SNG_TITLE + ' by ' + track.ART_NAME + ' from ' + track.ALB_TITLE));
+    try {
+        let ext = '.mp3', fileSize = 0, downloaded = 0, coverSize = 500;
+        switch (quality) {
+            case 1:
+            case '1':
+            case '128':
+            case 'MP3_128':
+            case '128kbps':
+                quality = 1;
+                fileSize = Number(track.FILESIZE_MP3_128);
+                coverSize = coverSizes['128'];
+                break;
+            case 9:
+            case '9':
+            case 'flac':
+            case 'Flac':
+            case 'FLAC':
+                quality = 9;
+                ext = '.flac';
+                fileSize = Number(track.FILESIZE_FLAC);
+                coverSize = coverSizes['flac'];
+                break;
+            default:
+                quality = 3;
+                fileSize = Number(track.FILESIZE_MP3_320);
+                coverSize = coverSizes['320'];
+        }
+        const savePath = (0, util_2.saveLayout)({ track, album: info, path, trackNumber, minimumIntegerDigits: totalTracks >= 100 ? 3 : 2 }) + ext;
+        if ((0, fs_1.existsSync)(savePath) && !overwrite) {
+            (0, log_update_1.default)(signale_1.default.info(`Skipped "${track.SNG_TITLE}", track already exists.`));
+            log_update_1.default.done();
+            (0, log_update_1.default)(signale_1.default.note(savePath));
+            log_update_1.default.done();
+            return savePath;
+        }
+        let trackData;
+        try {
+            trackData = await (0, gerdur_core_1.getTrackDownloadUrl)(track, quality);
+        }
+        catch (err) {
+            if (!(err instanceof gerdur_core_1.GeoBlocked) || !track.FALLBACK) {
+                throw err;
+            }
+        }
+        if (!trackData) {
+            if (fallbackTrack && track.FALLBACK && !isFallback && track.ART_ID === track.FALLBACK.ART_ID) {
+                const { FALLBACK, ...CURRENT_TRACK } = track;
+                return await downloadTrack({
+                    track: { ...CURRENT_TRACK, ...FALLBACK },
+                    quality,
+                    info,
+                    coverSizes,
+                    path,
+                    totalTracks,
+                    trackNumber,
+                    fallbackTrack: false,
+                    isFallback: true,
+                    overwrite,
+                    message,
+                });
+            }
+            else if (fallbackQuality && quality !== 1) {
+                return await downloadTrack({
+                    track,
+                    quality: quality === 9 ? 3 : 1,
+                    info,
+                    coverSizes,
+                    path,
+                    totalTracks,
+                    trackNumber,
+                    fallbackTrack,
+                    isFallback,
+                    isQualityFallback: true,
+                    overwrite,
+                    message,
+                });
+            }
+            (0, log_update_1.default)(signale_1.default.warn(`Skipped "${track.SNG_TITLE}", track not available.`));
+            log_update_1.default.done();
+            return;
+        }
+        const headers = {};
+        const tmpfile = `gerdur_${quality}_${track.SNG_ID}_${simulate ? 'simulate' : track.MD5_ORIGIN}`;
+        if (simulate) {
+            coverSize = 56;
+            headers.range = 'bytes=0-1023';
+        }
+        else if ((0, fs_1.existsSync)(tmpfile)) {
+            const tmpfilestat = (0, fs_1.statSync)(tmpfile);
+            downloaded = tmpfilestat.size;
+            headers.range = 'bytes=' + tmpfilestat.size + '-';
+        }
+        fileSize = trackData.fileSize;
+        const bar = (0, util_2.progressBar)(fileSize, 40);
+        const humanSizeTotal = (fileSize / 1024 / 1024).toFixed(2);
+        let transferredLast = downloaded;
+        await pipeline(got_1.default.stream(trackData.trackUrl, { responseType: 'buffer', headers }).on('downloadProgress', ({ transferred }) => {
+            // Report download progress
+            transferred += downloaded;
+            if (transferred - transferredLast > 50000) {
+                transferredLast = transferred;
+                (0, log_update_1.default)(signale_1.default.info(`Downloading ${track.SNG_TITLE} ${message}\n  ${bar(transferred)} | ${humanSizeTotal}MiB`));
+            }
+        }), (0, fs_1.createWriteStream)(tmpfile, { flags: 'a', autoClose: true }));
+        let outFile;
+        if (trackData.isEncrypted) {
+            (0, log_update_1.default)(signale_1.default.pending('Decrypting ' + track.SNG_TITLE + ' by ' + track.ART_NAME));
+            outFile = await (0, decrypt_1.decryptDownloadFile)(tmpfile, track.SNG_ID);
+        }
+        else {
+            outFile = (0, fs_1.readFileSync)(tmpfile);
+        }
+        (0, log_update_1.default)(signale_1.default.pending('Tagging ' + track.SNG_TITLE + ' by ' + track.ART_NAME));
+        const trackWithMetadata = await (0, gerdur_core_1.addTrackTags)(outFile, track, coverSize);
+        // Delete temporary file now
+        (0, fs_1.unlinkSync)(tmpfile);
+        (0, log_update_1.default)(signale_1.default.pending('Saving ' + track.SNG_TITLE + ' by ' + track.ART_NAME));
+        if (!simulate) {
+            // Create directory if not exists
+            const dir = (0, path_1.dirname)(savePath);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            // Save file to disk
+            (0, fs_1.writeFileSync)(savePath, trackWithMetadata);
+        }
+        // Print sucess info
+        (0, log_update_1.default)(signale_1.default.success(`${isFallback ? chalk_1.default.yellow('[Fallback] ') : ''}${track.SNG_TITLE} by ${track.ART_NAME}`));
+        log_update_1.default.done();
+        if (isQualityFallback) {
+            (0, log_update_1.default)(signale_1.default.note(`Used ${quality === 3 ? '320kbps' : '128kbps'} as other formats were unavailable`));
+            log_update_1.default.done();
+        }
+        return savePath;
+    }
+    catch (err) {
+        (0, log_update_1.default)(signale_1.default.error(track.SNG_TITLE));
+        log_update_1.default.done();
+        (0, log_update_1.default)(signale_1.default.note(err.message));
+        log_update_1.default.done();
+    }
+};
+exports.default = downloadTrack;

package/dist/src/lib/email-login.d.ts

@@ -0,0 +1,16 @@
+/** Discriminated result so the caller can branch on the failure reason. */
+export type LoginResult = {
+    ok: true;
+    arl: string;
+} | {
+    ok: false;
+    reason: 'wrong-credentials' | 'no-arl' | 'network' | 'unknown';
+    message: string;
+};
+/**
+ * Attempt to obtain an arl for the given credentials.
+ *
+ * The password is MD5-hashed and folded into the app hash before transmission;
+ * it is never written anywhere by this function.
+ */
+export declare const loginWithEmail: (email: string, password: string) => Promise<LoginResult>;

package/dist/src/lib/email-login.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginWithEmail = void 0;
+const crypto_1 = require("crypto");
+const got_1 = __importDefault(require("got"));
+/**
+ * Email/password -> arl login for Deezer.
+ *
+ * Uses Deezer's mobile OAuth endpoint (connect.deezer.com/oauth/user_auth.php)
+ * rather than the web login form, which is bot-protected. The approach and the
+ * public app credentials/hash scheme mirror the well-known deemix flow.
+ *
+ * This is still best-effort: Deezer may reject the login (bad credentials,
+ * account protections, or changes on their side), in which case the caller
+ * should fall back to pasting an arl. Passwords handled here are never persisted
+ * or logged; only the resulting arl is returned.
+ */
+// Public Deezer app credentials used by the mobile OAuth flow (same values used
+// by deemix and similar tools). Not secret in any meaningful sense.
+const CLIENT_ID = '447462';
+const CLIENT_SECRET = 'a83bf7f38ad2f137e444727cfc3775cf';
+const UA = 'Mozilla/5.0 (X11; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0';
+const md5 = (data) => (0, crypto_1.createHash)('md5').update(Buffer.from(data, 'utf8')).digest('hex');
+/**
+ * Merge `set-cookie` response headers into a cookie map (last value wins),
+ * emulating a cookie jar shared across the login requests.
+ */
+const collectCookies = (jar, setCookie) => {
+    if (!setCookie) {
+        return;
+    }
+    for (const raw of setCookie) {
+        const [pair] = raw.split(';');
+        const eq = pair.indexOf('=');
+        if (eq > 0) {
+            const name = pair.slice(0, eq).trim();
+            const value = pair.slice(eq + 1).trim();
+            if (name) {
+                jar.set(name, value);
+            }
+        }
+    }
+};
+const cookieHeader = (jar) => [...jar.entries()].map(([k, v]) => `${k}=${v}`).join('; ');
+/**
+ * Attempt to obtain an arl for the given credentials.
+ *
+ * The password is MD5-hashed and folded into the app hash before transmission;
+ * it is never written anywhere by this function.
+ */
+const loginWithEmail = async (email, password) => {
+    const jar = new Map();
+    try {
+        // 1. Bootstrap a session so Deezer sets an initial sid cookie.
+        const boot = await (0, got_1.default)('https://www.deezer.com', {
+            method: 'POST',
+            headers: { 'User-Agent': UA },
+            timeout: { request: 15000 },
+            throwHttpErrors: false,
+        });
+        collectCookies(jar, boot.headers['set-cookie']);
+        // 2. Authenticate via the mobile OAuth endpoint. The password is hashed,
+        //    then combined with the public app id/secret into the request hash.
+        const passwordHash = md5(password);
+        const hash = md5([CLIENT_ID, email, passwordHash, CLIENT_SECRET].join(''));
+        let accessToken = null;
+        const auth = await (0, got_1.default)('https://connect.deezer.com/oauth/user_auth.php', {
+            searchParams: { app_id: CLIENT_ID, login: email, password: passwordHash, hash },
+            headers: { 'User-Agent': UA, cookie: cookieHeader(jar) },
+            responseType: 'json',
+            timeout: { request: 15000 },
+            throwHttpErrors: false,
+        });
+        collectCookies(jar, auth.headers['set-cookie']);
+        const authBody = auth.body ?? {};
+        if (authBody.access_token && authBody.access_token !== 'undefined') {
+            accessToken = authBody.access_token;
+        }
+        if (!accessToken && !jar.has('arl') && (authBody.error || auth.statusCode >= 400)) {
+            return { ok: false, reason: 'wrong-credentials', message: 'Login failed — check your email and password.' };
+        }
+        // 3. Read the arl for the now-authenticated session.
+        const arlResp = await (0, got_1.default)('https://www.deezer.com/ajax/gw-light.php', {
+            searchParams: { method: 'user.getArl', input: 3, api_version: '1.0', api_token: 'null' },
+            headers: { 'User-Agent': UA, cookie: cookieHeader(jar) },
+            responseType: 'json',
+            timeout: { request: 15000 },
+            throwHttpErrors: false,
+        });
+        collectCookies(jar, arlResp.headers['set-cookie']);
+        const arl = arlResp.body?.results;
+        if (typeof arl === 'string' && arl.length === 192) {
+            return { ok: true, arl };
+        }
+        if (jar.has('arl') && jar.get('arl').length === 192) {
+            return { ok: true, arl: jar.get('arl') };
+        }
+        return {
+            ok: false,
+            reason: 'no-arl',
+            message: 'Logged in but could not retrieve an arl. Please paste your arl instead.',
+        };
+    }
+    catch (err) {
+        return { ok: false, reason: 'network', message: err?.message || 'Network error during login.' };
+    }
+};
+exports.loginWithEmail = loginWithEmail;

package/dist/src/lib/session.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { parseInfo, searchMusic } from 'gerdur-core';
+import type { Quality, DownloadTrackOptions, DownloadResult } from './api-download';
+import type { trackType, userType } from 'gerdur-core/types';
+/** Search result categories accepted by {@link Session.search}. */
+export type SearchType = 'ALBUM' | 'ARTIST' | 'TRACK' | 'PLAYLIST' | 'RADIO' | 'SHOW' | 'USER' | 'LIVESTREAM' | 'CHANNEL';
+export interface SessionOptions {
+    /** Deezer arl cookie. Provide this OR email+password. */
+    arl?: string;
+    /** Deezer account email (used with `password` to fetch an arl). */
+    email?: string;
+    /** Deezer account password. */
+    password?: string;
+    /** Default download concurrency for `downloadTracks`. Default 4. */
+    concurrency?: number;
+}
+export interface DownloadTracksOptions extends DownloadTrackOptions {
+    /** Concurrent downloads. Defaults to the session concurrency. */
+    concurrency?: number;
+    /**
+     * Called after each track settles, with the running progress. `result` is the
+     * download result (or `null` if the track was unavailable / errored).
+     */
+    onProgress?: (progress: {
+        index: number;
+        total: number;
+        track: trackType;
+        result: DownloadResult | null;
+    }) => void;
+}
+/**
+ * An authenticated Deezer session exposing high-level query and download
+ * helpers. Create one with {@link createSession}. All methods are silent (no
+ * console output); use `onProgress` callbacks for progress.
+ */
+export declare class Session {
+    /** The arl in use for this session. */
+    readonly arl: string;
+    private concurrency;
+    private constructor();
+    /**
+     * Log in and return a ready-to-use session. Accepts either an `arl` or
+     * `email`+`password` (which are exchanged for an arl via Deezer's OAuth flow).
+     */
+    static create(options: SessionOptions): Promise<Session>;
+    /** Fetch the logged-in user profile. */
+    getUser(): Promise<userType>;
+    /**
+     * Resolve any supported URL (Deezer/Spotify/Tidal track, album, playlist, or
+     * artist) into its info + track list.
+     */
+    parseUrl(url: string): ReturnType<typeof parseInfo>;
+    /** Search Deezer. Defaults to track results. */
+    search(query: string, types?: SearchType[], limit?: number): ReturnType<typeof searchMusic>;
+    /** Return a fully tagged audio Buffer for a track (nothing written to disk). */
+    getTrackBuffer(track: trackType, quality?: Quality, options?: {}): Promise<Buffer | null>;
+    /** Download a single track to disk. */
+    downloadTrack(track: trackType, quality?: Quality, options?: DownloadTrackOptions): Promise<DownloadResult | null>;
+    /**
+     * Download many tracks with bounded concurrency. Resolves to one result per
+     * input track (in the original order); entries are `null` for tracks that
+     * were unavailable or errored. Progress is reported via `onProgress`.
+     */
+    downloadTracks(tracks: trackType[], quality?: Quality, options?: DownloadTracksOptions): Promise<(DownloadResult | null)[]>;
+    /**
+     * Convenience: resolve a URL and download all of its tracks in one call.
+     * Uses the linked album/playlist info for filename templating.
+     */
+    downloadUrl(url: string, quality?: Quality, options?: DownloadTracksOptions): Promise<(DownloadResult | null)[]>;
+}
+/**
+ * Create and log in an authenticated {@link Session}.
+ *
+ * @example
+ * ```ts
+ * const session = await createSession({arl: '...'});          // or {email, password}
+ * const {tracks, linkinfo} = await session.parseUrl(url);
+ * await session.downloadTracks(tracks, 'flac', {
+ *   output: 'Music/{ALB_TITLE}/{SNG_TITLE}',
+ *   onProgress: ({index, total}) => console.log(`${index + 1}/${total}`),
+ * });
+ * ```
+ */
+export declare const createSession: (options: SessionOptions) => Promise<Session>;

package/dist/src/lib/session.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSession = exports.Session = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+const gerdur_core_1 = require("gerdur-core");
+const email_login_1 = require("./email-login");
+const api_download_1 = require("./api-download");
+/**
+ * An authenticated Deezer session exposing high-level query and download
+ * helpers. Create one with {@link createSession}. All methods are silent (no
+ * console output); use `onProgress` callbacks for progress.
+ */
+class Session {
+    /** The arl in use for this session. */
+    arl;
+    concurrency;
+    constructor(arl, concurrency) {
+        this.arl = arl;
+        this.concurrency = concurrency;
+    }
+    /**
+     * Log in and return a ready-to-use session. Accepts either an `arl` or
+     * `email`+`password` (which are exchanged for an arl via Deezer's OAuth flow).
+     */
+    static async create(options) {
+        let arl = options.arl?.trim();
+        if (!arl && options.email && options.password) {
+            const result = await (0, email_login_1.loginWithEmail)(options.email, options.password);
+            if (!result.ok) {
+                throw new Error(`Login failed (${result.reason}): ${result.message}`);
+            }
+            arl = result.arl;
+        }
+        if (!arl) {
+            throw new Error('createSession requires either an arl or email + password.');
+        }
+        await (0, gerdur_core_1.initDeezerApi)(arl);
+        // Verify the session is actually usable before handing it back.
+        await (0, gerdur_core_1.getUser)();
+        return new Session(arl, options.concurrency ?? 4);
+    }
+    /** Fetch the logged-in user profile. */
+    getUser() {
+        return (0, gerdur_core_1.getUser)();
+    }
+    /**
+     * Resolve any supported URL (Deezer/Spotify/Tidal track, album, playlist, or
+     * artist) into its info + track list.
+     */
+    parseUrl(url) {
+        return (0, gerdur_core_1.parseInfo)(url);
+    }
+    /** Search Deezer. Defaults to track results. */
+    search(query, types = ['TRACK'], limit) {
+        return (0, gerdur_core_1.searchMusic)(query, types, limit);
+    }
+    /** Return a fully tagged audio Buffer for a track (nothing written to disk). */
+    getTrackBuffer(track, quality = '320', options = {}) {
+        return (0, api_download_1.getTrackBuffer)(track, quality, options);
+    }
+    /** Download a single track to disk. */
+    downloadTrack(track, quality = '320', options = {}) {
+        return (0, api_download_1.downloadTrackToFile)(track, quality, options);
+    }
+    /**
+     * Download many tracks with bounded concurrency. Resolves to one result per
+     * input track (in the original order); entries are `null` for tracks that
+     * were unavailable or errored. Progress is reported via `onProgress`.
+     */
+    async downloadTracks(tracks, quality = '320', options = {}) {
+        const { concurrency = this.concurrency, onProgress, ...trackOptions } = options;
+        const queue = new p_queue_1.default({ concurrency });
+        const total = tracks.length;
+        const results = new Array(total).fill(null);
+        await queue.addAll(tracks.map((track, index) => async () => {
+            let result = null;
+            try {
+                result = await (0, api_download_1.downloadTrackToFile)(track, quality, trackOptions);
+            }
+            catch {
+                result = null;
+            }
+            results[index] = result;
+            if (onProgress) {
+                onProgress({ index, total, track, result });
+            }
+        }));
+        return results;
+    }
+    /**
+     * Convenience: resolve a URL and download all of its tracks in one call.
+     * Uses the linked album/playlist info for filename templating.
+     */
+    async downloadUrl(url, quality = '320', options = {}) {
+        const data = await (0, gerdur_core_1.parseInfo)(url);
+        const albumInfo = data.linkinfo ?? {};
+        return this.downloadTracks(data.tracks, quality, { albumInfo, ...options });
+    }
+}
+exports.Session = Session;
+/**
+ * Create and log in an authenticated {@link Session}.
+ *
+ * @example
+ * ```ts
+ * const session = await createSession({arl: '...'});          // or {email, password}
+ * const {tracks, linkinfo} = await session.parseUrl(url);
+ * await session.downloadTracks(tracks, 'flac', {
+ *   output: 'Music/{ALB_TITLE}/{SNG_TITLE}',
+ *   onProgress: ({index, total}) => console.log(`${index + 1}/${total}`),
+ * });
+ * ```
+ */
+const createSession = (options) => Session.create(options);
+exports.createSession = createSession;

package/dist/src/lib/signale.d.ts

@@ -0,0 +1,15 @@
+export declare const info: (message: string) => string;
+export declare const warn: (message: string) => string;
+export declare const pending: (message: string) => string;
+export declare const success: (message: string) => string;
+export declare const error: (message: string) => string;
+export declare const note: (message: string) => string;
+declare const _default: {
+    info: (message: string) => string;
+    warn: (message: string) => string;
+    pending: (message: string) => string;
+    success: (message: string) => string;
+    error: (message: string) => string;
+    note: (message: string) => string;
+};
+export default _default;

package/dist/src/lib/signale.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.note = exports.error = exports.success = exports.pending = exports.warn = exports.info = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const info = (message) => chalk_1.default.blueBright('ℹ info ') + message;
+exports.info = info;
+const warn = (message) => chalk_1.default.yellowBright('⚠ warn ') + message;
+exports.warn = warn;
+const pending = (message) => chalk_1.default.blueBright('● pending ') + message;
+exports.pending = pending;
+const success = (message) => chalk_1.default.greenBright('✔ success ') + message;
+exports.success = success;
+const error = (message) => chalk_1.default.redBright('✖ error ') + message;
+exports.error = error;
+const note = (message) => chalk_1.default.gray('  → ' + message);
+exports.note = note;
+exports.default = { info: exports.info, warn: exports.warn, pending: exports.pending, success: exports.success, error: exports.error, note: exports.note };

package/dist/src/lib/update-check.d.ts

@@ -0,0 +1,2 @@
+declare const updateCheck: (pkg: any) => Promise<import("update-check").Result | null | undefined>;
+export default updateCheck;

package/dist/src/lib/update-check.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const update_check_1 = __importDefault(require("update-check"));
+const gradient_string_1 = __importDefault(require("gradient-string"));
+const updateCheck = async (pkg) => {
+    try {
+        const distTag = pkg.version.includes('beta') ? 'beta' : 'latest';
+        const update = await (0, update_check_1.default)(pkg, { distTag });
+        if (update) {
+            process.on('exit', () => {
+                console.log((0, gradient_string_1.default)('#f50', 'orange', 'red')(' ──────────────────────────────────────────────') +
+                    '\n' +
+                    (0, gradient_string_1.default)('#f50', 'orange', 'red')(`     Update available ${pkg.version} \u2192  ${update.latest}`) +
+                    '\n' +
+                    chalk_1.default.redBright('     Run ') +
+                    chalk_1.default.cyanBright(`${process.pkg ? 'gerdur -U' : 'npm i -g gerdur@' + distTag}`) +
+                    chalk_1.default.redBright(' to update') +
+                    '\n' +
+                    (0, gradient_string_1.default)('#f50', 'orange', 'red')(' ──────────────────────────────────────────────'));
+            });
+        }
+        return update;
+    }
+    catch (err) { }
+};
+exports.default = updateCheck;

package/dist/src/lib/util.d.ts

@@ -0,0 +1,17 @@
+type saveLayoutProps = {
+    track: {
+        [key: string]: any;
+    };
+    album: {
+        [key: string]: any;
+    };
+    path: string;
+    minimumIntegerDigits: number;
+    trackNumber: boolean;
+};
+export declare const sanitizeFilename: (input: string, replacement?: string) => string;
+export declare const formatSecondsReadable: (time: number) => string;
+export declare const saveLayout: ({ track, album, path: filePath, minimumIntegerDigits, trackNumber }: saveLayoutProps) => string;
+export declare const progressBar: (total: number, width: number) => (value: number) => string;
+export declare const commonPath: (paths: string[]) => string;
+export {};