tiny-essentials 1.28.7 → 1.28.9

package/docs/v1/README.md

@@ -21,6 +21,7 @@ Here, you can navigate through different sections of the project. Below are the
 - 📺 **[FullScreen](./basics/fullScreen.md)** — A complete fullscreen API manager with detection, event handling, and cross-browser compatibility.
 - 🧱 **[Collision](./basics/collision.md)** — Full-featured rectangle collision detection system with directional analysis, depth calculation, and center offset metrics.
 - 🎵 **[MediaContent](./basics/mediaContent.md)** — A comprehensive media processing module for downloading audio, extracting rich ID3 metadata, and managing image blobs for album art.
+- 📦 **[BrowserDetector](./basics/browserDetector.md)** — A multi-layered JavaScript utility for identifying the user's web browser and rendering engine.
 
 ### 2. **`libs/`**
 - 🗂️ **[TinyPromiseQueue](./libs/TinyPromiseQueue.md)** — A class that allows sequential execution of asynchronous tasks, supporting task delays, cancellation, and queue management.
@@ -64,6 +65,7 @@ Here, you can navigate through different sections of the project. Below are the
 * 🧠 **[TinyMamdaniInferenceSystem](./libs/TinyMamdaniInferenceSystem.md)** — A implementation of a Mamdani Inference System, allowing you to model logic using trapezoidal membership functions.
 * 📻 **[TinyRadioFm](./libs/TinyRadioFm.md)** — It is designed to handle complex playback sequences, including music and voice playlists, scheduled timeline mutations, and custom content injections, all while maintaining absolute reproducibility through a mathematical seed.
 * ⏯️ **[TinyMediaPlayer](./libs/TinyMediaPlayer.md)** — A universal media player architecture utilizing an adapter pattern to orchestrate multiple platform APIs, featuring robust playlist management, playback controls, and weighted random selection.
+* 🛠️ **[TinyDebugger](./libs/TinyDebugger.md)** — A lightweight, event-driven debugging utility designed to wrap standard `console` methods. It provides enhanced features such as custom prefixes, color support, and the ability to emit events whenever a log occurs, making it perfect for complex applications where you might want to redirect logs to an external service or a UI component.
 
 ### 2.1. **`libs/TinyClassManager`**
 

package/docs/v1/basics/browserDetector.md

@@ -0,0 +1,135 @@
+# 🌐 Browser Detection Toolkit
+
+A multi-layered JavaScript utility for identifying the user's web browser and rendering engine.
+
+## 📋 Table of Contents
+1. [Data Types](#📋-data-types)
+2. [Core Functions](#🛠️-core-functions)
+   - [isBrowserAgent](#1-isbrowseragent)
+   - [getBrowserCssPrefix](#2-getbrowsercssprefix)
+   - [getDuckTyping](#3-getducktyping)
+3. [Advanced Detection](#🎯-advanced-detection)
+   - [getBrowserPings](#4-getbrowserpings)
+   - [browserIs](#5-browseris)
+
+---
+
+## 📋 Data Types
+
+To ensure type safety and clarity, the toolkit utilizes the following definitions:
+
+### `BrowserDetected`
+A union type representing the supported browser names:
+`'chrome' | 'firefox' | 'ie' | 'edge' | 'safari' | 'opera' | 'yandex' | 'other'`
+
+### `DuckTypingResult`
+An object returned by feature detection, containing boolean flags:
+| Property | Description |
+| :--- | :--- |
+| `isOpera` | `true` if Opera is detected |
+| `isFirefox` | `true` if Firefox is detected |
+| `isSafari` | `true` if Safari is detected |
+| `isIE` | `true` if Internet Explorer is detected |
+| `isEdge` | `true` if Microsoft Edge is detected |
+| `isChrome` | `true` if Google Chrome is detected |
+| `isBlink` | `true` if the Blink rendering engine is detected |
+
+---
+
+## 🛠️ Core Functions
+
+### 1. `isBrowserAgent()`
+Parses the `navigator.userAgent` string to provide a quick identification of the browser.
+
+* **Returns:** `BrowserDetected`
+* **Best use case:** Quick, lightweight checks where absolute precision is not critical.
+
+```javascript
+import { isBrowserAgent } from 'tiny-essentials/basics/browserDetector';
+
+const browser = isBrowserAgent();
+console.log(`You are using: ${browser}`); 
+// Output example: "chrome"
+```
+
+### 2. `getBrowserCssPrefix()`
+Inspects the computed styles of the document to determine the CSS rendering engine.
+
+* **Returns:** `'gecko' | 'webkit' | 'trident' | 'other'`
+* **Best use case:** When you need to apply CSS vendor prefixes or handle engine-specific rendering quirks.
+
+```javascript
+import { getBrowserCssPrefix } from 'tiny-essentials/basics/browserDetector';
+
+const engine = getBrowserCssPrefix();
+if (engine === 'webkit') {
+  console.log("Applying WebKit specific styles... 🎨");
+}
+```
+
+### 3. `getDuckTyping()`
+Performs deep feature detection by checking for the existence of specific global objects and APIs.
+
+* **Returns:** `DuckTypingResult`
+* **Best use case:** When you need to know exactly which features are available in the current environment.
+
+```javascript
+import { getDuckTyping } from './browserDetector.js';
+
+const features = getDuckTyping();
+
+if (features.isChrome) {
+  console.log("Chrome-specific API available! ✅");
+}
+
+if (features.isBlink) {
+  console.log("Blink engine detected. ⚡");
+}
+```
+
+---
+
+## 🎯 Advanced Detection
+
+These functions aggregate the results from the core functions to provide the highest possible accuracy.
+
+### 4. `getBrowserPings(disable = [])`
+Aggregates detection results from all three methods (User Agent, CSS Prefix, and Duck Typing) to provide a "ping count" for each browser.
+
+* **Parameters:** 
+  * `disable` (Array): An optional array of `BrowserDetected` names to exclude from the results.
+* **Returns:** `Object<BrowserDetected, number>` (An object where keys are browsers and values are the number of times they were detected).
+* **Throws:** `TypeError` if `disable` is not an array or contains invalid browser names.
+
+```javascript
+import { getBrowserPings } from 'tiny-essentials/basics/browserDetector';
+
+// Get detection counts for all browsers
+const counts = getBrowserPings();
+console.log(counts);
+
+// Get counts while ignoring Internet Explorer
+const filteredCounts = getBrowserPings(['ie']);
+console.log(filteredCounts);
+```
+
+### 5. `browserIs(disable = [])`
+The most reliable method. It runs all detection strategies and returns the browser that received the highest number of "pings."
+
+* **Parameters:** 
+  * `disable` (Array): An optional array of `BrowserDetected` names to exclude.
+* **Returns:** `BrowserDetected` (The most likely browser name).
+* **Throws:** `TypeError` if `disable` is not an array or contains invalid browser names.
+
+```javascript
+import { browserIs } from 'tiny-essentials/basics/browserDetector';
+
+// Get the most accurate browser identification
+const currentBrowser = browserIs();
+
+if (currentBrowser === 'firefox') {
+  console.log("Welcome, Firefox user! 🦊");
+} else {
+  console.log(`Detected: ${currentBrowser}`);
+}
+```

package/docs/v1/libs/TinyDebugger.md

@@ -0,0 +1,119 @@
+# 🛠️ TinyDebugger Documentation
+
+`TinyDebugger` is a lightweight, event-driven debugging utility designed to wrap standard `console` methods. It provides enhanced features such as custom prefixes, color support, and the ability to emit events whenever a log occurs, making it perfect for complex applications where you might want to redirect logs to an external service or a UI component.
+
+## 🚀 Quick Start
+
+To use `TinyDebugger`, import it into your project and initialize it with a configuration object.
+
+```javascript
+import TinyDebugger from 'tiny-essentials/libs/TinyDebugger';
+
+const debuggerInstance = new TinyDebugger({
+  logger: console, // You can use standard console or a custom object
+  id: 'APP_CORE',
+  debugMode: true,
+  canEmitLogs: true,
+  useLogColors: true
+});
+
+debuggerInstance.log('info', 'Hello, Yasmin! The debugger is ready. 🌟');
+```
+
+---
+
+## ⚙️ Configuration
+
+When creating a new instance via the `constructor`, you can pass a configuration object with the following properties:
+
+| Property | Type | Required | Default | Description |
+| :--- | :--- | :--- | :--- | :--- |
+| `logger` | `Object` | **Yes** | N/A | An object implementing the `Console` interface. |
+| `id` | `string` | **Yes** | N/A | A unique identifier for this debugger instance. |
+| `debugMode` | `boolean` | **Yes** | N/A | If `false`, all logging methods will return immediately. |
+| `canEmitLogs` | `boolean` | No | `false` | If `true`, the instance will emit events for every log action. |
+| `useLogColors` | `boolean` | No | `false` | Enables ANSI color codes. *Note: Automatically disabled in Firefox.* |
+
+---
+
+## ✨ Key Features
+
+### 🎨 Custom Colors
+You can inject colors into your log messages using the `_colorName_` syntax.
+*   **Syntax:** `_color_`
+*   **Example:** `debugger.log('info', 'This is _red_ critical error!');`
+
+### 🏷️ Custom Prefixes
+You can use placeholders to insert specific prefix text into your logs.
+*   **Syntax:** `:id:`
+*   **Example:** `debugger.log('info', ':info: System initialized.');`
+
+### 📡 Event Emission
+If `canEmitLogs` is set to `true`, `TinyDebugger` acts as an `EventEmitter`, allowing you to listen to specific debugging events. This is incredibly useful for building custom developer consoles in web applications.
+
+---
+
+## 📖 API Reference
+
+### `log(logType, message, ...args)`
+The primary method for logging.
+*   **logType:** `'log' | 'info' | 'warn' | 'error' | 'debug' | 'dirxml' | 'group' | 'groupCollapsed' | 'trace'`
+*   **message:** `string` (The text to display)
+*   **args:** `...any` (Additional data to inspect)
+
+### `logLabel(logType, label)`
+Logs a specific console type associated with a label.
+*   **logType:** `'count' | 'countReset' | 'time' | 'timeEnd' | 'profile' | 'profileEnd' | 'timeStamp'`
+*   **label:** `string`
+
+### `logTimeLabel(label, ...args)`
+Starts a timer with a specific label.
+*   **label:** `string`
+
+### `logAssert(condition, ...args)`
+Logs a message only if the provided condition evaluates to `false`.
+*   **condition:** `boolean`
+
+### `logDir(item, options)`
+Displays an element as a JavaScript object (similar to `console.dir`).
+*   **item:** `any`
+*   **options:** `InspectOptions`
+
+### `logTable(tabularData, properties)`
+Displays data in a clean, readable table.
+*   **tabularData:** `any`
+*   **properties:** `string[]` (Optional array of column properties)
+
+### `logClear()`
+Clears the console.
+### `logGroupEnd()`
+Ends the current console group.
+
+---
+
+## 🛠️ Advanced Customization
+
+You can dynamically modify the behavior of your debugger instance using these internal methods:
+
+| Method | Description |
+| :--- | :--- |
+| `_addLogColor(id, code)` | Adds a new color shortcut (e.g., `_mycolor_`). |
+| `_removeLogColor(id)` | Removes a color shortcut. |
+| `_addLogPrefix(id, text)` | Adds a new prefix shortcut (e.g., `:status:`). |
+| `_removeLogPrefix(id)` | Removes a prefix shortcut. |
+
+### Example: Adding a Custom Color
+```javascript
+debuggerInstance._addLogColor('gold', '\x1b[33m');
+debuggerInstance.log('info', 'This message is _gold_!');
+```
+
+---
+
+## ⚠️ Error Handling
+
+It will throw `TypeError` if:
+1.  The `logger` provided is not a valid object.
+2.  The `id` is not a string.
+3.  Configuration booleans are provided as other types.
+4.  An invalid `logType` is passed to the logging methods.

package/docs/v1/libs/TinyMediaPlayer.md

@@ -1,6 +1,6 @@
 # 🎧 TinyMediaPlayer Documentation
 
-`TinyMediaPlayer` is a robust, universal media player manager designed to orchestrate playback across multiple different media providers (such as YouTube, Spotify, etc.) using an **Adapter Pattern**.
+`TinyMediaPlayer` is a robust, universal media player manager designed to orchestrate playback across multiple different media providers (such as YouTube, Spotify, etc.) using an **Adapter Pattern**. It inherits debugging capabilities from `TinyDebugger`.
 
 ---
 
@@ -11,33 +11,31 @@ To support different media platforms, `TinyMediaPlayer` relies on **Adapters**.
 ### 🛠️ `BaseMediaAdapter` (Abstract Class)
 *This class cannot be instantiated directly. It serves as an interface that all specific API wrappers must extend and implement.*
 
-#### Properties
-| Property | Type | Description |
-| :--- | :--- | :--- |
-| `destroyed` | `boolean` | Indicates if the adapter instance has been destroyed. |
-
 #### Methods
 | Method | Description | Parameters | Returns |
 | :--- | :--- | :--- | :--- |
+| `static canHandle` | Determines if the adapter can play the provided content. | `content: MediaContent` | `boolean` |
 | `canHandle` | Determines if the adapter can play the provided content. | `content: MediaContent` | `boolean` |
 | `isReady` | Synchronously checks if the adapter is ready. | None | `boolean` |
+| `isPaused` | Checks whether the media adapter is paused. | None | `boolean` |
+| `isEnded` | Checks whether the media adapter is ended. | None | `boolean` |
 | `waitIsReady` | Asynchronously waits until the adapter is ready. | None | `Promise<void>` |
 | `play` | Starts or resumes playback of the provided content. | `content: MediaContent` | `Promise<void>` |
 | `pause` | Pauses the current playback. | None | `Promise<void>` |
-| `stop` | Stops the playback completely and resets the platform state. | None | `Promise<void>` |
+| `stop` | Stops the playback completely and resets the internal platform state. | None | `Promise<void>` |
 | `seek` | Seeks to a specific time in the media timeline. | `timeMs: number` | `Promise<void>` |
 | `isMuted` | Checks whether the player is currently muted. | None | `boolean \| null` |
 | `mute` | Mutes the current playback. | None | `Promise<void>` |
 | `unMute` | Unmutes the current playback. | None | `Promise<void>` |
-| `getCurrentTime` | Retrieves the current playback position. | None | `number` (ms) |
+| `getCurrentTime` | Retrieves the current playback time from the underlying API. | None | `number` (ms) |
 | `getTotalDuration` | Gets the total duration of the content. | None | `number` (ms) |
 | `getRemainingTime` | Gets the remaining time until the content ends. | None | `number` (ms) |
 | `getPlaybackPercentage` | Gets the percentage of the content that has been played. | None | `number` (0 to 100) |
 | `getTimeData` | Retrieves a consolidated object containing all time-related metrics. | None | `ContentTimeData` |
 | `setVolume` | Sets the playback volume for the underlying API. | `volume: number` (0.0 to 1.0) | `void` |
-| `getVolume` | Gets the current playback volume. | None | `number` (0.0 to 1.0) |
-| `getContentData` | Retrieves the metadata of the loaded content. | None | `Promise<ContentData>` |
-| `destroy` | Cleans up the instance and marks it as destroyed. | None | `void` |
+| `getVolume` | Gets the playback volume from the underlying API. | None | `number` (0.0 to 1.0) |
+| `getContentData` | Retrieves the metadata of the currently loaded content. | None | `Promise<ContentData>` |
+| `destroy` | Cleans up the instance. | None | `void` |
 
 ---
 
@@ -90,11 +88,6 @@ import { BaseMediaAdapter } from 'tiny-essentials/libs/TinyMediaPlayer/Base';
  * @extends BaseMediaAdapter
  */
 class MyCustomServiceAdapter extends BaseMediaAdapter {
-  /**
-   * Determines if this adapter can play the given content.
-   * @param {MediaContent} content - The media content to check.
-   * @returns {boolean} - True if the URL matches the service.
-   */
   static canHandle(content) {
     return content.url.startsWith('https://example.com/');
   }
@@ -116,6 +109,8 @@ class MyCustomServiceAdapter extends BaseMediaAdapter {
   async getContentData() { return {}; }
   async waitIsReady() {}
   isReady() { return true; }
+  isPaused() { return false; }
+  isEnded() { return false; }
   isMuted() { return false; }
   async mute() {}
   async unMute() {}
@@ -123,6 +118,7 @@ class MyCustomServiceAdapter extends BaseMediaAdapter {
   getRemainingTime() { return 0; }
   getPlaybackPercentage() { return 0; }
   getTimeData() { return {}; }
+  destroy() {}
 }
 
 // Registering the custom adapter
@@ -166,6 +162,9 @@ When initializing `new TinyMediaPlayer(options)`, you can pass the following `Ti
 * **`repeatCurrentOnPrev`** (`boolean`): If `true`, clicking 'previous' repeats the current track on the first click. (Default: `false`).
 * **`smoothPlayPauseVolume`** (`boolean`): If `true`, volume fades smoothly during play/pause transitions. (Default: `false`).
 * **`smoothStopVolume`** (`boolean`): If `true`, volume fades smoothly to zero when stopping. (Default: `false`).
+* **`debugMode`** (`boolean`): Whether to enable internal debug logging.
+* **`useLogColors`** (`boolean`): Whether to enable log color support.
+* **`logger`** (`Console`): A custom logger object.
 
 ---
 
@@ -204,7 +203,7 @@ When initializing `new TinyMediaPlayer(options)`, you can pass the following `Ti
 | `isRandom` | `boolean` | Enables or disables shuffle mode. |
 | `isPlaying` | `boolean` | Indicates if media is currently playing. |
 | `volume` | `number` | The current volume level (strictly between `0.0` and `1.0`). |
-| `isMuted` | `boolean` | Sets the mute state of the player. |
+| `isMuted` | `boolean` | Indicates if the player is currently muted. |
 
 #### 🎨 UX & Customization
 | Property | Type | Description |
@@ -253,7 +252,7 @@ When initializing `new TinyMediaPlayer(options)`, you can pass the following `Ti
 * **`existsTrack(index)`**: Returns `true` if the track exists at the given index.
 * **`getTrack(index)`**: Retrieves the track at the specified index.
 * **`removeTrack(index)`**: **(Async)** Removes a track and adjusts the current index/playback accordingly.
-* **`searchTrack(query)`**: Searches the playlist.
+* **`searchTrack(query)`**: Searches the playlist (string or function).
     * `query`: A `string` (searches title, artist, or album) or a `function` (custom logic).
     * **Returns**: `SearchResult[]` (array of objects containing the track and their corresponding indices).
 * **`clearPlaylist()`**: **(Async)** Stops playback and empties the entire playlist.
@@ -264,19 +263,24 @@ When initializing `new TinyMediaPlayer(options)`, you can pass the following `Ti
 * **`stop()`**: **(Async)** Stops the current track completely.
 * **`next()`**: **(Async)** Advances to the next track (respects `loopMode` and `isRandom`).
 * **`prev()`**: **(Async)** Returns to the previous track (respects `loopMode` and `isRandom`).
+* **`skipTo(index)`**: **(Async)** Jumps to a specific index in the playlist.
 * **`seek(timeMs)`**: **(Async)** Jumps to a specific millisecond in the current track.
 * **`step(stepMs)`**: **(Async)** Moves the timeline forward (+) or backward (-) by `stepMs`.
+* **`mute()`**: **(Async)** Mutes the current playback.
+* **`unMute()`**: **(Async)** Unmutes the current playback.
 
 #### ⏳ Time Utilities
 * **`getCurrentTime()`**: Gets the current playback time in milliseconds.
 * **`getTotalDuration()`**: Gets the total duration of the current track in milliseconds.
 * **`getRemainingTime()`**: Gets the remaining time until the current track ends in milliseconds.
 * **`getPlaybackPercentage()`**: Gets the percentage of the current track that has been played (0-100).
-* **`getContentData()`**: Retrieves structured metadata for the current content.
+* **`isPaused`**: **(Getter)** Checks if the adapter is paused.
+* **`isEnded`**: **(Getter)** Checks if the adapter has ended.
+* **`getContentData()`**: **(Async)** Retrieves structured metadata for the current content.
 * **`waitIsReady()`**: **(Async)** Waits until the active adapter is fully initialized.
 
 #### ♻️ Lifecycle
-* **`destroy()`**: **(Async)** Safely stops playback, clears state, removes adapters, and detaches all listeners to prevent memory leaks.
+* **`destroy()`**: **(Async)** Safely stops playback, clears state, removes adapters, and detaches all listeners.
 
 ---
 
@@ -318,6 +322,6 @@ When initializing `new TinyMediaPlayer(options)`, you can pass the following `Ti
 ## ⚠️ Error Handling
 
 The class uses strict validation. The following errors may be thrown:
-* **`TypeError`**: Thrown when an argument is of the wrong type (e.g., invalid index type, non-boolean options, invalid adapter instance, or empty storage key).
-* **`RangeError`**: Thrown when a number is out of allowed bounds (e.g., negative time, volume outside `0.0`-`1.0`, negative durations, or index out of playlist bounds).
+* **`TypeError`**: Thrown when an argument is of the wrong type.
+* **`RangeError`**: Thrown when a number is out of allowed bounds.
 * **`Error`**: Thrown if no compatible adapter is found for the current content.

package/docs/v1/libs/TinyRadioFm.md

@@ -31,7 +31,9 @@ The behavior of the engine is controlled via the `RadioConfig` object.
 | `voiceAfterMusic` | `boolean` | `true` | If `true`, voice messages play after music tracks. |
 | `voiceMin` | `number` | `0` | Minimum number of voice messages to play in a cycle. |
 | `voiceMax` | `number` | `1` | Maximum number of voice messages to play in a cycle. |
+| `musicMinConsecutive`| `number` | `0` | Min times a music track must repeat consecutively. |
 | `musicMaxConsecutive`| `number` | `0` | Max consecutive music repeats (`-1` = unlimited, `0` = no repeats). |
+| `voiceMinConsecutive`| `number` | `0` | Min times a voice track must repeat consecutively. |
 | `voiceMaxConsecutive`| `number` | `0` | Max consecutive voice repeats (`-1` = unlimited, `0` = no repeats). |
 
 ---
@@ -60,7 +62,7 @@ Adds new content to the engine immediately.
 * **Parameters:**
     * `type`: `'music' | 'voice' | 'custom'`.
     * `data`: The `MediaContent` object (must include `id` and `duration`).
-    * `smartQueue`: If `true`, delays insertion until the current content ends (primarily for `custom`).
+    * `smartQueue`: If `true`, delays insertion until the end of the content playing at that timestamp (primarily for `custom`).
 * **Emits:** `contentAdded`
 
 #### `remove(id)`
@@ -108,7 +110,7 @@ Predicts upcoming events from a specific date forward using a virtual sandbox to
 ### 💾 Persistence & Lifecycle
 
 #### `async exportState()`
-Exports the entire radio state (playlists, tasks, seed, config) as a JSON string. Automatically converts all image Blob URLs to **Base64** for portability.
+Exports the entire radio state (playlists, tasks, seed, config) as a JSON string. Automatically converts all image Blob URLs to **Base64** for easy storage.
 * **Returns:** `Promise<string>`
 
 #### `importState(json)`
@@ -138,4 +140,24 @@ An instruction to change the radio state.
 * `timestamp`: Execution time.
 * `action`: `'add' | 'remove' | 'move'`.
 * `type`: `'music' | 'voice'`.
-* `payload`: Action-specific data.
+* `payload`: Action-specific data (`MediaContent`, `string`, or `ScheduledMovePayload`).
+
+### `CustomPosition` 📍
+Represents content injected at a specific absolute timestamp.
+* `content`: The `MediaContent` object.
+* `intendedTimestamp`: The target absolute timestamp.
+* `originalTimestamp`: The timestamp preserved for intelligent repositioning.
+
+### `ScheduledMovePayload` 🚚
+Data required to relocate an existing item within a playlist.
+* `id`: Content ID to move.
+* `newIndex`: The target index in the playlist.
+
+### `CycleBlock` 🔄
+A structural block representing a single full iteration of the radio sequence.
+* `items`: Items belonging to this cycle.
+* `duration`: Total duration of the cycle block in ms.
+* `lastMusicId`: ID of the last music played in this block.
+* `musicConsecutiveCount`: Current consecutive count for music.
+* `lastVoiceId`: ID of the last voice played in this block.
+* `voiceConsecutiveCount`: Current consecutive count for voice.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-essentials",
-  "version": "1.28.7",
+  "version": "1.28.9",
   "description": "Collection of small, essential scripts designed to be used across various projects. These simple utilities are crafted for speed, ease of use, and versatility.",
   "bin": {
     "tiny-essentials-fork": "./TinyFork.mjs"
@@ -112,6 +112,10 @@
       "require": "./dist/v1/basics/promiseUtils.cjs",
       "import": "./dist/v1/basics/promiseUtils.mjs"
     },
+    "./basics/browserDetector": {
+      "require": "./dist/v1/basics/browserDetector.cjs",
+      "import": "./dist/v1/basics/browserDetector.mjs"
+    },
     "./fileManager": {
       "require": "./dist/v1/fileManager/index.cjs",
       "import": "./dist/v1/fileManager/index.mjs"
@@ -156,6 +160,10 @@
       "require": "./dist/v1/libs/TinyMediaPlayer/HtmlVideo.cjs",
       "import": "./dist/v1/libs/TinyMediaPlayer/HtmlVideo.mjs"
     },
+    "./libs/TinyMediaPlayer/Mock": {
+      "require": "./dist/v1/libs/TinyMediaPlayer/Mock.cjs",
+      "import": "./dist/v1/libs/TinyMediaPlayer/Mock.mjs"
+    },
     "./libs/TinyMediaPlayer/docs/YouTubePlayer": {
       "require": "./dist/v1/libs/TinyMediaPlayer/docs/YouTubePlayer.cjs",
       "import": "./dist/v1/libs/TinyMediaPlayer/docs/YouTubePlayer.mjs"
@@ -168,6 +176,10 @@
       "require": "./dist/v1/libs/TinyRadioFm.cjs",
       "import": "./dist/v1/libs/TinyRadioFm.mjs"
     },
+    "./libs/TinyDebugger": {
+      "require": "./dist/v1/libs/TinyDebugger.cjs",
+      "import": "./dist/v1/libs/TinyDebugger.mjs"
+    },
     "./libs/UltraRandomMsgGen": {
       "require": "./dist/v1/libs/UltraRandomMsgGen.cjs",
       "import": "./dist/v1/libs/UltraRandomMsgGen.mjs"