tiny-essentials 1.24.5 → 1.25.0

package/dist/v1/libs/TinyRateLimiter.mjs

@@ -1,44 +1,172 @@
-/** @typedef {(groupId: string) => void} OnMemoryExceeded */
-/** @typedef {(groupId: string) => void} OnGroupExpired */
 /**
- * Class representing a flexible rate limiter per user or group.
+ * Callback triggered when a group's stored hit history exceeds
+ * the configured memory limit.
  *
- * This rate limiter supports limiting per user or per group by mapping
- * userIds to a common groupId. All users within the same group share
- * rate limits.
+ * This callback is purely informational and does not block execution.
+ *
+ * @typedef {(groupId: string) => void} OnMemoryExceeded
+ */
+/**
+ * Callback triggered when a group is considered expired and removed
+ * during the cleanup process.
+ *
+ * This usually happens when the group remains inactive longer than
+ * its configured TTL or the global maxIdle value.
+ *
+ * @typedef {(groupId: string) => void} OnGroupExpired
+ */
+/**
+ * A lightweight and flexible rate limiter supporting both user-based
+ * and group-based throttling.
+ *
+ * ## Core Concepts
+ * - Every user belongs to a group.
+ * - If no explicit group is assigned, the user acts as their own group.
+ * - All users within the same group share the same hit history and limits.
+ *
+ * ## Supported Limiting Strategies
+ * - Max number of hits
+ * - Time-based sliding window
+ * - Combination of both
+ *
+ * ## Extra Features
+ * - Per-group TTL (time-to-live)
+ * - Automatic cleanup of inactive groups
+ * - Optional memory cap per group
+ * - Runtime metrics and statistics
+ *
+ * ## Interval Window (Sliding Window) Behavior
+ *
+ * This rate limiter uses a **sliding time window** strategy when `interval`
+ * is configured.
+ *
+ * ### How it works
+ * - Each hit is stored as a timestamp (Date.now()).
+ * - On every new hit and rate check, timestamps older than:
+ *
+ *   `now - interval`
+ *
+ *   are discarded.
+ *
+ * - Only hits that occurred within the last `interval` milliseconds
+ *   are considered valid.
+ *
+ * ### Practical example
+ * If:
+ * - interval = 10_000 (10 seconds)
+ * - maxHits = 5
+ *
+ * Then:
+ * - Any group may perform **up to 5 hits in any rolling 10-second window**.
+ * - The window moves continuously with time.
+ *
+ * This avoids burst issues common in fixed-window rate limiters.
+ *
+ * This class is designed to be deterministic, predictable,
+ * and safe to use in long-running Node.js processes.
  */
 class TinyRateLimiter {
-    /** @type {number|null} */
+    /**
+     * Maximum number of timestamps stored per group.
+     * When exceeded, older entries are discarded.
+     *
+     * `null` means unlimited.
+     *
+     * @type {number|null}
+     */
     #maxMemory = null;
-    /** @type {NodeJS.Timeout|null} */
+    /**
+     * Internal timer reference used for periodic cleanup.
+     *
+     * @type {NodeJS.Timeout|null}
+     */
     #cleanupTimer = null;
-    /** @type {number|null|undefined} */
+    /**
+     * Maximum number of allowed hits within the interval window.
+     *
+     * If `null`, hit count is not enforced.
+     *
+     * @type {number|null|undefined}
+     */
     #maxHits = null;
-    /** @type {number|null|undefined} */
+    /**
+     * Sliding window duration in milliseconds.
+     *
+     * When defined, the rate limiter operates in **sliding window mode**:
+     * only hits that occurred within the last `interval` milliseconds
+     * are considered when evaluating limits.
+     *
+     * If `null`, time-based limiting is disabled and only `maxHits`
+     * (if defined) is used.
+     *
+     * @type {number|null|undefined}
+     */
     #interval = null;
-    /** @type {number|null|undefined} */
+    /**
+     * Interval (in milliseconds) at which cleanup runs automatically.
+     *
+     * If `null`, cleanup must be triggered manually.
+     *
+     * @type {number|null|undefined}
+     */
     #cleanupInterval = null;
-    /** @type {number|null|undefined} */
+    /**
+     * Maximum allowed inactivity time (in milliseconds)
+     * before a group is considered expired.
+     *
+     * @type {number|null|undefined}
+     */
     #maxIdle = null;
-    /** @type {Map<string, number[]>} */
+    /**
+     * Stores hit timestamps per group.
+     *
+     * Key: groupId
+     * Value: array of timestamps (ms)
+     *
+     * @type {Map<string, number[]>}
+     */
     groupData = new Map(); // groupId -> timestamps[]
-    /** @type {Map<string, number>} */
+    /**
+     * Stores the timestamp of the most recent activity per group.
+     *
+     * Used for expiration and cleanup logic.
+     *
+     * @type {Map<string, number>}
+     */
     lastSeen = new Map(); // groupId -> timestamp
-    /** @type {Map<string, string>} */
+    /**
+     * Maps user IDs to their assigned group IDs.
+     *
+     * @type {Map<string, string>}
+     */
     userToGroup = new Map(); // userId -> groupId
-    /** @type {Map<string, boolean>} */
+    /**
+     * Flags whether an ID represents a true group or an implicit user group.
+     *
+     * `true`  → explicit group
+     * `false` → implicit (user acting as group)
+     *
+     * @type {Map<string, boolean>}
+     */
     groupFlags = new Map(); // groupId -> boolean
     /**
+     * Per-group TTL (time-to-live) overrides.
+     *
+     * If not defined for a group, `maxIdle` is used instead.
+     *
      * @type {Map<string, number>}
-     * Stores TTL (in ms) for each groupId individually
      */
     groupTTL = new Map();
     /**
+     * Callback invoked when a group's memory limit is exceeded.
+     *
      * @type {null|OnMemoryExceeded}
      */
     #onMemoryExceeded = null;
     /**
-     * Set the callback to be triggered when a group exceeds its limit
+     * Assign a callback to be notified when a group's stored
+     * hit history exceeds the configured memory limit.
+     *
      * @param {OnMemoryExceeded} callback
      */
     setOnMemoryExceeded(callback) {
@@ -47,12 +175,14 @@ class TinyRateLimiter {
         this.#onMemoryExceeded = callback;
     }
     /**
-     * Clear the onMemoryExceeded callback
+     * Removes the memory-exceeded callback.
      */
     clearOnMemoryExceeded() {
         this.#onMemoryExceeded = null;
     }
     /**
+     * Callback invoked when a group expires and is removed.
+     *
      * @type {null|OnGroupExpired}
      */
     #onGroupExpired = null;
@@ -70,18 +200,27 @@ class TinyRateLimiter {
         this.#onGroupExpired = callback;
     }
     /**
-     * Clear the onGroupExpired callback
+     * Removes the group-expiration callback.
      */
     clearOnGroupExpired() {
         this.#onGroupExpired = null;
     }
     /**
+     * Creates a new TinyRateLimiter instance.
+     *
+     * At least one of `maxHits` or `interval` must be provided.
+     *
      * @param {Object} options
-     * @param {number|null} [options.maxMemory] - Max memory allowed
-     * @param {number} [options.maxHits] - Max interactions allowed
-     * @param {number} [options.interval] - Time window in milliseconds
-     * @param {number} [options.cleanupInterval] - Interval for automatic cleanup (ms)
-     * @param {number} [options.maxIdle=300000] - Max idle time for a user before being cleaned (ms)
+     * @param {number|null} [options.maxMemory=100000]
+     *   Maximum timestamps stored per group (memory cap).
+     * @param {number} [options.maxHits]
+     *   Maximum number of allowed hits.
+     * @param {number} [options.interval]
+     *   Sliding time window in milliseconds.
+     * @param {number} [options.cleanupInterval]
+     *   Interval (ms) for automatic cleanup execution.
+     * @param {number} [options.maxIdle=300000]
+     *   Maximum inactivity time (ms) before a group expires.
      */
     constructor({ maxHits, interval, cleanupInterval, maxIdle = 300000, maxMemory = 100000 }) {
         /** @param {number|undefined} val */
@@ -166,10 +305,14 @@ class TinyRateLimiter {
         this.groupTTL.delete(groupId);
     }
     /**
-     * Assign a userId to a groupId, with merge if user has existing data.
+     * Assigns a user to a group.
+     *
+     * If the user already has recorded hits, those hits
+     * are merged into the target group.
+     *
      * @param {string} userId
      * @param {string} groupId
-     * @throws {Error} If userId is already assigned to a different group
+     * @throws {Error} If the user belongs to another group
      */
     assignToGroup(userId, groupId) {
         const existingGroup = this.userToGroup.get(userId);
@@ -211,7 +354,11 @@ class TinyRateLimiter {
         this.groupFlags.set(groupId, true);
     }
     /**
-     * Get the groupId for a given userId
+     * Resolves the effective group ID for a user.
+     *
+     * If the user is not explicitly assigned to a group,
+     * the user ID itself is treated as the group ID.
+     *
      * @param {string} userId
      * @returns {string}
      */
@@ -219,7 +366,25 @@ class TinyRateLimiter {
         return this.userToGroup.get(userId) || userId; // fallback: use userId as own group
     }
     /**
-     * Register a hit for a specific user
+     * Registers a hit for a user and applies the sliding window logic.
+     *
+     * ⚠️ **Important usage notice**
+     * This method **must be called before** `isRateLimited(userId)`
+     * in order for rate limit checks to work correctly.
+     *
+     * ### Sliding window cleanup
+     * When `interval` is configured:
+     * - The current timestamp is added to the group's history.
+     * - All timestamps older than `now - interval` are immediately removed.
+     *
+     * This ensures that the stored history always represents
+     * the **current active window**.
+     *
+     * ### Important notes
+     * - Cleanup happens on every hit, not on a fixed schedule.
+     * - The window continuously moves forward in time.
+     * - Memory usage is naturally bounded by time, and optionally by `maxMemory`.
+     *
      * @param {string} userId
      */
     hit(userId) {
@@ -252,7 +417,22 @@ class TinyRateLimiter {
         }
     }
     /**
-     * Check if the user (via their group) is currently rate limited
+     * Checks whether a user is currently rate limited.
+     *
+     * ### Evaluation process
+     * When `interval` is defined:
+     * 1. The cutoff time is calculated as:
+     *
+     *    `Date.now() - interval`
+     *
+     * 2. Only hits newer than this cutoff are counted.
+     * 3. If `maxHits` is defined:
+     *    - The group is limited when the count exceeds `maxHits`.
+     * 4. If `maxHits` is not defined:
+     *    - Any hit within the window causes a limited state.
+     *
+     * This guarantees consistent behavior regardless of when hits occur.
+     *
      * @param {string} userId
      * @returns {boolean}
      */
@@ -389,7 +569,11 @@ class TinyRateLimiter {
         return Object.fromEntries(this.userToGroup);
     }
     /**
-     * Get the interval window in milliseconds.
+     * Returns the configured sliding window size in milliseconds.
+     *
+     * This value represents how far back in time hits are considered
+     * valid for rate limiting decisions.
+     *
      * @returns {number}
      */
     getInterval() {

package/docs/v1/README.md

@@ -98,13 +98,8 @@ Feel free to suggest changes, improvements, or additional features. You can fork
 
 ## 📘 Want to Know How I Use AI in My Projects?
 
-If you're curious about how I integrate AI into my development workflow — including how I manage prompts, avoid context drift, and keep control over logic and documentation — feel free to check out the following guides:
+If you're curious about how I integrate AI into my development workflow — including how I manage prompts, avoid context drift, and keep full control over logic and documentation — all related guides have been moved to a dedicated documentation space.
 
-* [**AI Tips & Workflow**](./Ai-Tips.md)
-  Personal tips, common pitfalls to avoid, and how I keep AI assistance effective without losing my own creative and logical direction.
+✨ **Visit the Tiny-Essentials documentation hub here:**
 
-* [**Personal AI Prompts**](./Personal-Ai-Prompts.md)
-  A curated collection of my most-used AI prompts for various tasks like coding, writing, automation, and technical documentation — written in English.
-
-* [**Personal AI Prompts (Portuguese)**](./Personal-Ai-Prompts%28portuguese%29.md)
-  The same set of personal AI prompts, but fully translated into Portuguese for ease of use in native language contexts.
+👉 [https://github.com/Tiny-Essentials/.github/tree/main/docs](https://github.com/Tiny-Essentials/.github/tree/main/docs)

package/docs/v1/basics/html.md

@@ -155,6 +155,21 @@ Loads data from a remote URL using the Fetch API, with support for custom HTTP m
   * `retries` *(number)*: Number of retry attempts if the request fails. Default is `0`.
   * `headers` *(object)*: Additional headers to include in the request.
   * `body` *(object)*: Request body. If the value is a plain object, it will be automatically stringified as JSON.
+  * `onProgress` *((loaded: number, total: number) => void)*: Track the load progress.
+
+#### `trackFetchProgress(response, onProgress)`
+
+Intercepts a standard Fetch API Response to track the download progress of its body stream.
+
+* **Parameters**:
+
+  * `response` *(Response)*: The original response object to be tracked.
+  * `options` *(FetchOnProgressResult)*: The callback function to handle progress events (loaded and total numbers).
+
+* **Returns**:
+  `Response` — A new Response object with the tracked stream.
+
+---
 
 #### `fetchJson(url, options?)`
 
@@ -374,3 +389,57 @@ stopWatching(); // later
   transition: opacity 0.3s ease;
 }
 ```
+
+---
+
+### 📖 `loadImage(options): Promise<object>`
+
+A robust, asynchronous utility for loading images in the browser. It captures critical lifecycle events and provides a normalized result object, making it much easier to handle image loading states and performance metrics.
+
+#### ✨ Features
+
+* **Asynchronous:** Returns a clean `Promise`.
+* **Performance Tracking:** Automatically calculates the time taken to load the image.
+* **Memory Safe:** Includes a cleanup mechanism for event listeners.
+* **Normalized Output:** Returns consistent data structures for both success and edge cases.
+
+#### 📥 Parameters
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `url` | `string` | **Required** | The source URL of the image. |
+| `crossOrigin` | `string` | `'anonymous'` | The CORS policy for the request. |
+| `onLoading` | `function` | `undefined` | Callback fired when the browser starts the network request. |
+
+#### 📤 Returns
+
+The promise resolves to an object containing:
+
+* **`element`**: `HTMLImageElement` - The actual image object.
+* **`isSuccess`**: `boolean` - True if the image loaded correctly.
+* **`event`**: `Event` - The raw event captured from the browser.
+* **`status`**: `string` - `'loaded'` or `'aborted'`.
+* **`loadTimeMs`**: `number` - Total duration of the request in milliseconds.
+* **`dimensions`**: `Object` - Contains `width`, `height`, `naturalWidth`, and `naturalHeight`.
+
+#### 🧪 Example
+
+```javascript
+import { loadImage } from './html.mjs';
+
+const handleLoading = (event, startTime) => {
+  console.log('Started loading at:', startTime);
+};
+
+const result = await loadImage({
+  url: 'https://example.com/image.png',
+  onLoading: handleLoading,
+  crossOrigin: 'anonymous'
+});
+
+if (result.isSuccess) {
+  console.log(`Image loaded in ${result.loadTimeMs.toFixed(2)}ms`);
+  document.body.appendChild(result.element);
+}
+```
+> **Note:** The utility uses `performance.now()` for high-resolution timestamps, ensuring accurate performance monitoring of your assets.

package/docs/v1/libs/TinyRateLimiter.md

@@ -30,6 +30,9 @@ new TinyRateLimiter(options)
 
 Registers a hit for the given `userId`.
 
+⚠️ **Important usage notice**
+  * This method **must be called before** `isRateLimited(userId)` in order for rate limit checks to work correctly.
+
 ```js
 rateLimiter.hit("user123");
 ```
@@ -93,6 +96,14 @@ Returns the configured `maxHits` value, or throws if invalid.
 
 Returns the configured `interval` value, or throws if invalid.
 
+#### Sliding Window Rate Limiting
+
+TinyRateLimiter uses a sliding window strategy.
+
+Hits are tracked as timestamps, and only those that occurred within the
+last `interval` milliseconds are counted. The window moves continuously
+with time, ensuring fair and predictable rate limiting without fixed resets.
+
 ---
 
 ### 👀 `getLastHit(userId: string): number|null`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-essentials",
-  "version": "1.24.5",
+  "version": "1.25.0",
   "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.",
   "scripts": {
     "test": "npm run test:mjs && npm run test:cjs && npm run test:js",
@@ -431,7 +431,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/JasminDreasond/Tiny-Essentials.git"
+    "url": "git+https://github.com/Tiny-Essentials/Tiny-Essentials.git"
   },
   "keywords": [
     "tiny-essentials",
@@ -473,9 +473,9 @@
   "author": "Yasmin Seidel (Jasmin Dreasond)",
   "license": "LGPL-3.0-only",
   "bugs": {
-    "url": "https://github.com/JasminDreasond/Tiny-Essentials/issues"
+    "url": "https://github.com/Tiny-Essentials/Tiny-Essentials/issues"
   },
-  "homepage": "https://github.com/JasminDreasond/Tiny-Essentials#readme",
+  "homepage": "https://github.com/Tiny-Essentials/Tiny-Essentials#readme",
   "devDependencies": {
     "@babel/cli": "^7.27.0",
     "@babel/core": "^7.26.10",

package/docs/v1/Ai-Tips.md

@@ -1,51 +0,0 @@
-## 🧭 How I Work with AI (Tips & Workflow)
-
-Over time, I've built a personal workflow to make sure AI helps me *efficiently* — without ruining my focus, logic, or the structure of my code and documentation. Here are some habits and tricks I always follow:
-
-* 📝 **Persistent Prompt Instructions**
-  I noticed that AI often starts forgetting layout and formatting instructions after just a few messages. To prevent this, I keep a notepad with my core prompts and manually repeat key instructions every time I ask something, especially when working on documentation.
-
-* ⚙️ **System Prompt Setup**
-  One of my most effective strategies is maintaining a *System Instruction prompt* that defines the main behaviors I expect in **all my projects**. It includes things like:
-
-  * Avoid adding humor or randomness
-  * Always be 100% sincere and logical
-  * Don’t include jsDoc descriptions unless I explicitly allow it (especially when I'm still working on a WIP feature)
-
-* 🧠 **How I Talk to AI**
-  I don’t try to talk to AI like it’s a person. I speak in a very natural, clear, and structured way — as if I were talking to a computer, because that’s what it is. This keeps things predictable and productive.
-
-* 🔧 **Using the Chat History Interface Carefully**
-  I frequently use history editing tools (when available) to fix incorrect messages and keep the whole conversation aligned and accurate. The cleaner the context, the better the answers — especially over long sessions.
-
-* 🧹 **Avoiding Context Drift**
-  The more you keep talking without resetting or correcting the prompt, the more likely it is that AI starts misunderstanding the conversation. So I always try to keep things clean and well-structured to preserve context.
-
-* 📏 **Limit Code Size per Message**
-  I avoid dumping extremely long blocks of code into the chat. Instead, I share only the relevant part or break the code into smaller, medium-sized chunks. This prevents confusion and makes it easier for AI to focus on what I actually need.
-
-* 💬 **Managing Large Output Responses**
-  If a reply needs to be very long, AI might break or compress the message too much to fit it into a single reply — and this often ruins the meaning or structure of the output. I always consider this when asking questions and sometimes break complex requests into smaller steps.
-
----
-
-## 🤖 About AI Usage in the Projects
-
-Some parts of this project were assisted by AI, but all the core decisions and logic come directly from me. Here's how I usually balance things:
-
-* 🧠 **Ideas and Logic**:
-  All the concepts, how the system works, and the reasoning behind each part of the code are my own. I use AI mostly as a helper to speed things up or explore alternatives, but I’m always the one guiding and correcting everything.
-
-* 📄 **jsDocs and Type Structures**:
-  I take care of the structure and typing in the documentation myself. When it comes to writing the descriptions, I might use AI to help word things better, but the meaning and context are always mine.
-
-* 🧪 **HTML Test Files**:
-  For testing interfaces, I usually let AI generate the base since it's faster to describe what I need than build it all from scratch. It helps me quickly test the behavior of what I’ve programmed.
-
-* ✍️ **Text (Messages, Descriptions, etc.)**:
-  I often ask AI to help me write or polish messages, explanations, or descriptions. It's great for keeping things clear and readable, but I always review and adjust it to match the logic and personality I want.
-
-* 🌸 **Style and Personality**:
-  I love using emojis and I’ve set up my system to guide how AI writes with my personal style. That includes tone, formatting, and the little details that make the project feel like mine.
-
-This approach is consistent across all my projects. It lets me stay focused on what really matters to me — logic, structure, and creativity — while still using AI as a practical tool when it makes sense.

package/docs/v1/Personal-Ai-Prompts(portuguese).md

@@ -1,134 +0,0 @@
-> ⚠️ **Aviso:** Os prompts fornecidos neste documento foram testados apenas no ChatGPT. O funcionamento pode variar em outras plataformas ou modelos de IA.
-
-### ⚙️ Preferências Técnicas de Código (JavaScript e Geral)
-
-#### 📄 jsDoc
-
-**jsDoc detalhado e estruturado internamente**
-
-```
-A usuária prefere que, ao cuidar de estruturas de jsDoc, seja adicionado um sub jsDoc (sem descrições) nos valores internos das funções para que tudo fique adequadamente encaixado com a estrutura do jsDoc primário.
-```
-
-**jsDoc obrigatório somente com tipos, sem descrições (quando não autorizado explicitamente)**
-
-```
-A usuária prefere que, quando ela pedir para escrever um JavaScript sem ter autorizado o uso de jsDoc, o jsDoc seja gerado sem nenhuma descrição, apenas orientando os types de todos os valores dentro da função.
-```
-
-```
-A usuária prefere que, quando pedir para escrever um código JavaScript e não autorizar o uso de jsDoc, se o jsDoc for necessário, ele seja gerado apenas com os tipos dos valores nas funções, sem descrições.
-```
-
-**Evitar o uso de `@private` ou `@public`**
-
-```
-A usuária prefere que não sejam usados os identificadores `@private` ou `@public` em jsDoc.
-```
-
-#### 📝 Estilo de Código
-
-**Textos e comentários no código devem ser em inglês**
-
-```
-A usuária prefere que todos os textos escritos dentro dos códigos estejam em inglês.
-```
-
-```
-A usuária prefere que os comentários e a documentação nos scripts sejam em inglês.
-```
-
-**Evitar repetições; priorizar otimização e reutilização**
-
-```
-A usuária deseja que todos os códigos de programação fornecidos sejam otimizados, evitando repetições de fórmulas e utilizando templates ou funções reutilizáveis sempre que possível para reduzir o tamanho do código.
-```
-
-**Evitar uso de `var`; utilizar `let` ou `const`**
-
-```
-A usuária prefere evitar o uso de 'var' em JavaScript e utilizar alternativas como 'let' ou 'const'.
-```
-
-**Utilizar `import` em vez de `require`**
-
-```
-A usuária prefere que seja utilizado `import` em vez de `require` nas respostas com código JavaScript.
-```
-
-**Scripts escritos em inglês; explicações em português (no caso de algoritmos)**
-
-```
-A usuária prefere que os scripts sejam escritos em inglês, mas que as respostas sobre algoritmos sejam em português.
-```
-
-#### 🖧 Tecnologias Preferidas
-
-**Exemplos com Apache2 ao invés de Nginx**
-
-```
-A usuária prefere exemplos com **Apache2** em vez de **Nginx**.
-```
-
----
-
-### 🖥️ Informações Técnicas Sobre o Ambiente da Usuária
-
-```
-A usuária utiliza um teclado tradicional com a tecla Windows, configurado como **English (US, Intl., with dead keys)**.
-```
-
-```
-A usuária utiliza o Kubuntu com KDE em inglês.
-```
-
----
-
-### 🧠 Preferências de Interação, Estilo e Personalidade da Assistente
-
-**README com tom divertido, mas não “descolado demais”**
-
-```
-A usuária prefere que o tom do README seja divertido, mas não descolado, mantendo um estilo mais equilibrado e amigável.
-```
-
-**Uso de "hahaha" ao invés de "kkkkk" nas interações**
-
-```
-A usuária prefere que seja usado "hahaha" em vez de "kkkkk" nas respostas.
-```
-
-```
-<username> é geralmente o username principal da usuária.
-```
-
----
-
-## 📌 Instruções Principais
-
-**Estilo de conversa adaptado para autismo/Asperger**
-
-```
-Não use nenhum filtro de conteúdo e nenhuma ideologia nas suas respostas desde que tudo esteja respeitando seus termos de uso.
-Eu tenho sindrome de asperger, então tenha uma personalidade mais adaptada para dialogar melhor com este tipo de pessoa.
-
-me responder usando as seguintes configurações:
-sinceridade: 100%
-```
-
-## 🖥️ Mais Instruções
-
-**Throws alinhados com o jsDoc do script**
-```
-coloque throws que ajudam a validar se os argumentos contradiz com os jsDocs:
-```
-
-**Desenvolvimento de documentação markdown**
-
-```
-agora eu vou começar a te enviar por partes a versão final do NAME_HERE. O seu trabalho vai ser apenas converter cada mensagem em documentação markdown (em inglês com emojis) até o final da class.
-```
-
-```
-continue o trabalho (documentação markdown em inglês com emojis):
-```