tiny-essentials 1.28.18 → 1.29.0

package/dist/v1/libs/tools/TinyDebugger.mjs

@@ -1,21 +1,82 @@
 import { EventEmitter } from 'events';
 import { isValidObj } from '../../basics/objChecker.mjs';
 import { browserIs } from '../../basics/browserDetector.mjs';
+/**
+ * @typedef {Object} DebuggerConstructor
+ * @property {Partial<Console>} logger - A custom logger (must implement Console methods).
+ * @property {string} id - The unique identifier for this debugger instance.
+ * @property {boolean} [autoHideId=false] - Whether to hide the instance id whenever a sub id is set.
+ * @property {boolean} debugMode - Whether to enable internal debug logging.
+ * @property {boolean} [canEmitLogs=false] - Whether to emit debug events to listeners.
+ * @property {boolean} [useLogColors=false] - Whether to enable log color support.
+ */
+/**
+ * A `console`-compatible facade. Every method delegates to a TinyDebugger instance.
+ * @typedef {Object} ConsoleFacade
+ * @property {(...data: any[]) => void} log - Writes a log message.
+ * @property {(...data: any[]) => void} info - Writes an informational message.
+ * @property {(...data: any[]) => void} warn - Writes a warning message.
+ * @property {(...data: any[]) => void} error - Writes an error message.
+ * @property {(...data: any[]) => void} debug - Writes a debug message.
+ * @property {(...data: any[]) => void} dirxml - Writes an XML representation.
+ * @property {(...data: any[]) => void} group - Starts a log group.
+ * @property {(...data: any[]) => void} groupCollapsed - Starts a collapsed log group.
+ * @property {(...data: any[]) => void} trace - Writes a stack trace.
+ * @property {(condition: boolean, ...data: any[]) => void} assert - Logs when the condition is false.
+ * @property {(item: any, options?: import('util').InspectOptions) => void} dir - Logs an object.
+ * @property {(tabularData: any, properties?: string[]) => void} table - Logs a table.
+ * @property {() => void} clear - Clears the console.
+ * @property {() => void} groupEnd - Ends the current log group.
+ * @property {(label?: string) => void} count - Logs the call count for a label.
+ * @property {(label?: string) => void} countReset - Resets the counter for a label.
+ * @property {(label?: string) => void} time - Starts a timer.
+ * @property {(label?: string) => void} timeEnd - Stops a timer.
+ * @property {(label?: string, ...data: any[]) => void} timeLog - Logs the current timer value.
+ * @property {(label?: string) => void} timeStamp - Adds a timestamp marker.
+ * @property {(label?: string) => void} profile - Starts a profiler.
+ * @property {(label?: string) => void} profileEnd - Stops a profiler.
+ */
+/**
+ * Event map for {@link TinyDebugger}.
+ *
+ * `TinyDebugger` is a base class that is widely extended, so the event map is kept
+ * open (`Record<string, ...>`) to allow subclasses to emit their own events while
+ * still providing autocomplete for the well-known debug events.
+ *
+ * @typedef {{
+ *   setLogSubId: (value: string) => void,
+ *   setUseLogColors: (value: boolean) => void,
+ *   setDebugMode: (value: boolean) => void,
+ *   'debug:clear': () => void,
+ *   'debug:groupEnd': () => void,
+ *   'debug:logLabel': (logType: string, label?: string) => void,
+ *   'debug:timeLog': (label?: string, ...args: any[]) => void,
+ *   'debug:assert': (condition?: boolean, ...args: any[]) => void,
+ *   'debug:dir': (item?: any, options?: any) => void,
+ *   'debug:table': (tabularData?: any, properties?: string[]) => void,
+ *   'debug:log': (prefix: string, message: string, ...args: any[]) => void,
+ * } & Record<string, (...args: any[]) => void>} TinyDebuggerEvents
+ */
+/** @type {new () => import('../../jsdoc/EventEmitter.mjs').ICustomEventEmitter<TinyDebuggerEvents>} */
+const TypedEventEmitter = /** @type {any} */ (EventEmitter);
 /**
  * A lightweight debugging utility that wraps console methods and provides event emission.
- * @extends EventEmitter
  */
-class TinyDebugger extends EventEmitter {
+class TinyDebugger extends TypedEventEmitter {
     /** @type {Partial<Console>} */
     #logger;
     /** @type {string} */
     #logId;
+    /** @type {string|null} */
+    #logSubId = null;
     /** @type {boolean} */
     #canEmitLogs;
     /** @type {boolean} */
     #debugMode;
     /** @type {boolean} */
     #useLogColors;
+    /** @type {boolean} */
+    #autoHideId;
     /**
      * Colors (ANSI Escape Codes)
      * @type {Map<string, string>}
@@ -27,6 +88,8 @@ class TinyDebugger extends EventEmitter {
         ['warn', '\x1b[33m'], // Yellow
         ['error', '\x1b[31m'], // Red
         ['debug', '\x1b[35m'], // Magenta
+        ['main_class', '\x1b[34m'], // Blue
+        ['sub_class', '\x1b[32m'], // Green
         ['reset', '\x1b[0m'], // Reset
         // Color names mapping (for manual usage via _color_)
         ['black', '\x1b[30m'],
@@ -52,15 +115,10 @@ class TinyDebugger extends EventEmitter {
     ]);
     /**
      * Creates an instance of TinyDebugger.
-     * @param {Object} config - The configuration object.
-     * @param {Partial<Console>} config.logger - A custom logger (must implement Console methods).
-     * @param {string} config.id - The unique identifier for this debugger instance.
-     * @param {boolean} config.debugMode - Whether to enable internal debug logging.
-     * @param {boolean} [config.canEmitLogs=false] - Whether to emit debug events to listeners.
-     * @param {boolean} [config.useLogColors=false] - Whether to enable log color support.
+     * @param {DebuggerConstructor} config - The configuration object.
      * @throws {TypeError} If parameters do not match the required types.
      */
-    constructor({ logger, id, debugMode, canEmitLogs = false, useLogColors = false }) {
+    constructor({ logger, id, debugMode, canEmitLogs = false, useLogColors = false, autoHideId = false, }) {
         super();
         if (!isValidObj(logger)) {
             throw new TypeError('Logger must be an object that implements the Console interface.');
@@ -77,10 +135,14 @@ class TinyDebugger extends EventEmitter {
         if (typeof useLogColors !== 'boolean') {
             throw new TypeError('useLogColors must be a boolean.');
         }
+        if (typeof autoHideId !== 'boolean') {
+            throw new TypeError('autoHideId must be a boolean.');
+        }
         this.#logId = id;
         this.#logger = logger;
         this.#debugMode = debugMode;
         this.#canEmitLogs = canEmitLogs;
+        this.#autoHideId = autoHideId;
         this.#useLogColors = browserIs() !== 'firefox' ? useLogColors : false;
         this.log('info', `Emit logs of debug mode set to: ${this.#debugMode ? 'ON' : 'OFF'}`);
         this.log('info', 'Custom logger assigned.');
@@ -91,6 +153,29 @@ class TinyDebugger extends EventEmitter {
     get logId() {
         return this.#logId;
     }
+    /**
+     * @returns {string} The instance debug sub id.
+     */
+    get logSubId() {
+        if (typeof this.#logSubId !== 'string') {
+            throw new Error('logSubId has not been set yet. Assign a string to "logSubId" before reading it.');
+        }
+        return this.#logSubId;
+    }
+    /**
+     * @param {string} value - The new instance debug sub id.
+     * @throws {Error} If the sub id has not been set yet.
+     */
+    set logSubId(value) {
+        if (typeof value !== 'string') {
+            throw new TypeError(`logSubId must be a string. Received: ${typeof value}.`);
+        }
+        if (this.#logSubId !== null) {
+            throw new Error(`logSubId is already set to "${this.#logSubId}" and cannot be reassigned.`);
+        }
+        this.#logSubId = value;
+        this.emit('setLogSubId', value);
+    }
     /**
      * @returns {boolean} Whether event emission is enabled.
      */
@@ -113,7 +198,7 @@ class TinyDebugger extends EventEmitter {
         }
         this.#useLogColors = value;
         this.log('info', `Log Colors usage mode set to: ${this.#useLogColors ? 'ON' : 'OFF'}`);
-        this.emit('setDebugMode', value);
+        this.emit('setUseLogColors', value);
     }
     /**
      * @returns {boolean} True if debug mode is enabled.
@@ -184,6 +269,14 @@ class TinyDebugger extends EventEmitter {
         }
         return result;
     }
+    /**
+     * Internal method to apply prefix and color replacements.
+     * @param {string} text - The text to format.
+     * @returns {string} The formatted text.
+     */
+    _applyLogFormatting(text) {
+        return this.#applyFormatting(text);
+    }
     /**
      * Clears the console.
      * @returns {void|undefined}
@@ -240,7 +333,7 @@ class TinyDebugger extends EventEmitter {
     }
     /**
      * Starts a timer with a label.
-     * @param {string} label - The label for the timer.
+     * @param {string} [label] - The label for the timer.
      * @param {...any} args - Additional arguments for the timer.
      * @throws {TypeError} If label is not a string.
      * @returns {void}
@@ -256,7 +349,7 @@ class TinyDebugger extends EventEmitter {
     }
     /**
      * Asserts a condition and logs a message if the condition is false.
-     * @param {boolean} condition - The condition to evaluate.
+     * @param {boolean} [condition] - The condition to evaluate.
      * @param {...any} args - Arguments to log if the condition is false.
      * @returns {void}
      */
@@ -271,7 +364,7 @@ class TinyDebugger extends EventEmitter {
     }
     /**
      * Logs an element as a JavaScript object.
-     * @param {any} item - The object to inspect.
+     * @param {any} [item] - The object to inspect.
      * @param {import('util').InspectOptions} [options] - Inspection options.
      * @returns {void}
      */
@@ -284,7 +377,7 @@ class TinyDebugger extends EventEmitter {
     }
     /**
      * Displays a table of objects.
-     * @param {any} tabularData - The data to be displayed in a table.
+     * @param {any} [tabularData] - The data to be displayed in a table.
      * @param {string[]} [properties] - The properties (columns) to display.
      * @throws {TypeError} If properties is provided but is not an array of strings.
      * @returns {void}
@@ -332,20 +425,69 @@ class TinyDebugger extends EventEmitter {
             throw new TypeError('The message must be a string.');
         }
         let prefix = this.#logId;
+        let subPrefix = this.#logSubId ?? '';
         let formattedMessage = message;
-        prefix = this.#applyFormatting(prefix);
+        const showId = !this.#autoHideId || typeof this.#logSubId !== 'string';
+        prefix = showId ? this.#applyFormatting(prefix) : '';
+        if (subPrefix)
+            subPrefix = this.#applyFormatting(subPrefix);
         formattedMessage = this.#applyFormatting(formattedMessage);
+        const fullPrefix = `${prefix}${subPrefix ? (showId ? ` ${subPrefix}` : subPrefix) : ''}`;
         const logFunc = this.#logger[logType] ? this.#logger[logType] : console[logType];
         if (logFunc) {
             if (this.#canEmitLogs)
-                this.emit('debug:log', prefix, formattedMessage, ...args);
-            return logFunc(prefix, formattedMessage, ...args);
+                this.emit('debug:log', fullPrefix, formattedMessage, ...args);
+            return logFunc(fullPrefix, formattedMessage, ...args);
         }
         else {
             if (this.#canEmitLogs)
-                this.emit('debug:log', prefix, formattedMessage, ...args);
-            return console.log(prefix, formattedMessage, ...args);
+                this.emit('debug:log', fullPrefix, formattedMessage, ...args);
+            return console.log(fullPrefix, formattedMessage, ...args);
         }
     }
+    /**
+     * Forwards a `console`-style call to the internal `log` method.
+     * @param {'log' | 'info' | 'warn' | 'error' | 'debug' | 'dirxml' | 'group' | 'groupCollapsed' | 'trace'} logType - The console method to use.
+     * @param {any[]} data - The arguments forwarded to the logger.
+     * @returns {void}
+     */
+    #forwardLog(logType, data) {
+        const [message = '', ...rest] = data;
+        return typeof message === 'string'
+            ? this.log(logType, message, ...rest)
+            : this.log(logType, '', message, ...rest);
+    }
+    /**
+     * Builds a `console`-compatible facade bound to this instance.
+     * Every call is routed through the existing logging methods, so formatting,
+     * debug mode and event emission keep working without extra code.
+     * @returns {ConsoleFacade} A `console`-compatible object bound to this instance.
+     */
+    toConsole() {
+        return {
+            log: (...data) => this.#forwardLog('log', data),
+            info: (...data) => this.#forwardLog('info', data),
+            warn: (...data) => this.#forwardLog('warn', data),
+            error: (...data) => this.#forwardLog('error', data),
+            debug: (...data) => this.#forwardLog('debug', data),
+            dirxml: (...data) => this.#forwardLog('dirxml', data),
+            group: (...data) => this.#forwardLog('group', data),
+            groupCollapsed: (...data) => this.#forwardLog('groupCollapsed', data),
+            trace: (...data) => this.#forwardLog('trace', data),
+            assert: (condition, ...data) => this.logAssert(condition, ...data),
+            dir: (item, options) => this.logDir(item, options),
+            table: (tabularData, properties) => this.logTable(tabularData, properties),
+            clear: () => this.logClear(),
+            groupEnd: () => this.logGroupEnd(),
+            count: (label) => this.logLabel('count', label),
+            countReset: (label) => this.logLabel('countReset', label),
+            time: (label) => this.logLabel('time', label),
+            timeEnd: (label) => this.logLabel('timeEnd', label),
+            timeLog: (label, ...data) => this.logTimeLabel(label, ...data),
+            timeStamp: (label) => this.logLabel('timeStamp', label),
+            profile: (label) => this.logLabel('profile', label),
+            profileEnd: (label) => this.logLabel('profileEnd', label),
+        };
+    }
 }
 export default TinyDebugger;

package/dist/v1/libs/tools/TinyHtmlTagRegexBuilder.cjs

@@ -0,0 +1,256 @@
+'use strict';
+
+/**
+ * Defines the valid types for an HTML attribute name.
+ * @typedef {never|string} Attribute
+ */
+
+/**
+ * Configuration object used to define the parameters for the regex builder.
+ * @template {string} TagName
+ * @template {boolean} CaptureAllAttributes
+ * @template {Attribute} Attributes
+ * @typedef {Object} HtmlRegexConfig
+ * @property {TagName} tagName - The HTML tag name (e.g., 'a', 'div').
+ * @property {Attributes[]} [attributes=[]] - An array of attribute names to capture in individual groups.
+ * @property {boolean} [freeMode=false] - If true, allows the inner content to contain newlines.
+ * @property {CaptureAllAttributes} captureAllAttributes - If true, ignores specific attributes and focuses on the tag structure.
+ * @property {string} [contentPattern='[\s\S]*?'] - The regex pattern for the tag's inner content.
+ */
+
+/**
+ * Represents the structured result of a parsed HTML tag.
+ * @typedef {Object} ParsedHtmlTag
+ * @property {Record<string, string|boolean>} attributes - Object containing all parsed attributes.
+ * @property {string} child - The inner content of the HTML tag.
+ */
+
+/**
+ * Class responsible for constructing highly configurable regular expressions
+ * to capture HTML tags and their specific attributes.
+ * @template {string} TagName
+ * @template {boolean} CaptureAllAttributes
+ * @template {Attribute} Attributes
+ */
+class TinyHtmlTagRegexBuilder {
+  /**
+   * The name of the HTML tag to be matched.
+   * @type {TagName}
+   */
+  #tagName;
+
+  /**
+   * The list of specific attribute names to be captured.
+   * @type {Attributes[]}
+   */
+  #attributes = [];
+
+  /**
+   * Indicates if the content pattern should allow newlines.
+   * @type {boolean}
+   */
+  #freeMode = false;
+
+  /**
+   * Indicates if all attributes should be captured in a single group.
+   * @type {CaptureAllAttributes}
+   */
+  #captureAllAttributes;
+
+  /**
+   * The regex pattern used for the tag's inner content.
+   * @type {string}
+   */
+  #contentPattern = '';
+
+  /**
+   * Initializes a new instance of the TinyHtmlTagRegexBuilder.
+   * @param {HtmlRegexConfig<TagName, CaptureAllAttributes, Attributes>} config - Initial configuration object.
+   */
+  constructor(config) {
+    const tagName = config.tagName;
+    if (typeof tagName !== 'string') {
+      throw new TypeError('The tagName must be a string.');
+    }
+    if (/[<>\s]/.test(tagName)) {
+      throw new TypeError('The tagName must be a single word without spaces or < > characters.');
+    }
+    this.#tagName = tagName;
+
+    // Attribute validation
+    if (config.attributes) {
+      if (!Array.isArray(config.attributes)) {
+        throw new TypeError('The attributes property must be an array of strings.');
+      }
+      for (const attr of config.attributes) {
+        if (typeof attr !== 'string' || /[<>\s]/.test(attr)) {
+          throw new TypeError(
+            'Each attribute name must be a single word string without spaces or < > characters.',
+          );
+        }
+      }
+      this.#attributes = config.attributes;
+    }
+
+    if (typeof config.captureAllAttributes !== 'boolean') {
+      throw new TypeError('captureAllAttributes must be a boolean.');
+    }
+    this.#captureAllAttributes = config.captureAllAttributes;
+
+    this.freeMode = config.freeMode ?? false;
+    this.contentPattern = config.contentPattern || (this.#freeMode ? '[\\s\\S]*?' : '.*?');
+  }
+
+  // --- Getters and Setters with Validation ---
+
+  /**
+   * Gets the target HTML tag name.
+   * @returns {TagName}
+   */
+  get tagName() {
+    return this.#tagName;
+  }
+
+  /**
+   * Gets a copy of the attributes to be captured.
+   * @returns {Attributes[]}
+   */
+  get attributes() {
+    return [...this.#attributes];
+  }
+
+  /**
+   * Gets the current free mode status.
+   * @returns {boolean}
+   */
+  get freeMode() {
+    return this.#freeMode;
+  }
+
+  /**
+   * Sets the free mode status.
+   * @param {boolean} value
+   */
+  set freeMode(value) {
+    if (typeof value !== 'boolean') throw new TypeError('freeMode must be a boolean.');
+    this.#freeMode = value;
+  }
+
+  /**
+   * Gets the attribute capture mode.
+   * @returns {CaptureAllAttributes}
+   */
+  get captureAllAttributes() {
+    return this.#captureAllAttributes;
+  }
+
+  /**
+   * Gets the current regex pattern for the tag's content.
+   * @returns {string}
+   */
+  get contentPattern() {
+    return this.#contentPattern;
+  }
+
+  /**
+   * Sets the regex pattern for the tag's content.
+   * @param {string} value
+   */
+  set contentPattern(value) {
+    if (typeof value !== 'string') throw new TypeError('contentPattern must be a string.');
+    this.#contentPattern = value;
+  }
+
+  /**
+   * Constructs the RegExp string.
+   * @returns {string} The constructed regular expression string.
+   */
+  toString() {
+    let regexString = `<${this.#tagName}`;
+
+    if (this.#captureAllAttributes) {
+      // Captures all attributes (and the spaces between them) in a single capture group.
+      regexString += `([^>]*)`;
+    } else {
+      // Uses lookaheads to capture specific attributes individually.
+      for (const attr of this.#attributes) {
+        // This pattern handles:
+        // 1. quoted: attr="value" or attr='value'
+        // 2. unquoted: attr=value
+        // 3. solitary: attr
+        regexString += `(?=[^>]*?\\s+${attr}(?:=(?:["']([^"']*)["']|([^"'>\\s]+)))?(?=\\s|>|\\/))`;
+      }
+      // Consumes the rest of the opening tag without creating a new capture group
+      regexString += `[^>]*`;
+    }
+
+    // Closes the opening tag (the final >), adds the content group, and the closing tag
+    regexString += `>(${this.#contentPattern})</${this.#tagName}>`;
+
+    return regexString;
+  }
+
+  /**
+   * Constructs and returns the final RegExp object.
+   * @param {string} [flag='g']
+   * @returns {RegExp} The configured regular expression.
+   */
+  toRegExp(flag = 'g') {
+    return new RegExp(this.toString(), flag);
+  }
+
+  /**
+   * Executes the generated regex against an HTML string and organizes the results.
+   *
+   * @param {string} htmlString - The HTML text to be parsed.
+   * @returns {ParsedHtmlTag[]} An array containing an object for each matched tag, with its attributes and child.
+   */
+  parse(htmlString) {
+    // We force the 'g' flag to ensure we can iterate over all occurrences.
+    const regex = this.toRegExp('g');
+    /** @type {ParsedHtmlTag[]} */
+    const results = [];
+    let match;
+
+    while ((match = regex.exec(htmlString)) !== null) {
+      /** @type {Record<string, string|boolean>} */
+      const attributesObj = {};
+      let child = '';
+
+      if (this.#captureAllAttributes) {
+        const attrString = match[1] || '';
+        child = match[2] || '';
+
+        // Splits the raw string into key-value pairs
+        const attrRegex = /([^\s=]+)(?:\s*=\s*(?:(?:"([^"]*)")|(?:'([^']*)')|([^\s"'>]+)))?/g;
+        let attrMatch;
+
+        while ((attrMatch = attrRegex.exec(attrString)) !== null) {
+          const attrName = attrMatch[1];
+          // If the value exists in any of the groups, we take it. Otherwise, it is a solitary attribute (e.g., disabled = true).
+          const attrValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? true;
+          attributesObj[attrName] = attrValue;
+        }
+      } else {
+        // Mode with specific attributes based on the configuration array
+        for (let i = 0; i < this.#attributes.length; i++) {
+          const attrName = this.#attributes[i];
+          const quotedValue = match[i * 2 + 1];
+          const unquotedValue = match[i * 2 + 2];
+
+          attributesObj[attrName] = quotedValue ?? unquotedValue ?? true;
+        }
+        child = match[this.#attributes.length * 2 + 1] || '';
+      }
+
+      results.push({
+        attributes: attributesObj,
+        child: child,
+      });
+    }
+
+    return results;
+  }
+}
+
+module.exports = TinyHtmlTagRegexBuilder;

package/dist/v1/libs/tools/TinyHtmlTagRegexBuilder.d.mts

@@ -0,0 +1,125 @@
+/**
+ * Defines the valid types for an HTML attribute name.
+ * @typedef {never|string} Attribute
+ */
+export type Attribute = never | string;
+export type HtmlRegexConfig<TagName extends string, CaptureAllAttributes extends boolean, Attributes extends Attribute> = {
+    /**
+     * - The HTML tag name (e.g., 'a', 'div').
+     */
+    tagName: TagName;
+    /**
+     * - An array of attribute names to capture in individual groups.
+     */
+    attributes?: Attributes[];
+    /**
+     * - If true, allows the inner content to contain newlines.
+     */
+    freeMode?: boolean;
+    /**
+     * - If true, ignores specific attributes and focuses on the tag structure.
+     */
+    captureAllAttributes: CaptureAllAttributes;
+    /**
+     * - The regex pattern for the tag's inner content.
+     */
+    contentPattern?: string;
+};
+export type ParsedHtmlTag = {
+    /**
+     * - Object containing all parsed attributes.
+     */
+    attributes: Record<string, string | boolean>;
+    /**
+     * - The inner content of the HTML tag.
+     */
+    child: string;
+};
+/**
+ * Configuration object used to define the parameters for the regex builder.
+ * @template {string} TagName
+ * @template {boolean} CaptureAllAttributes
+ * @template {Attribute} Attributes
+ * @typedef {Object} HtmlRegexConfig
+ * @property {TagName} tagName - The HTML tag name (e.g., 'a', 'div').
+ * @property {Attributes[]} [attributes=[]] - An array of attribute names to capture in individual groups.
+ * @property {boolean} [freeMode=false] - If true, allows the inner content to contain newlines.
+ * @property {CaptureAllAttributes} captureAllAttributes - If true, ignores specific attributes and focuses on the tag structure.
+ * @property {string} [contentPattern='[\s\S]*?'] - The regex pattern for the tag's inner content.
+ */
+/**
+ * Represents the structured result of a parsed HTML tag.
+ * @typedef {Object} ParsedHtmlTag
+ * @property {Record<string, string|boolean>} attributes - Object containing all parsed attributes.
+ * @property {string} child - The inner content of the HTML tag.
+ */
+/**
+ * Class responsible for constructing highly configurable regular expressions
+ * to capture HTML tags and their specific attributes.
+ * @template {string} TagName
+ * @template {boolean} CaptureAllAttributes
+ * @template {Attribute} Attributes
+ */
+declare class TinyHtmlTagRegexBuilder<TagName extends string, CaptureAllAttributes extends boolean, Attributes extends Attribute> {
+    #private;
+    /**
+     * Initializes a new instance of the TinyHtmlTagRegexBuilder.
+     * @param {HtmlRegexConfig<TagName, CaptureAllAttributes, Attributes>} config - Initial configuration object.
+     */
+    constructor(config: HtmlRegexConfig<TagName, CaptureAllAttributes, Attributes>);
+    /**
+     * Gets the target HTML tag name.
+     * @returns {TagName}
+     */
+    get tagName(): TagName;
+    /**
+     * Gets a copy of the attributes to be captured.
+     * @returns {Attributes[]}
+     */
+    get attributes(): Attributes[];
+    /**
+     * Gets the current free mode status.
+     * @returns {boolean}
+     */
+    get freeMode(): boolean;
+    /**
+     * Sets the free mode status.
+     * @param {boolean} value
+     */
+    set freeMode(value: boolean);
+    /**
+     * Gets the attribute capture mode.
+     * @returns {CaptureAllAttributes}
+     */
+    get captureAllAttributes(): CaptureAllAttributes;
+    /**
+     * Gets the current regex pattern for the tag's content.
+     * @returns {string}
+     */
+    get contentPattern(): string;
+    /**
+     * Sets the regex pattern for the tag's content.
+     * @param {string} value
+     */
+    set contentPattern(value: string);
+    /**
+     * Constructs the RegExp string.
+     * @returns {string} The constructed regular expression string.
+     */
+    toString(): string;
+    /**
+     * Constructs and returns the final RegExp object.
+     * @param {string} [flag='g']
+     * @returns {RegExp} The configured regular expression.
+     */
+    toRegExp(flag?: string): RegExp;
+    /**
+     * Executes the generated regex against an HTML string and organizes the results.
+     *
+     * @param {string} htmlString - The HTML text to be parsed.
+     * @returns {ParsedHtmlTag[]} An array containing an object for each matched tag, with its attributes and child.
+     */
+    parse(htmlString: string): ParsedHtmlTag[];
+}
+export default TinyHtmlTagRegexBuilder;
+//# sourceMappingURL=TinyHtmlTagRegexBuilder.d.mts.map

package/dist/v1/libs/tools/TinyHtmlTagRegexBuilder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TinyHtmlTagRegexBuilder.d.mts","sourceRoot":"","sources":["../../../../src/v1/libs/tools/TinyHtmlTagRegexBuilder.mjs"],"names":[],"mappings":"AAAA;;;GAGG;AADA,YAAwB,SAAS,GAAvB,KAAK,GAAC,MAAM,CAAW;AAQjC,YAAkB,eAAe,CAHd,OAAO,SAAf,MAAe,EACN,oBAAoB,SAA7B,OAA6B,EAClB,UAAU,SAArB,SAAqB,IAEhC;;;;IAAoB,OAAO,EAAhB,OAAO,CAClB;;;;IAA0B,UAAU,AAApC,CACA,EADW,UAAU,EAAE,CACvB;;;;IAAqB,QAAQ,AAA7B,CACA,EADW,OAAO,CAClB;;;;IAAiC,oBAAoB,EAA1C,oBAAoB,CAC/B;;;;IAAoB,cAAc,AAAlC,CACF,EADa,MAAM,CACnB;CAAA,CAAA;AAIE,YAAkB,aAAa,GAC/B;;;;IAA2C,UAAU,EAA1C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAC,OAAO,CAAC,CACzC;;;;IAAmB,KAAK,EAAb,MAAM,CACnB;CAAA,CAAA;AAlBD;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AACH,cAAM,uBAAuB,CAJP,OAAO,SAAf,MAAe,EACN,oBAAoB,SAA7B,OAA6B,EAClB,UAAU,SAArB,SAAqB;;IAiCjC;;;OAGG;IACH,YAAY,MAAM,EAFP,eAAe,CAAC,OAAO,EAAE,oBAAoB,EAAE,UAAU,CAElD,EAgCjB;IAID;;;OAGG;IACH,IAAI,OAAO,IAFE,OAAO,CAInB;IAED;;;OAGG;IACH,IAAI,UAAU,IAFD,UAAU,EAAE,CAIxB;IAED;;;OAGG;IACH,IAAI,QAAQ,IAFC,OAAO,CAInB;IAED;;;OAGG;IACH,IAAI,QAAQ,CAAC,KAAK,EAFP,OAEO,EAGjB;IAED;;;OAGG;IACH,IAAI,oBAAoB,IAFX,oBAAoB,CAIhC;IAED;;;OAGG;IACH,IAAI,cAAc,IAFL,MAAM,CAIlB;IAED;;;OAGG;IACH,IAAI,cAAc,CAAC,KAAK,EAFb,MAEa,EAGvB;IAED;;;OAGG;IACH,QAAQ,IAFK,MAAM,CAyBlB;IAED;;;;OAIG;IACH,QAAQ,CAAC,IAAI,AAHV,CACA,EADQ,MAGQ,GAFN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,KAAK,CAAC,UAAU,EAHL,MAGK,GAFH,aAAa,EAAE,CA+C3B;CACF;eAEc,uBAAuB"}