lyrics-structure 1.2.0 → 1.2.2

package/.prettierrc

@@ -0,0 +1,10 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "bracketSpacing": true,
+  "arrowParens": "always"
+} 

package/.vscode/settings.json

@@ -0,0 +1,19 @@
+{
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.codeActionsOnSave": {
+    "source.fixAll": true
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[markdown]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
+}

package/CHANGELOG.md

@@ -1,18 +1,28 @@
 # Changelog
 
+## [1.2.2] - 2024-04-06
+
+### Fixed
+
+- Fixed issue where consecutive lines without part containers were incorrectly split into separate parts
+- Improved handling of regular text lines to maintain proper grouping
+
 ## [1.2.0] - 2024-03-XX
 
 ### Changed
+
 - Simplified the lyrics format to use clear section markers
 - Updated documentation with clearer examples
 - Improved type definitions for better TypeScript support
 
 ### Added
+
 - Support for section indications in parentheses
 - Better handling of repeated sections
 - More intuitive content structure
 
 ### Removed
+
 - Slide-based content splitting
 - Special command tags
 - Complex formatting options
@@ -20,6 +30,7 @@
 ## [1.1.0] - 2024-03-XX
 
 ### Added
+
 - Initial release
 - `getParts` function for basic content extraction
 - `getSlideParts` function for slide-based content splitting
@@ -28,6 +39,7 @@
 - TypeScript types and documentation
 
 ### Features
+
 - Bracketed section parsing
 - Special command tag handling
 - Slide splitting based on content length
@@ -37,7 +49,8 @@
 - Unicode support in tags
 
 ### Test Coverage
+
 - Basic functionality tests
 - Slide splitting tests
 - Special command tests
-- Edge case handling 
+- Edge case handling

package/debug.ts

@@ -0,0 +1,47 @@
+import { getSlideParts } from './slide';
+
+const comprehensiveInput = `
+[verse]
+First line of verse
+Second line of verse
+Third line of verse
+Fourth line of verse
+Fifth line of verse
+[/verse]
+[verse]
+(inside parentheses)
+Regular text line 1
+Regular text line 2
+
+[chorus]
+First chorus line
+Second chorus line
+[/chorus]
+
+[verse 1]
+This is a very long line that should be considered too long for the slide
+This is another very long line that should also be considered too long
+Short line 1
+Short line 2
+[/verse 1]
+
+Regular line 1
+Regular line 2
+
+More content
+
+This is a very long line that exceeds forty characters for testing purposes
+This is another very long line that also exceeds the forty character limit
+Another very long line that should be considered too long for the slide
+And yet another very long line that should be split into a new section
+Regular line
+
+[verse 2]
+    First line with spaces    
+  Second line with spaces  
+[/verse 2]
+
+[chorus]`;
+
+console.log('Output from getSlideParts:');
+console.log(JSON.stringify(getSlideParts(comprehensiveInput), null, 2));

package/dist/debug.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/debug.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const slide_1 = require("./slide");
+const comprehensiveInput = `
+[verse]
+First line of verse
+Second line of verse
+Third line of verse
+Fourth line of verse
+Fifth line of verse
+[/verse]
+[verse]
+(inside parentheses)
+Regular text line 1
+Regular text line 2
+
+[chorus]
+First chorus line
+Second chorus line
+[/chorus]
+
+[verse 1]
+This is a very long line that should be considered too long for the slide
+This is another very long line that should also be considered too long
+Short line 1
+Short line 2
+[/verse 1]
+
+Regular line 1
+Regular line 2
+
+More content
+
+This is a very long line that exceeds forty characters for testing purposes
+This is another very long line that also exceeds the forty character limit
+Another very long line that should be considered too long for the slide
+And yet another very long line that should be split into a new section
+Regular line
+
+[verse 2]
+    First line with spaces    
+  Second line with spaces  
+[/verse 2]
+
+[chorus]`;
+console.log('Output from getSlideParts:');
+console.log(JSON.stringify((0, slide_1.getSlideParts)(comprehensiveInput), null, 2));

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './slide.js';
+export * from './lyrics.js';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./slide.js"), exports);
+__exportStar(require("./lyrics.js"), exports);

package/dist/lyrics.d.ts

@@ -0,0 +1,25 @@
+export type LyricPart = {
+    name: string | undefined;
+    repetition: boolean;
+    indication: string | null;
+    content: string | undefined;
+};
+/**
+ * Splits lyrics into structured parts, handling named sections, repetitions, and indications.
+ * Works with lyrics formatted using square brackets for section names and optional parentheses for indications.
+ *
+ * Example input:
+ * ```
+ * [verse 1] (first time)
+ * Lyrics content here
+ * [/verse 1]
+ *
+ * [chorus]
+ * Chorus lyrics
+ * [/chorus]
+ * ```
+ *
+ * @param lyrics - The input lyrics text to be parsed into parts
+ * @returns Array of LyricPart objects containing structured lyrics data
+ */
+export declare function getLyricsParts(lyrics: string): LyricPart[];

package/dist/lyrics.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLyricsParts = getLyricsParts;
+/**
+ * Splits lyrics into structured parts, handling named sections, repetitions, and indications.
+ * Works with lyrics formatted using square brackets for section names and optional parentheses for indications.
+ *
+ * Example input:
+ * ```
+ * [verse 1] (first time)
+ * Lyrics content here
+ * [/verse 1]
+ *
+ * [chorus]
+ * Chorus lyrics
+ * [/chorus]
+ * ```
+ *
+ * @param lyrics - The input lyrics text to be parsed into parts
+ * @returns Array of LyricPart objects containing structured lyrics data
+ */
+function getLyricsParts(lyrics) {
+    const parts = [];
+    const seenParts = new Map();
+    const partContentMap = new Map();
+    // First pass: extract all content with closing tags
+    const cleanedText = lyrics.replace(/\[([^\]]+)\](?:\s*\(([^)]+)\))?\s*([\s\S]*?)\[\/\1\]/g, (match, key, indication, content) => {
+        if (!partContentMap.has(key)) {
+            partContentMap.set(key, content.trim());
+        }
+        return `[${key}]${indication ? ` (${indication})` : ''}`;
+    });
+    // Split the lyrics into lines and process them
+    const lines = cleanedText.split('\n');
+    let currentPart = null;
+    let currentUnnamedContent = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Check for part start
+        const partStartMatch = line.match(/^\[([^\]]+)\](?:\s*\(([^)]+)\))?$/);
+        if (partStartMatch) {
+            // If we have accumulated unnamed content, add it as a part
+            if (currentUnnamedContent.length > 0) {
+                parts.push({
+                    name: undefined,
+                    repetition: false,
+                    indication: null,
+                    content: currentUnnamedContent.join('\n'),
+                });
+                currentUnnamedContent = [];
+            }
+            const partName = partStartMatch[1];
+            const indication = partStartMatch[2] || null;
+            // Check if this part has been seen before
+            const partCount = (seenParts.get(partName) || 0) + 1;
+            seenParts.set(partName, partCount);
+            currentPart = {
+                name: partName,
+                repetition: partCount > 1,
+                indication,
+                content: partContentMap.get(partName),
+            };
+            parts.push(currentPart);
+            continue;
+        }
+        // Handle content without a part container
+        if (line && !line.startsWith('[') && !line.startsWith('[/')) {
+            currentUnnamedContent.push(line);
+        }
+        else if (currentUnnamedContent.length > 0) {
+            // If we hit a part marker or empty line, add the accumulated content
+            parts.push({
+                name: undefined,
+                repetition: false,
+                indication: null,
+                content: currentUnnamedContent.join('\n'),
+            });
+            currentUnnamedContent = [];
+        }
+    }
+    // Add any remaining unnamed content
+    if (currentUnnamedContent.length > 0) {
+        parts.push({
+            name: undefined,
+            repetition: false,
+            indication: null,
+            content: currentUnnamedContent.join('\n'),
+        });
+    }
+    return parts;
+}

package/dist/lyrics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lyrics.test.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lyrics_1 = require("./lyrics");
+const testLyrics = `[partname 1] (indication 1)
+
+content 1
+
+[/partname 1]
+
+[partname 1] (indication 2)
+
+[partname 2]
+
+content 2
+
+[/partname 2]
+
+[interlude 1]
+
+[partname 3]
+
+content without partname container
+
+content standalone 1
+content standalone 2
+`;
+describe('getLyricsParts', () => {
+    it('should correctly parse lyrics into parts', () => {
+        const result = (0, lyrics_1.getLyricsParts)(testLyrics);
+        expect(result).toEqual([
+            {
+                name: 'partname 1',
+                repetition: false,
+                indication: 'indication 1',
+                content: 'content 1',
+            },
+            {
+                name: 'partname 1',
+                repetition: true,
+                indication: 'indication 2',
+                content: 'content 1',
+            },
+            {
+                name: 'partname 2',
+                repetition: false,
+                indication: null,
+                content: 'content 2',
+            },
+            {
+                name: 'interlude 1',
+                repetition: false,
+                indication: null,
+                content: undefined,
+            },
+            {
+                name: 'partname 3',
+                repetition: false,
+                indication: null,
+                content: undefined,
+            },
+            {
+                name: undefined,
+                repetition: false,
+                indication: null,
+                content: 'content without partname container',
+            },
+            {
+                name: undefined,
+                repetition: false,
+                indication: null,
+                content: 'content standalone 1\ncontent standalone 2',
+            },
+        ]);
+    });
+});

package/dist/slide.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Splits text into natural sections based on text structure.
+ * Works with plain text without requiring markdown or special formatting.
+ * Empty lines are treated as natural separators between parts.
+ *
+ * @param text - The input text to be split into sections
+ * @param maxLinesPerSlide - Maximum number of lines to include in a single slide (default: 6)
+ * @returns An array of content sections
+ */
+export declare const getSlideParts: (text?: string) => string[];

package/dist/slide.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Splits text into natural sections based on text structure.
+ * Works with plain text without requiring markdown or special formatting.
+ * Empty lines are treated as natural separators between parts.
+ *
+ * @param text - The input text to be split into sections
+ * @param maxLinesPerSlide - Maximum number of lines to include in a single slide (default: 6)
+ * @returns An array of content sections
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSlideParts = void 0;
+const lyrics_1 = require("./lyrics");
+const isLineTooLong = (line) => line.length > 40;
+const processContent = (content) => {
+    const slides = [];
+    let currentSlide = [];
+    content.split('\n').forEach((line) => {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            if (currentSlide.length > 0) {
+                slides.push(currentSlide.join('\n'));
+                currentSlide = [];
+            }
+            return;
+        }
+        if (currentSlide.length >= 4 ||
+            (currentSlide.length >= 2 && currentSlide.filter(isLineTooLong).length >= 2)) {
+            slides.push(currentSlide.join('\n'));
+            currentSlide = [];
+        }
+        currentSlide.push(trimmedLine);
+    });
+    if (currentSlide.length > 0) {
+        slides.push(currentSlide.join('\n'));
+    }
+    return slides;
+};
+const getSlideParts = (text) => {
+    if (!text)
+        return [];
+    // Remove text between parentheses
+    const textWithoutParentheses = text.replace(/\([^)]*\)/g, '');
+    const partsText = (0, lyrics_1.getLyricsParts)(textWithoutParentheses).map((part) => part.content);
+    const result = [];
+    partsText.forEach((part) => {
+        if (part) {
+            result.push(...processContent(part));
+        }
+    });
+    return result;
+};
+exports.getSlideParts = getSlideParts;

package/dist/slide.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/slide.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const slide_js_1 = require("./slide.js");
+describe('Comprehensive Tests', () => {
+    test('handles all cases in one comprehensive input', () => {
+        const comprehensiveInput = `
+[verse]
+First line of verse
+Second line of verse
+Third line of verse
+Fourth line of verse
+Fifth line of verse
+[/verse]
+[verse]
+(inside parentheses)
+Regular text line 1
+Regular text line 2
+
+[chorus]
+First chorus line
+Second chorus line
+[/chorus]
+
+[verse 1]
+This is a very long line that should be considered too long for the slide
+This is another very long line that should also be considered too long
+Short line 1
+Short line 2
+[/verse 1]
+
+Regular line 1
+Regular line 2
+
+More content
+
+This is a very long line that exceeds forty characters for testing purposes
+This is another very long line that also exceeds the forty character limit
+Another very long line that should be considered too long for the slide
+And yet another very long line that should be split into a new section
+Regular line
+
+[verse 2]
+    First line with spaces    
+  Second line with spaces  
+[/verse 2]
+
+[chorus]`;
+        expect((0, slide_js_1.getSlideParts)(comprehensiveInput)).toEqual([
+            'First line of verse\nSecond line of verse\nThird line of verse\nFourth line of verse',
+            'Fifth line of verse',
+            'First line of verse\nSecond line of verse\nThird line of verse\nFourth line of verse',
+            'Fifth line of verse',
+            'Regular text line 1\nRegular text line 2',
+            'First chorus line\nSecond chorus line',
+            'This is a very long line that should be considered too long for the slide\nThis is another very long line that should also be considered too long',
+            'Short line 1\nShort line 2',
+            'Regular line 1\nRegular line 2',
+            'More content',
+            'This is a very long line that exceeds forty characters for testing purposes\nThis is another very long line that also exceeds the forty character limit',
+            'Another very long line that should be considered too long for the slide\nAnd yet another very long line that should be split into a new section',
+            'Regular line',
+            'First line with spaces\nSecond line with spaces',
+            'First chorus line\nSecond chorus line'
+        ]);
+    });
+});

package/jest.config.js

@@ -7,8 +7,11 @@ export default {
     '^(\\.{1,2}/.*)\\.js$': '$1',
   },
   transform: {
-    '^.+\\.tsx?$': ['ts-jest', {
-      useESM: true,
-    }],
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
   },
-}; 
+};

package/lyrics.test.ts

@@ -18,49 +18,59 @@ content 2
 
 [partname 3]
 
-content without partname container`;
+content without partname container
+
+content standalone 1
+content standalone 2
+`;
 
 describe('getLyricsParts', () => {
-    it('should correctly parse lyrics into parts', () => {
-        const result = getLyricsParts(testLyrics);
-        
-        expect(result).toEqual([
-            {
-                name: 'partname 1',
-                repetition: false,
-                indication: 'indication 1',
-                content: 'content 1'
-            },
-            {
-                name: 'partname 1',
-                repetition: true,
-                indication: 'indication 2',
-                content: 'content 1'
-            },
-            {
-                name: 'partname 2',
-                repetition: false,
-                indication: null,
-                content: 'content 2'
-            },
-            {
-                name: 'interlude 1',
-                repetition: false,
-                indication: null,
-                content: undefined
-            },
-            {
-                name: 'partname 3',
-                repetition: false,
-                indication: null,
-                content: undefined
-            },
-            {
-                name: undefined,
-                repetition: false,
-                indication: null,
-                content: 'content without partname container'
-            }
-        ]);
-    });
-}); 
+  it('should correctly parse lyrics into parts', () => {
+    const result = getLyricsParts(testLyrics);
+
+    expect(result).toEqual([
+      {
+        name: 'partname 1',
+        repetition: false,
+        indication: 'indication 1',
+        content: 'content 1',
+      },
+      {
+        name: 'partname 1',
+        repetition: true,
+        indication: 'indication 2',
+        content: 'content 1',
+      },
+      {
+        name: 'partname 2',
+        repetition: false,
+        indication: null,
+        content: 'content 2',
+      },
+      {
+        name: 'interlude 1',
+        repetition: false,
+        indication: null,
+        content: undefined,
+      },
+      {
+        name: 'partname 3',
+        repetition: false,
+        indication: null,
+        content: undefined,
+      },
+      {
+        name: undefined,
+        repetition: false,
+        indication: null,
+        content: 'content without partname container',
+      },
+      {
+        name: undefined,
+        repetition: false,
+        indication: null,
+        content: 'content standalone 1\ncontent standalone 2',
+      },
+    ]);
+  });
+});

package/lyrics.ts

@@ -1,81 +1,107 @@
 export type LyricPart = {
-    name: string | undefined;
-    repetition: boolean;
-    indication: string | null;
-    content: string | undefined;
+  name: string | undefined;
+  repetition: boolean;
+  indication: string | null;
+  content: string | undefined;
 };
 /**
  * Splits lyrics into structured parts, handling named sections, repetitions, and indications.
  * Works with lyrics formatted using square brackets for section names and optional parentheses for indications.
- * 
+ *
  * Example input:
  * ```
  * [verse 1] (first time)
  * Lyrics content here
  * [/verse 1]
- * 
+ *
  * [chorus]
  * Chorus lyrics
  * [/chorus]
  * ```
- * 
+ *
  * @param lyrics - The input lyrics text to be parsed into parts
  * @returns Array of LyricPart objects containing structured lyrics data
  */
 
 export function getLyricsParts(lyrics: string): LyricPart[] {
-    const parts: LyricPart[] = [];
-    const seenParts = new Map<string, number>();
-    const partContentMap = new Map<string, string>();
+  const parts: LyricPart[] = [];
+  const seenParts = new Map<string, number>();
+  const partContentMap = new Map<string, string>();
 
-    // First pass: extract all content with closing tags
-    const cleanedText = lyrics.replace(
-        /\[([^\]]+)\](?:\s*\(([^)]+)\))?\s*([\s\S]*?)\[\/\1\]/g,
-        (match, key: string, indication: string | undefined, content: string) => {
-            if (!partContentMap.has(key)) {
-                partContentMap.set(key, content.trim());
-            }
-            return `[${key}]${indication ? ` (${indication})` : ''}`;
-        }
-    );
+  // First pass: extract all content with closing tags
+  const cleanedText = lyrics.replace(
+    /\[([^\]]+)\](?:\s*\(([^)]+)\))?\s*([\s\S]*?)\[\/\1\]/g,
+    (match, key: string, indication: string | undefined, content: string) => {
+      if (!partContentMap.has(key)) {
+        partContentMap.set(key, content.trim());
+      }
+      return `[${key}]${indication ? ` (${indication})` : ''}`;
+    }
+  );
+
+  // Split the lyrics into lines and process them
+  const lines = cleanedText.split('\n');
+  let currentPart: LyricPart | null = null;
+  let currentUnnamedContent: string[] = [];
 
-    // Split the lyrics into lines and process them
-    const lines = cleanedText.split('\n');
-    let currentPart: LyricPart | null = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
 
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
+    // Check for part start
+    const partStartMatch = line.match(/^\[([^\]]+)\](?:\s*\(([^)]+)\))?$/);
+    if (partStartMatch) {
+      // If we have accumulated unnamed content, add it as a part
+      if (currentUnnamedContent.length > 0) {
+        parts.push({
+          name: undefined,
+          repetition: false,
+          indication: null,
+          content: currentUnnamedContent.join('\n'),
+        });
+        currentUnnamedContent = [];
+      }
 
-        // Check for part start
-        const partStartMatch = line.match(/^\[([^\]]+)\](?:\s*\(([^)]+)\))?$/);
-        if (partStartMatch) {
-            const partName = partStartMatch[1];
-            const indication = partStartMatch[2] || null;
-            
-            // Check if this part has been seen before
-            const partCount = (seenParts.get(partName) || 0) + 1;
-            seenParts.set(partName, partCount);
+      const partName = partStartMatch[1];
+      const indication = partStartMatch[2] || null;
 
-            currentPart = {
-                name: partName,
-                repetition: partCount > 1,
-                indication,
-                content: partContentMap.get(partName)
-            };
-            parts.push(currentPart);
-            continue;
-        }
+      // Check if this part has been seen before
+      const partCount = (seenParts.get(partName) || 0) + 1;
+      seenParts.set(partName, partCount);
 
-        // Handle content without a part container
-        if (line && !line.startsWith('[') && !line.startsWith('[/')) {
-            parts.push({
-                name: undefined,
-                repetition: false,
-                indication: null,
-                content: line
-            });
-        }
+      currentPart = {
+        name: partName,
+        repetition: partCount > 1,
+        indication,
+        content: partContentMap.get(partName),
+      };
+      parts.push(currentPart);
+      continue;
     }
 
-    return parts;
-} 
+    // Handle content without a part container
+    if (line && !line.startsWith('[') && !line.startsWith('[/')) {
+      currentUnnamedContent.push(line);
+    } else if (currentUnnamedContent.length > 0) {
+      // If we hit a part marker or empty line, add the accumulated content
+      parts.push({
+        name: undefined,
+        repetition: false,
+        indication: null,
+        content: currentUnnamedContent.join('\n'),
+      });
+      currentUnnamedContent = [];
+    }
+  }
+
+  // Add any remaining unnamed content
+  if (currentUnnamedContent.length > 0) {
+    parts.push({
+      name: undefined,
+      repetition: false,
+      indication: null,
+      content: currentUnnamedContent.join('\n'),
+    });
+  }
+
+  return parts;
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "lyrics-structure",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Parser for lyrics with structured sections, names, and indications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "test": "jest",
-    "test:watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "format": "prettier --write \"**/*.{ts,js,json,md}\""
   },
   "keywords": [
     "lyrics",
@@ -20,6 +21,7 @@
   "devDependencies": {
     "@types/jest": "^29.0.0",
     "jest": "^29.0.0",
+    "prettier": "^3.5.3",
     "ts-jest": "^29.0.0",
     "typescript": "^5.0.0"
   }

package/slide.ts

@@ -2,82 +2,62 @@
  * Splits text into natural sections based on text structure.
  * Works with plain text without requiring markdown or special formatting.
  * Empty lines are treated as natural separators between parts.
- * 
+ *
  * @param text - The input text to be split into sections
  * @param maxLinesPerSlide - Maximum number of lines to include in a single slide (default: 6)
  * @returns An array of content sections
  */
 
-export const getSlideParts = (text?: string): string[]  => {
-    if (!text) return [];
-  
-    const isLineTooLong = (line: string) => line.length > 40;
-  
-    // Process parts in brackets and create a map
-    const partsMap = new Map<string, string>();
-    
-    // First pass: extract all content with closing tags
-    const cleanedText = text.replace(
-        /\[(.*?)\]([\s\S]*?)\[\/\1\]/g,
-        (match, key: string, content) => {
-            if (!partsMap.has(key)) {
-                partsMap.set(key, content.trim());
-            }
-            return `[${key}]`;
-        }
-    );
+import { getLyricsParts } from './lyrics';
 
-    // Remove text between parentheses
-    const textWithoutParentheses = cleanedText.replace(/\([^)]*\)/g, '');
-  
-    const processContent = (content: string): string[] => {
-        const slides: string[] = [];
-        let currentSlide: string[] = [];
-  
-        content.split("\n").forEach((line) => {
-            const trimmedLine = line.trim();
-  
-            if (!trimmedLine) {
-                if (currentSlide.length > 0) {
-                    slides.push(currentSlide.join("\n"));
-                    currentSlide = [];
-                }
-                return;
-            }
-  
-            if (
-                currentSlide.length >= 4 ||
-                (currentSlide.length >= 2 &&
-                currentSlide.filter(isLineTooLong).length >= 2)
-            ) {
-                slides.push(currentSlide.join("\n"));
-                currentSlide = [];
-            }
-  
-            currentSlide.push(trimmedLine);
-        });
-  
-        if (currentSlide.length > 0) {
-            slides.push(currentSlide.join("\n"));
-        }
-  
-        return slides;
-    };
-  
-    const result: string[] = [];
-    const parts = textWithoutParentheses
-        .trim()
-        .split(/\[([^\]]+)\]/)
-        .filter(Boolean);
-  
-    parts.forEach((part) => {
-        if (partsMap.has(part)) {
-            const partContent = partsMap.get(part)!;
-            result.push(...processContent(partContent));
-        } else if (part.trim()) {
-            result.push(...processContent(part));
-        }
-    });
-  
-    return result;
-};
+const isLineTooLong = (line: string) => line.length > 40;
+const processContent = (content: string): string[] => {
+  const slides: string[] = [];
+  let currentSlide: string[] = [];
+
+  content.split('\n').forEach((line) => {
+    const trimmedLine = line.trim();
+
+    if (!trimmedLine) {
+      if (currentSlide.length > 0) {
+        slides.push(currentSlide.join('\n'));
+        currentSlide = [];
+      }
+      return;
+    }
+
+    if (
+      currentSlide.length >= 4 ||
+      (currentSlide.length >= 2 && currentSlide.filter(isLineTooLong).length >= 2)
+    ) {
+      slides.push(currentSlide.join('\n'));
+      currentSlide = [];
+    }
+
+    currentSlide.push(trimmedLine);
+  });
+
+  if (currentSlide.length > 0) {
+    slides.push(currentSlide.join('\n'));
+  }
+
+  return slides;
+};
+
+export const getSlideParts = (text?: string): string[] => {
+  if (!text) return [];
+
+  // Remove text between parentheses
+  const textWithoutParentheses = text.replace(/\([^)]*\)/g, '');
+  const partsText = getLyricsParts(textWithoutParentheses).map((part) => part.content);
+
+  const result: string[] = [];
+
+  partsText.forEach((part) => {
+    if (part) {
+      result.push(...processContent(part));
+    }
+  });
+
+  return result;
+};