@karaplay/file-coder 1.1.0

package/dist/emk/server-decode.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * @fileoverview Main decoding logic for .emk (Extreme Karaoke) files.
+ * This is the SERVER-SIDE implementation using Node.js's 'zlib'.
+ * It is used by the GET /api/emk/import endpoint for playback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xorDecrypt = xorDecrypt;
+exports.looksLikeText = looksLikeText;
+exports.decodeEmk = decodeEmk;
+exports.parseSongInfo = parseSongInfo;
+const zlib_1 = require("zlib");
+const XOR_KEY = Buffer.from([0xAF, 0xF2, 0x4C, 0x9C, 0xE9, 0xEA, 0x99, 0x43]);
+const MAGIC_SIGNATURE = '.SFDS';
+const ZLIB_SECOND_BYTES = new Set([0x01, 0x5E, 0x9C, 0xDA, 0x7D, 0x20, 0xBB]);
+function xorDecrypt(data) {
+    const decrypted = Buffer.alloc(data.length);
+    for (let i = 0; i < data.length; i++) {
+        decrypted[i] = data[i] ^ XOR_KEY[i % XOR_KEY.length];
+    }
+    return decrypted;
+}
+function looksLikeText(buf) {
+    const sample = buf.subarray(0, Math.min(64, buf.length));
+    for (let i = 0; i < sample.length; i++) {
+        const c = sample[i];
+        if (c === 0x0a || c === 0x0d || c === 0x09 || (c >= 0x20 && c <= 0x7e) || c >= 0x80) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function decodeEmk(fileBuffer) {
+    const decryptedBuffer = xorDecrypt(fileBuffer);
+    const magic = decryptedBuffer.subarray(0, MAGIC_SIGNATURE.length).toString('utf-8');
+    if (magic !== MAGIC_SIGNATURE) {
+        throw new Error(`Invalid EMK file signature. Expected '${MAGIC_SIGNATURE}' but got '${magic}'.`);
+    }
+    const result = {};
+    const inflatedParts = [];
+    for (let i = 0; i < decryptedBuffer.length - 2; i++) {
+        const b0 = decryptedBuffer[i];
+        const b1 = decryptedBuffer[i + 1];
+        if (b0 !== 0x78 || !ZLIB_SECOND_BYTES.has(b1))
+            continue;
+        try {
+            const inflated = (0, zlib_1.inflateSync)(decryptedBuffer.subarray(i));
+            inflatedParts.push(inflated);
+        }
+        catch {
+            continue;
+        }
+    }
+    if (inflatedParts.length < 3) {
+        throw new Error(`Invalid EMK structure: expected at least 3 zlib blocks, found ${inflatedParts.length}.`);
+    }
+    for (const inflated of inflatedParts) {
+        const asciiPrefix = inflated.subarray(0, 16).toString('ascii');
+        if (asciiPrefix.startsWith('SIGNATURE=')) {
+            result.header = inflated;
+        }
+        else if (asciiPrefix.startsWith('CODE=')) {
+            result.songInfo = inflated;
+        }
+        else if (inflated.subarray(0, 4).toString('ascii') === 'MThd') {
+            result.midi = inflated;
+        }
+        else if (looksLikeText(inflated)) {
+            if (!result.lyric) {
+                result.lyric = inflated;
+            }
+            else {
+                result.cursor = inflated;
+            }
+        }
+        else {
+            if (!result.cursor) {
+                result.cursor = inflated;
+            }
+        }
+    }
+    if (!result.midi)
+        throw new Error('MIDI data block not found in EMK file.');
+    if (!result.lyric)
+        throw new Error('Lyric data block not found in EMK file.');
+    if (!result.cursor)
+        throw new Error('Cursor data block not found in EMK file.');
+    if (!result.songInfo) {
+        result.songInfo = Buffer.from('CODE=\nTITLE=Unknown Title\nARTIST=Unknown Artist');
+    }
+    return result;
+}
+/**
+ * Parses the "song info" block from a Buffer.
+ * @param songInfoBuffer The buffer containing the song info data.
+ * @returns A record containing TITLE, ARTIST, and CODE.
+ */
+function parseSongInfo(songInfoBuffer) {
+    if (!songInfoBuffer)
+        return {};
+    try {
+        const text = new TextDecoder('windows-874', { fatal: false }).decode(songInfoBuffer);
+        const lines = text.split(/\r?\n/);
+        const info = {};
+        for (const line of lines) {
+            const parts = line.split('=');
+            if (parts.length >= 2) {
+                const key = parts[0].trim().toUpperCase();
+                const value = parts.slice(1).join('=').trim();
+                // Only store relevant keys to keep it focused
+                if (key === 'TITLE' || key === 'ARTIST' || key === 'CODE' || key === 'title' || key === 'artist' || key === 'code') {
+                    info[key.toUpperCase()] = value;
+                }
+            }
+        }
+        return info;
+    }
+    catch (e) {
+        console.error("Failed to parse song info", e);
+        return {};
+    }
+}

package/dist/emk-to-kar.browser.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Browser-compatible EMK to KAR workflow
+ * Complete pipeline for client-side processing
+ */
+export interface BrowserEmkToKarOptions {
+    emkBuffer: Buffer;
+    outputFileName?: string;
+    autoDownload?: boolean;
+}
+export interface BrowserEmkToKarResult {
+    success: boolean;
+    karBuffer: Buffer;
+    fileName: string;
+    intermediateBuffers?: {
+        midi: Buffer;
+        lyric: Buffer;
+        cursor: Buffer;
+    };
+    metadata: {
+        title: string;
+        artist: string;
+        code?: string;
+    };
+    warnings: string[];
+}
+/**
+ * Browser-compatible EMK to KAR conversion
+ * Complete pipeline: EMK buffer → decode → convert → KAR buffer
+ */
+export declare function convertEmkToKarBrowser(options: BrowserEmkToKarOptions): BrowserEmkToKarResult;
+/**
+ * Process EMK File object directly (for file input in browser)
+ */
+export declare function convertEmkFileToKar(emkFile: File, options?: {
+    autoDownload?: boolean;
+}): Promise<BrowserEmkToKarResult>;
+/**
+ * Process multiple EMK files in the browser
+ */
+export declare function convertEmkFilesBatch(emkFiles: File[], options?: {
+    autoDownload?: boolean;
+}): Promise<BrowserEmkToKarResult[]>;
+/**
+ * Validate Thai text readability from buffer (browser version)
+ */
+export declare function validateThaiLyricReadabilityBrowser(lyricBuffer: Buffer): {
+    readable: boolean;
+    encoding: string;
+    preview: string[];
+    charCount: number;
+};

package/dist/emk-to-kar.browser.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Browser-compatible EMK to KAR workflow
+ * Complete pipeline for client-side processing
+ */
+'use client';
+/**
+ * Browser-compatible EMK to KAR workflow
+ * Complete pipeline for client-side processing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEmkToKarBrowser = convertEmkToKarBrowser;
+exports.convertEmkFileToKar = convertEmkFileToKar;
+exports.convertEmkFilesBatch = convertEmkFilesBatch;
+exports.validateThaiLyricReadabilityBrowser = validateThaiLyricReadabilityBrowser;
+const client_decoder_1 = require("./emk/client-decoder");
+const ncntokar_browser_1 = require("./ncntokar.browser");
+/**
+ * Browser-compatible EMK to KAR conversion
+ * Complete pipeline: EMK buffer → decode → convert → KAR buffer
+ */
+function convertEmkToKarBrowser(options) {
+    const warnings = [];
+    try {
+        // Step 1: Decode EMK buffer
+        console.log('[Browser] [1/3] Decoding EMK buffer...');
+        const decoded = (0, client_decoder_1.decodeEmk)(options.emkBuffer);
+        // Verify all parts are present
+        if (!decoded.midi)
+            throw new Error('MIDI data not found in EMK file');
+        if (!decoded.lyric)
+            throw new Error('Lyric data not found in EMK file');
+        if (!decoded.cursor)
+            throw new Error('Cursor data not found in EMK file');
+        console.log('[Browser] [1/3] ✓ Decoded: MIDI, Lyric, Cursor');
+        // Extract metadata from EMK
+        const songInfo = (0, client_decoder_1.parseSongInfo)(decoded.songInfo);
+        const lyricMetadata = (0, ncntokar_browser_1.parseLyricBuffer)(decoded.lyric);
+        const metadata = {
+            title: lyricMetadata.title || songInfo.TITLE || 'Unknown Title',
+            artist: lyricMetadata.artist || songInfo.ARTIST || 'Unknown Artist',
+            code: songInfo.CODE
+        };
+        console.log(`[Browser] [2/3] Converting to KAR: ${metadata.title} - ${metadata.artist}`);
+        // Step 2: Convert NCN buffers to KAR
+        const conversionResult = (0, ncntokar_browser_1.convertNcnToKarBrowser)({
+            midiBuffer: decoded.midi,
+            lyricBuffer: decoded.lyric,
+            cursorBuffer: decoded.cursor,
+            outputFileName: options.outputFileName || 'output.kar'
+        });
+        warnings.push(...conversionResult.warnings);
+        console.log(`[Browser] [3/3] ✓ KAR buffer created`);
+        // Optionally auto-download
+        if (options.autoDownload) {
+            (0, ncntokar_browser_1.downloadBuffer)(conversionResult.karBuffer, conversionResult.fileName);
+        }
+        return {
+            success: true,
+            karBuffer: conversionResult.karBuffer,
+            fileName: conversionResult.fileName,
+            intermediateBuffers: {
+                midi: decoded.midi,
+                lyric: decoded.lyric,
+                cursor: decoded.cursor
+            },
+            metadata,
+            warnings
+        };
+    }
+    catch (error) {
+        throw new Error(`Browser EMK to KAR conversion failed: ${error.message}`);
+    }
+}
+/**
+ * Process EMK File object directly (for file input in browser)
+ */
+async function convertEmkFileToKar(emkFile, options) {
+    const emkBuffer = await (0, ncntokar_browser_1.fileToBuffer)(emkFile);
+    const fileName = emkFile.name.replace('.emk', '.kar');
+    return convertEmkToKarBrowser({
+        emkBuffer,
+        outputFileName: fileName,
+        autoDownload: options?.autoDownload ?? true
+    });
+}
+/**
+ * Process multiple EMK files in the browser
+ */
+async function convertEmkFilesBatch(emkFiles, options) {
+    const results = [];
+    for (const emkFile of emkFiles) {
+        try {
+            const result = await convertEmkFileToKar(emkFile, {
+                autoDownload: options?.autoDownload ?? false
+            });
+            results.push(result);
+            console.log(`✓ ${emkFile.name}: ${result.metadata.title}`);
+        }
+        catch (error) {
+            console.error(`✗ ${emkFile.name}: ${error.message}`);
+            results.push({
+                success: false,
+                karBuffer: Buffer.alloc(0),
+                fileName: emkFile.name.replace('.emk', '.kar'),
+                metadata: {
+                    title: 'Error',
+                    artist: 'Error'
+                },
+                warnings: [error.message]
+            });
+        }
+    }
+    // Download all if requested
+    if (options?.autoDownload) {
+        results
+            .filter(r => r.success)
+            .forEach(r => (0, ncntokar_browser_1.downloadBuffer)(r.karBuffer, r.fileName));
+    }
+    return results;
+}
+/**
+ * Validate Thai text readability from buffer (browser version)
+ */
+function validateThaiLyricReadabilityBrowser(lyricBuffer) {
+    const iconv = require('iconv-lite');
+    const text = iconv.decode(lyricBuffer, 'tis-620');
+    const lines = text.split(/\r?\n/).filter((l) => l.trim().length > 0);
+    const thaiCharRegex = /[\u0E00-\u0E7F]/;
+    const hasThaiChars = thaiCharRegex.test(text);
+    const controlCharCount = (text.match(/[\x00-\x08\x0B-\x0C\x0E-\x1F]/g) || []).length;
+    const isReadable = controlCharCount < (text.length * 0.1);
+    return {
+        readable: isReadable,
+        encoding: 'TIS-620',
+        preview: lines.slice(0, 5),
+        charCount: text.length
+    };
+}

package/dist/emk-to-kar.d.ts

@@ -0,0 +1,53 @@
+/**
+ * EMK to KAR Workflow
+ * Complete pipeline: EMK file → decode → MIDI + LYR + CUR → convert → KAR file
+ */
+export interface EmkToKarOptions {
+    inputEmk: string;
+    outputKar: string;
+    outputDir?: string;
+    keepIntermediateFiles?: boolean;
+    appendTitles?: boolean;
+}
+export interface EmkToKarResult {
+    success: boolean;
+    outputKar: string;
+    intermediateFiles?: {
+        midi: string;
+        lyric: string;
+        cursor: string;
+    };
+    metadata: {
+        title: string;
+        artist: string;
+        code?: string;
+    };
+    warnings: string[];
+}
+/**
+ * Complete workflow: Converts EMK file directly to KAR file
+ *
+ * Pipeline:
+ * 1. Decode EMK → MIDI + Lyric + Cursor files
+ * 2. Convert MIDI + Lyric + Cursor → KAR file
+ *
+ * @param options Configuration options
+ * @returns Result with metadata and warnings
+ */
+export declare function convertEmkToKar(options: EmkToKarOptions): EmkToKarResult;
+/**
+ * Batch convert multiple EMK files to KAR
+ */
+export declare function convertEmkToKarBatch(emkFiles: string[], outputDirectory: string, options?: {
+    keepIntermediateFiles?: boolean;
+    appendTitles?: boolean;
+}): EmkToKarResult[];
+/**
+ * Validate Thai text readability from lyric buffer
+ */
+export declare function validateThaiLyricReadability(lyricBuffer: Buffer): {
+    readable: boolean;
+    encoding: string;
+    preview: string[];
+    charCount: number;
+};

package/dist/emk-to-kar.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * EMK to KAR Workflow
+ * Complete pipeline: EMK file → decode → MIDI + LYR + CUR → convert → KAR file
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEmkToKar = convertEmkToKar;
+exports.convertEmkToKarBatch = convertEmkToKarBatch;
+exports.validateThaiLyricReadability = validateThaiLyricReadability;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const server_decode_1 = require("./emk/server-decode");
+const ncntokar_1 = require("./ncntokar");
+const iconv = __importStar(require("iconv-lite"));
+/**
+ * Complete workflow: Converts EMK file directly to KAR file
+ *
+ * Pipeline:
+ * 1. Decode EMK → MIDI + Lyric + Cursor files
+ * 2. Convert MIDI + Lyric + Cursor → KAR file
+ *
+ * @param options Configuration options
+ * @returns Result with metadata and warnings
+ */
+function convertEmkToKar(options) {
+    const warnings = [];
+    // Validate input
+    if (!fs.existsSync(options.inputEmk)) {
+        throw new Error(`Input EMK file not found: ${options.inputEmk}`);
+    }
+    // Determine output directory for intermediate files
+    const outputDir = options.outputDir || path.join(path.dirname(options.outputKar), 'temp');
+    // Create temp directory if needed
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const baseFileName = path.basename(options.inputEmk, '.emk');
+    const midiFile = path.join(outputDir, `${baseFileName}.mid`);
+    const lyricFile = path.join(outputDir, `${baseFileName}.lyr`);
+    const cursorFile = path.join(outputDir, `${baseFileName}.cur`);
+    try {
+        // Step 1: Decode EMK file
+        console.log(`[1/3] Decoding EMK file: ${options.inputEmk}`);
+        const emkBuffer = fs.readFileSync(options.inputEmk);
+        const decoded = (0, server_decode_1.decodeEmk)(emkBuffer);
+        // Verify all parts are present
+        if (!decoded.midi)
+            throw new Error('MIDI data not found in EMK file');
+        if (!decoded.lyric)
+            throw new Error('Lyric data not found in EMK file');
+        if (!decoded.cursor)
+            throw new Error('Cursor data not found in EMK file');
+        // Write intermediate files
+        fs.writeFileSync(midiFile, decoded.midi);
+        fs.writeFileSync(lyricFile, decoded.lyric);
+        fs.writeFileSync(cursorFile, decoded.cursor);
+        console.log(`[1/3] ✓ Decoded to: MIDI, Lyric, Cursor`);
+        // Extract metadata from EMK
+        const songInfo = (0, server_decode_1.parseSongInfo)(decoded.songInfo);
+        // Parse lyric file to get title and artist (more reliable)
+        const lyricMetadata = (0, ncntokar_1.parseLyricFile)(lyricFile);
+        const metadata = {
+            title: lyricMetadata.title || songInfo.TITLE || 'Unknown Title',
+            artist: lyricMetadata.artist || songInfo.ARTIST || 'Unknown Artist',
+            code: songInfo.CODE
+        };
+        console.log(`[2/3] Converting to KAR: ${metadata.title} - ${metadata.artist}`);
+        // Step 2: Convert NCN to KAR
+        const conversionResult = (0, ncntokar_1.convertNcnToKar)({
+            inputMidi: midiFile,
+            inputLyr: lyricFile,
+            inputCur: cursorFile,
+            outputKar: options.outputKar,
+            appendTitles: options.appendTitles || false
+        });
+        warnings.push(...conversionResult.warnings);
+        console.log(`[3/3] ✓ KAR file created: ${options.outputKar}`);
+        // Clean up intermediate files if requested
+        if (!options.keepIntermediateFiles) {
+            fs.unlinkSync(midiFile);
+            fs.unlinkSync(lyricFile);
+            fs.unlinkSync(cursorFile);
+            // Remove temp directory if empty
+            try {
+                fs.rmdirSync(outputDir);
+            }
+            catch {
+                // Directory not empty or doesn't exist, ignore
+            }
+        }
+        return {
+            success: true,
+            outputKar: options.outputKar,
+            intermediateFiles: options.keepIntermediateFiles ? {
+                midi: midiFile,
+                lyric: lyricFile,
+                cursor: cursorFile
+            } : undefined,
+            metadata,
+            warnings
+        };
+    }
+    catch (error) {
+        // Clean up on error
+        try {
+            if (fs.existsSync(midiFile))
+                fs.unlinkSync(midiFile);
+            if (fs.existsSync(lyricFile))
+                fs.unlinkSync(lyricFile);
+            if (fs.existsSync(cursorFile))
+                fs.unlinkSync(cursorFile);
+            if (fs.existsSync(outputDir))
+                fs.rmdirSync(outputDir);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        throw new Error(`EMK to KAR conversion failed: ${error.message}`);
+    }
+}
+/**
+ * Batch convert multiple EMK files to KAR
+ */
+function convertEmkToKarBatch(emkFiles, outputDirectory, options) {
+    const results = [];
+    // Create output directory
+    if (!fs.existsSync(outputDirectory)) {
+        fs.mkdirSync(outputDirectory, { recursive: true });
+    }
+    for (const emkFile of emkFiles) {
+        const baseFileName = path.basename(emkFile, '.emk');
+        const outputKar = path.join(outputDirectory, `${baseFileName}.kar`);
+        try {
+            const result = convertEmkToKar({
+                inputEmk: emkFile,
+                outputKar,
+                keepIntermediateFiles: options?.keepIntermediateFiles || false,
+                appendTitles: options?.appendTitles || false
+            });
+            results.push(result);
+            console.log(`✓ ${baseFileName}: ${result.metadata.title}`);
+        }
+        catch (error) {
+            console.error(`✗ ${baseFileName}: ${error.message}`);
+            results.push({
+                success: false,
+                outputKar,
+                metadata: {
+                    title: 'Error',
+                    artist: 'Error'
+                },
+                warnings: [error.message]
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Validate Thai text readability from lyric buffer
+ */
+function validateThaiLyricReadability(lyricBuffer) {
+    // Try TIS-620 decoding
+    const text = iconv.decode(lyricBuffer, 'tis-620');
+    const lines = text.split(/\r?\n/).filter(l => l.trim().length > 0);
+    // Check if text contains Thai characters
+    const thaiCharRegex = /[\u0E00-\u0E7F]/;
+    const hasThaiChars = thaiCharRegex.test(text);
+    // Check if text is readable (not too many control characters)
+    const controlCharCount = (text.match(/[\x00-\x08\x0B-\x0C\x0E-\x1F]/g) || []).length;
+    const isReadable = controlCharCount < (text.length * 0.1); // Less than 10% control chars
+    return {
+        readable: isReadable,
+        encoding: 'TIS-620',
+        preview: lines.slice(0, 5),
+        charCount: text.length
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * file-coder - A comprehensive library for encoding/decoding karaoke files
+ * Supports .emk (Extreme Karaoke), .kar (MIDI karaoke), and NCN format conversions
+ */
+export { convertNcnToKar, convertWithDefaults, parseLyricFile, buildKaraokeTrack, buildMetadataTracks, readFileTextTIS620, splitLinesKeepEndings, trimLineEndings, metaEvent, endOfTrack, ensureReadableFile, ensureOutputDoesNotExist, CursorReader, type ConversionOptions, type SongMetadata } from './ncntokar';
+export { readKarFile, validateKarFile, extractLyricsFromKar, type KarFileInfo, type KarTrack } from './kar-reader';
+export { convertEmkToKar, convertEmkToKarBatch, validateThaiLyricReadability, type EmkToKarOptions, type EmkToKarResult } from './emk-to-kar';
+export { decodeEmk as decodeEmkServer, parseSongInfo as parseSongInfoServer, xorDecrypt as xorDecryptServer, looksLikeText as looksLikeTextServer, type DecodedEmkParts as DecodedEmkPartsServer } from './emk/server-decode';
+export { decodeEmk as decodeEmkClient, parseSongInfo as parseSongInfoClient, xorDecrypt as xorDecryptClient, looksLikeText as looksLikeTextClient, type DecodedEmkParts as DecodedEmkPartsClient } from './emk/client-decoder';
+export { convertNcnToKarBrowser, parseLyricBuffer, buildKaraokeTrackBrowser, buildMetadataTracksBrowser, fileToBuffer, downloadBuffer, type BrowserConversionOptions, type BrowserConversionResult, } from './ncntokar.browser';
+export { convertEmkToKarBrowser, convertEmkFileToKar, convertEmkFilesBatch, validateThaiLyricReadabilityBrowser, type BrowserEmkToKarOptions, type BrowserEmkToKarResult, } from './emk-to-kar.browser';
+export { readKarBuffer, validateKarBuffer, extractLyricsFromKarBuffer, readKarFile as readKarFileFromBrowser, type KarFileInfo as BrowserKarFileInfo, type KarTrack as BrowserKarTrack, } from './kar-reader.browser';

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * file-coder - A comprehensive library for encoding/decoding karaoke files
+ * Supports .emk (Extreme Karaoke), .kar (MIDI karaoke), and NCN format conversions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readKarFileFromBrowser = exports.extractLyricsFromKarBuffer = exports.validateKarBuffer = exports.readKarBuffer = exports.validateThaiLyricReadabilityBrowser = exports.convertEmkFilesBatch = exports.convertEmkFileToKar = exports.convertEmkToKarBrowser = exports.downloadBuffer = exports.fileToBuffer = exports.buildMetadataTracksBrowser = exports.buildKaraokeTrackBrowser = exports.parseLyricBuffer = exports.convertNcnToKarBrowser = exports.looksLikeTextClient = exports.xorDecryptClient = exports.parseSongInfoClient = exports.decodeEmkClient = exports.looksLikeTextServer = exports.xorDecryptServer = exports.parseSongInfoServer = exports.decodeEmkServer = exports.validateThaiLyricReadability = exports.convertEmkToKarBatch = exports.convertEmkToKar = exports.extractLyricsFromKar = exports.validateKarFile = exports.readKarFile = exports.CursorReader = exports.ensureOutputDoesNotExist = exports.ensureReadableFile = exports.endOfTrack = exports.metaEvent = exports.trimLineEndings = exports.splitLinesKeepEndings = exports.readFileTextTIS620 = exports.buildMetadataTracks = exports.buildKaraokeTrack = exports.parseLyricFile = exports.convertWithDefaults = exports.convertNcnToKar = void 0;
+// NCN to KAR converter exports
+var ncntokar_1 = require("./ncntokar");
+Object.defineProperty(exports, "convertNcnToKar", { enumerable: true, get: function () { return ncntokar_1.convertNcnToKar; } });
+Object.defineProperty(exports, "convertWithDefaults", { enumerable: true, get: function () { return ncntokar_1.convertWithDefaults; } });
+Object.defineProperty(exports, "parseLyricFile", { enumerable: true, get: function () { return ncntokar_1.parseLyricFile; } });
+Object.defineProperty(exports, "buildKaraokeTrack", { enumerable: true, get: function () { return ncntokar_1.buildKaraokeTrack; } });
+Object.defineProperty(exports, "buildMetadataTracks", { enumerable: true, get: function () { return ncntokar_1.buildMetadataTracks; } });
+Object.defineProperty(exports, "readFileTextTIS620", { enumerable: true, get: function () { return ncntokar_1.readFileTextTIS620; } });
+Object.defineProperty(exports, "splitLinesKeepEndings", { enumerable: true, get: function () { return ncntokar_1.splitLinesKeepEndings; } });
+Object.defineProperty(exports, "trimLineEndings", { enumerable: true, get: function () { return ncntokar_1.trimLineEndings; } });
+Object.defineProperty(exports, "metaEvent", { enumerable: true, get: function () { return ncntokar_1.metaEvent; } });
+Object.defineProperty(exports, "endOfTrack", { enumerable: true, get: function () { return ncntokar_1.endOfTrack; } });
+Object.defineProperty(exports, "ensureReadableFile", { enumerable: true, get: function () { return ncntokar_1.ensureReadableFile; } });
+Object.defineProperty(exports, "ensureOutputDoesNotExist", { enumerable: true, get: function () { return ncntokar_1.ensureOutputDoesNotExist; } });
+Object.defineProperty(exports, "CursorReader", { enumerable: true, get: function () { return ncntokar_1.CursorReader; } });
+// KAR file reader exports
+var kar_reader_1 = require("./kar-reader");
+Object.defineProperty(exports, "readKarFile", { enumerable: true, get: function () { return kar_reader_1.readKarFile; } });
+Object.defineProperty(exports, "validateKarFile", { enumerable: true, get: function () { return kar_reader_1.validateKarFile; } });
+Object.defineProperty(exports, "extractLyricsFromKar", { enumerable: true, get: function () { return kar_reader_1.extractLyricsFromKar; } });
+// EMK to KAR workflow exports (complete pipeline)
+var emk_to_kar_1 = require("./emk-to-kar");
+Object.defineProperty(exports, "convertEmkToKar", { enumerable: true, get: function () { return emk_to_kar_1.convertEmkToKar; } });
+Object.defineProperty(exports, "convertEmkToKarBatch", { enumerable: true, get: function () { return emk_to_kar_1.convertEmkToKarBatch; } });
+Object.defineProperty(exports, "validateThaiLyricReadability", { enumerable: true, get: function () { return emk_to_kar_1.validateThaiLyricReadability; } });
+// EMK server-side decoder exports
+var server_decode_1 = require("./emk/server-decode");
+Object.defineProperty(exports, "decodeEmkServer", { enumerable: true, get: function () { return server_decode_1.decodeEmk; } });
+Object.defineProperty(exports, "parseSongInfoServer", { enumerable: true, get: function () { return server_decode_1.parseSongInfo; } });
+Object.defineProperty(exports, "xorDecryptServer", { enumerable: true, get: function () { return server_decode_1.xorDecrypt; } });
+Object.defineProperty(exports, "looksLikeTextServer", { enumerable: true, get: function () { return server_decode_1.looksLikeText; } });
+// EMK client-side decoder exports
+var client_decoder_1 = require("./emk/client-decoder");
+Object.defineProperty(exports, "decodeEmkClient", { enumerable: true, get: function () { return client_decoder_1.decodeEmk; } });
+Object.defineProperty(exports, "parseSongInfoClient", { enumerable: true, get: function () { return client_decoder_1.parseSongInfo; } });
+Object.defineProperty(exports, "xorDecryptClient", { enumerable: true, get: function () { return client_decoder_1.xorDecrypt; } });
+Object.defineProperty(exports, "looksLikeTextClient", { enumerable: true, get: function () { return client_decoder_1.looksLikeText; } });
+// Browser-compatible NCN to KAR conversion
+var ncntokar_browser_1 = require("./ncntokar.browser");
+Object.defineProperty(exports, "convertNcnToKarBrowser", { enumerable: true, get: function () { return ncntokar_browser_1.convertNcnToKarBrowser; } });
+Object.defineProperty(exports, "parseLyricBuffer", { enumerable: true, get: function () { return ncntokar_browser_1.parseLyricBuffer; } });
+Object.defineProperty(exports, "buildKaraokeTrackBrowser", { enumerable: true, get: function () { return ncntokar_browser_1.buildKaraokeTrackBrowser; } });
+Object.defineProperty(exports, "buildMetadataTracksBrowser", { enumerable: true, get: function () { return ncntokar_browser_1.buildMetadataTracksBrowser; } });
+Object.defineProperty(exports, "fileToBuffer", { enumerable: true, get: function () { return ncntokar_browser_1.fileToBuffer; } });
+Object.defineProperty(exports, "downloadBuffer", { enumerable: true, get: function () { return ncntokar_browser_1.downloadBuffer; } });
+// Browser-compatible EMK to KAR workflow
+var emk_to_kar_browser_1 = require("./emk-to-kar.browser");
+Object.defineProperty(exports, "convertEmkToKarBrowser", { enumerable: true, get: function () { return emk_to_kar_browser_1.convertEmkToKarBrowser; } });
+Object.defineProperty(exports, "convertEmkFileToKar", { enumerable: true, get: function () { return emk_to_kar_browser_1.convertEmkFileToKar; } });
+Object.defineProperty(exports, "convertEmkFilesBatch", { enumerable: true, get: function () { return emk_to_kar_browser_1.convertEmkFilesBatch; } });
+Object.defineProperty(exports, "validateThaiLyricReadabilityBrowser", { enumerable: true, get: function () { return emk_to_kar_browser_1.validateThaiLyricReadabilityBrowser; } });
+// Browser-compatible KAR reader
+var kar_reader_browser_1 = require("./kar-reader.browser");
+Object.defineProperty(exports, "readKarBuffer", { enumerable: true, get: function () { return kar_reader_browser_1.readKarBuffer; } });
+Object.defineProperty(exports, "validateKarBuffer", { enumerable: true, get: function () { return kar_reader_browser_1.validateKarBuffer; } });
+Object.defineProperty(exports, "extractLyricsFromKarBuffer", { enumerable: true, get: function () { return kar_reader_browser_1.extractLyricsFromKarBuffer; } });
+Object.defineProperty(exports, "readKarFileFromBrowser", { enumerable: true, get: function () { return kar_reader_browser_1.readKarFile; } });