@fiddle-digital/string-tune 1.0.3 → 1.1.1

package/dist/index.d.mts

@@ -756,294 +756,6 @@ interface ISplitOptions {
     wordLine?: ISplitOptionItem[];
 }
 
-/**
- * Represents a single word identified during layout calculation.
- */
-interface LayoutWord {
-    /** The text content of the word. */
-    text: string;
-}
-
-/**
- * Represents a line of text as determined by layout calculations.
- */
-interface LayoutLine {
-    /** The full text content of the line as a single string. */
-    text: string;
-    /** An array of word objects that make up this line. */
-    words: LayoutWord[];
-}
-
-/**
- * Holds the final calculated numerical value resulting from applying
- * a specific ISplitOptionItem rule to a word or character, along with
- * context about the rule itself (type, alignment).
- * This is used by the SplitDomBuilderTool to set CSS variables.
- */
-interface CalculatedValue {
-    /**
-     * The final numerical result after applying the alignment ('start', 'center', 'end', 'random')
-     * and absolute value ('abs') logic based on the specific option rule.
-     * This is the value that will be set for the CSS variable.
-     */
-    value: number;
-    /**
-     * Indicates which type of split option definition this value originated from.
-     * Crucial for generating the correct CSS variable name prefix (e.g., '--word-', '--charLine-').
-     */
-    type: 'line' | 'word' | 'char' | 'wordLine' | 'charLine' | 'charWord';
-    /**
-     * Stores the specific alignment ('start', 'center', 'end', 'random')
-     * defined in the option rule that produced this value.
-     * Used for generating the CSS variable name suffix (e.g., '-center', '-end').
-     */
-    align: string;
-}
-
-/**
- * Represents a processed word, containing its text, contextual indices
- * (global, line, word-in-line), and an array of calculated values
- * based on the applicable 'word' and 'wordLine' options.
- */
-interface ProcessedWord {
-    /** The text content of the word. */
-    text: string;
-    /** The zero-based index of the word across all words in all lines. */
-    globalIndex: number;
-    /** The zero-based index of the line this word belongs to. */
-    lineIndex: number;
-    /** The zero-based index of this word within its line. */
-    wordIndexInLine: number;
-    /** An array of calculated values based on ISplitOptions ('word', 'wordLine'). */
-    calculatedValues: CalculatedValue[];
-}
-
-/**
- * Input for the CharIndexerTool.
- */
-interface CharIndexerInput {
-    /** The array of processed words from WordIndexerTool. */
-    processedWords: ProcessedWord[];
-    /** The array of layout lines (needed to calculate total line characters). */
-    lines: LayoutLine[];
-    /** The parsed split options relevant for characters ('char', 'charLine', 'charWord'). */
-    options: Pick<ISplitOptions, 'char' | 'charLine' | 'charWord'>;
-    /** The total number of non-whitespace characters in the original text. */
-    totalChars: number;
-}
-
-/**
- * Represents a processed character, containing its text, contextual indices
- * (global, line, word, plus parent info), and an array of calculated values
- * based on the applicable 'char', 'charLine', and 'charWord' options.
- */
-interface ProcessedChar {
-    /** The character itself. */
-    text: string;
-    /** The zero-based index of the character across all non-whitespace characters. */
-    globalCharIndex: number;
-    /** The zero-based index of the character within its line (excluding spaces between words). */
-    lineCharIndex: number;
-    /** The zero-based index of the character within its word. */
-    wordCharIndex: number;
-    /** Index of the parent word across all words. */
-    parentGlobalWordIndex: number;
-    /** Index of the line this character belongs to. */
-    parentLineIndex: number;
-    /** Index of the parent word within its line. */
-    parentWordIndexInLine: number;
-    /** An array of calculated index values based on ISplitOptions ('char', 'charLine', 'charWord'). */
-    calculatedValues: CalculatedValue[];
-}
-
-/**
- * Tool to process words split by layout, breaking them into characters
- * and assigning relevant indices (global, line, word) for each character.
- * Calculates index values based on ISplitOptions for characters ('char', 'charLine', 'charWord').
- * Produces an array of ProcessedChar objects.
- */
-declare class CharIndexerTool implements IStringTool<CharIndexerInput, ProcessedChar[]> {
-    /**
-     * Iterates through processed words, splits them into characters, assigns
-     * global, line, and word character indices, and calculates index values
-     * based on the provided character options ('char', 'charLine', 'charWord').
-     *
-     * @param input.processedWords - Array of ProcessedWord objects from WordIndexerTool.
-     * @param input.lines - Array of LayoutLine objects (needed for calculating total characters per line).
-     * @param input.options - The relevant ISplitOptions ('char', 'charLine', 'charWord').
-     * @param input.totalChars - Total number of non-whitespace characters in the original text.
-     * @returns An array of ProcessedChar objects, ready for DOM building/styling.
-     */
-    process({ processedWords, lines, options, totalChars, }: CharIndexerInput): ProcessedChar[];
-    /**
-     * Calculates the final numerical index value based on alignment options, context indices, and parent length.
-     * (Identical helper function as in WordIndexerTool - could be extracted to a common utility).
-     *
-     * @param option - The specific option item definition ({ align, random, abs }).
-     * @param primaryIndex - The main index used for calculation (global, line, or word char index).
-     * @param localIndex - The secondary index (e.g., index within word).
-     * @param parentLength - The total count in the relevant context (total chars, line chars, or word chars).
-     * @returns The calculated numerical index value.
-     */
-    private calculateIndex;
-}
-
-/**
- * Input interface for the LayoutLineSplitterTool.
- * Requires both the text and the element it will be rendered within.
- */
-interface LayoutSplitInput {
-    /** The raw text content to be split into lines based on layout. */
-    text: string;
-    /** The HTML element whose width and styles determine line breaks. */
-    targetElement: HTMLElement;
-}
-
-/**
- * Tool to split a text string into structured lines and words based on how
- * the text would visually wrap within a given target HTML element.
- * This simulates browser rendering by measuring word widths.
- * Returns an array of LayoutLine objects.
- */
-declare class LayoutLineSplitterTool implements IStringTool<LayoutSplitInput, LayoutLine[]> {
-    /**
-     * Processes the input text and splits it into lines containing words,
-     * simulating word wrapping within the boundaries of the targetElement.
-     *
-     * @param input.text - The text content to split.
-     * @param input.targetElement - The HTMLElement used as a reference for width and font styles.
-     * @returns An array of LayoutLine objects, each containing the line's text and an array of its words.
-     * Returns an empty array on error or invalid input.
-     */
-    process({ text, targetElement }: LayoutSplitInput): LayoutLine[];
-    /**
-     * Measures the width of a given text string using the provided temporary span.
-     * @param text - The text to measure.
-     * @param tempSpan - The pre-styled temporary span element used for measurement.
-     * @returns The width of the text in pixels.
-     */
-    private measureWidth;
-    /**
-     * Decodes basic HTML entities (currently just &amp;).
-     * Can be expanded if more entities need handling.
-     * @param str - The string potentially containing HTML entities.
-     * @returns The string with '&amp;' decoded to '&'.
-     */
-    private decodeHtmlEntity;
-}
-
-/**
- * Defines the input structure required by the SplitDomBuilderTool.
- */
-interface DomBuilderInput {
-    /** Array of lines determined by layout. */
-    lines: LayoutLine[];
-    /** Array of words with calculated indices and values. */
-    words: ProcessedWord[];
-    /** Array of characters with calculated indices and values. */
-    chars: ProcessedChar[];
-    /** The original parsed split options. */
-    options: ISplitOptions;
-}
-
-/**
- * Tool to build the final innerHTML string with nested spans (-s-line, -s-word, -s-char)
- * and apply calculated CSS variables based on processed data from indexer tools.
- * Implements the IStringTool interface.
- */
-declare class SplitDomBuilderTool implements IStringTool<DomBuilderInput, string> {
-    /**
-     * Generates the innerHTML string for the split text by creating nested spans
-     * (-s-line, -s-word, -s-char) based on options and applying styles from calculated index values.
-     *
-     * @param input An object containing layout lines, processed words, processed characters, and the original split options.
-     * @returns The generated HTML string representing the split content.
-     */
-    process({ lines, words, chars, options }: DomBuilderInput): string;
-    /**
-     * Creates and styles a character span.
-     * @param pChar - The processed character data.
-     * @returns The styled HTMLSpanElement for the character.
-     * @private
-     */
-    private createCharSpan;
-    /**
-     * Checks if any line-level splitting options (line, wordLine, charLine) are present.
-     * @param options - The ISplitOptions object.
-     * @returns True if any line-level options exist and have definitions, false otherwise.
-     * @private
-     */
-    private hasLineOptions;
-    /**
-     * Checks if any word-level splitting options (word, wordLine) are present.
-     * @param options - The ISplitOptions object.
-     * @returns True if any word-level options exist and have definitions, false otherwise.
-     * @private
-     */
-    private hasWordOptions;
-    /**
-     * Checks if any character-level splitting options (char, charLine, charWord) are present.
-     * @param options - The ISplitOptions object.
-     * @returns True if any character-level options exist and have definitions, false otherwise.
-     * @private
-     */
-    private hasCharOptions;
-    /**
-     * Applies the pre-calculated index values as CSS custom properties to the element's style.
-     * @param span - The HTMLElement (line, word, or char span) to apply styles to.
-     * @param calculatedValues - An array of calculated values from the indexer tool.
-     * @private
-     */
-    private applyStyles;
-    /**
-     * Generates a CSS custom property name based on the split type and alignment.
-     * @param type - The type of split element ('line', 'word', 'char', etc.).
-     * @param align - The alignment option ('start', 'center', 'end', 'random').
-     * @returns The generated CSS variable name string (e.g., '--word-center').
-     * @private
-     */
-    private generateVariableName;
-}
-
-/**
- * Input for the WordIndexerTool.
- */
-interface WordIndexerInput {
-    /** The array of layout lines produced by LayoutLineSplitterTool. */
-    lines: LayoutLine[];
-    /** The parsed split options relevant for words ('word', 'wordLine'). */
-    options: Pick<ISplitOptions, 'word' | 'wordLine'>;
-}
-
-/**
- * Tool to process layout lines and words, assigning relevant indices
- * and calculating index values based on ISplitOptions ('word', 'wordLine').
- * Produces an array of ProcessedWord objects.
- */
-declare class WordIndexerTool implements IStringTool<WordIndexerInput, ProcessedWord[]> {
-    /**
-     * Iterates through lines and words, assigning global and local indices,
-     * and calculating index values based on the provided options ('word', 'wordLine').
-     *
-     * @param input.lines - Array of LayoutLine objects from LayoutLineSplitterTool.
-     * @param input.options - The relevant ISplitOptions ('word', 'wordLine').
-     * @returns An array of ProcessedWord objects, each containing word text, indices,
-     * and an array of calculated values based on options.
-     */
-    process({ lines, options }: WordIndexerInput): ProcessedWord[];
-    /**
-     * Calculates the final numerical index value based on alignment options, context indices, and parent length.
-     * This logic determines the value eventually set as a CSS variable.
-     *
-     * @param option - The specific option item definition ({ align, random, abs }).
-     * @param primaryIndex - The main index used for calculation (global index for 'word', index within line for 'wordLine').
-     * @param localIndex - The secondary index (e.g., index within the line), potentially useful for some alignment logic.
-     * @param parentLength - The total count in the relevant context (total words for 'word', words in the current line for 'wordLine').
-     * @returns The calculated numerical index value.
-     */
-    private calculateIndex;
-}
-
 /**
  * Input interface for the SplitOptionsParserTool.
  */
@@ -1143,10 +855,6 @@ interface StringToolsContainer {
      */
     lerpVector: LerpVector2Tool;
     transformScaleParser: TransformScaleParserTool;
-    layoutSplitter: LayoutLineSplitterTool;
-    wordIndexer: WordIndexerTool;
-    charIndexer: CharIndexerTool;
-    domBuilder: SplitDomBuilderTool;
     optionsParser: SplitOptionsParserTool;
 }
 
@@ -1229,6 +937,14 @@ declare class StringObject {
      * Marks this object as "inactive" (usually on intersection/scroll leave).
      */
     leave(): void;
+    /**
+     * Removes the current object by iterating through all associated modules
+     * and invoking their `removeObject` method with the object's ID.
+     *
+     * This method ensures that the object is properly removed from all
+     * modules it is associated with.
+     */
+    remove(): void;
     /**
      * Shows the object, applies visual class and notifies connected modules.
      */
@@ -1320,6 +1036,8 @@ interface IStringModule {
      * Called when the interaction leaves the object's area.
      */
     exitObject(id: string): void;
+    addObject(id: string, object: StringObject): void;
+    removeObject(id: string): void;
 }
 
 type AttributeType = "string" | "number" | "boolean" | "json" | "dimension" | "tuple" | "easing" | "color" | {
@@ -1370,6 +1088,16 @@ declare class StringModule implements IStringModule {
      * Example: ["offset-top", "offset-bottom"]
      */
     protected attributesToMap: AttributeMapping[];
+    /**
+     * A map that associates string keys with `StringObject` instances.
+     * This map is used to manage and track `StringObject` instances on a page.
+     */
+    protected objectMapOnPage: Map<string, StringObject>;
+    /**
+     * A protected array that holds the collection of `StringObject` instances
+     * currently present on the page.
+     */
+    protected objectsOnPage: StringObject[];
     /**
      * A map of all entered objects by their unique ID.
      */
@@ -1413,7 +1141,22 @@ declare class StringModule implements IStringModule {
     protected events: EventManager;
     constructor(context: StringContext);
     /**
-     * Called when a DOM element is detected as a potential interactive object.
+     * Initializes a `StringObject` by mapping attributes from an HTML element
+     * and applying transformations as needed.
+     *
+     * @param globalId - A unique identifier for the object being initialized.
+     * @param object - The `StringObject` instance to be initialized.
+     * @param element - The HTML element from which attributes are extracted.
+     * @param attributes - A record of additional attributes to be used during initialization.
+     *
+     * The method performs the following steps:
+     * 1. Retrieves the bounding rectangle of the provided HTML element.
+     * 2. Iterates over a predefined list of attributes to map.
+     * 3. Resolves fallback values for attributes, either from the provided attributes,
+     *    settings, or a fallback function.
+     * 4. Processes and parses the raw attribute values based on their expected type.
+     * 5. Applies optional transformations to the parsed values.
+     * 6. Sets the processed attributes as properties on the `StringObject` instance.
      */
     initializeObject(globalId: number, object: StringObject, element: HTMLElement, attributes: Record<string, any>): void;
     /**
@@ -1462,6 +1205,30 @@ declare class StringModule implements IStringModule {
      * Unregisters the object when it leaves the module’s scope.
      */
     exitObject(id: string): void;
+    /**
+     * Adds a `StringObject` to the internal collections if it does not already exist.
+     *
+     * @param id - The unique identifier for the `StringObject`.
+     * @param object - The `StringObject` to be added.
+     *
+     * @remarks
+     * This method ensures that the object is added to both `objectMapOnPage` and
+     * `objectsOnPage` only if the `id` is not already present in `objectMapOnPage`.
+     */
+    addObject(id: string, object: StringObject): void;
+    /**
+     * Removes an object from the page by its unique identifier.
+     *
+     * This method performs the following steps:
+     * 1. Retrieves the object associated with the given `id` from `objectMapOnPage`.
+     * 2. If the object is not found, the method exits early.
+     * 3. Deletes the object from `objectMapOnPage`.
+     * 4. Finds the index of the object in the `objectsOnPage` array.
+     * 5. If the object exists in the array, it is removed using `splice`.
+     *
+     * @param id - The unique identifier of the object to be removed.
+     */
+    removeObject(id: string): void;
     /**
      * Called when an object is connected. Can be overridden to apply initial styles or logic.
      * @param object The connected object.
@@ -1566,6 +1333,11 @@ declare class StringLazy extends StringModule {
     private setAspectRatio;
 }
 
+/**
+ * Represents a module responsible for handling loading-related functionality.
+ * Extends the `StringModule` class and provides additional behavior for managing
+ * loading states and timeouts.
+ */
 declare class StringLoading extends StringModule {
     loadingTimeout: number;
     constructor(context: StringContext);
@@ -1582,11 +1354,24 @@ declare class StringResponsive extends StringModule {
     private updateElements;
 }
 
+/**
+ * The `StringAnchor` class extends the `StringModule` class and is responsible for
+ * managing anchor-related functionality within the string module system.
+ *
+ * This class maps an `anchor` attribute to a tuple containing x and y coordinates,
+ * processes these coordinates using the `originParser` tool, and applies the resulting
+ * values to the connected object's element as a CSS `transform-origin` style.
+ */
 declare class StringAnchor extends StringModule {
     constructor(context: StringContext);
     onObjectConnected(object: StringObject): void;
 }
 
+/**
+ * The `StringGlide` class is a module that handles the glide effect for string objects
+ * based on scroll events. It calculates displacement, acceleration, and velocity
+ * to create a smooth scrolling effect for objects.
+ */
 declare class StringGlide extends StringModule {
     private previousLerp;
     private displacement;
@@ -1631,6 +1416,11 @@ declare class StringLerp extends StringModule {
     private setLerpValue;
 }
 
+/**
+ * The `StringProgress` class extends the `StringModule` class and is responsible for
+ * managing progress-based behavior for elements during scroll events. It maps specific
+ * attributes, initializes objects, and updates their progress based on scroll data.
+ */
 declare class StringProgress extends StringModule {
     constructor(context: StringContext);
     /**
@@ -1645,6 +1435,12 @@ declare class StringProgress extends StringModule {
     private setUpObject;
 }
 
+/**
+ * The `StringParallax` class extends the `StringProgress` class to provide
+ * functionality for handling parallax effects on scrollable elements.
+ * It maps specific attributes related to parallax and calculates the
+ * necessary transformations based on scroll progress and viewport size.
+ */
 declare class StringParallax extends StringProgress {
     constructor(context: StringContext);
     /**
@@ -1692,60 +1488,61 @@ declare class StringScrollbar extends StringModule {
 }
 
 /**
- * StringModule responsible for splitting text within HTML elements
- * into lines, words, and characters based on layout and attributes,
- * and applying CSS variables for animation purposes.
- * Uses a tool-based approach for modularity.
+ * StringSplit module: splits text into lines, words, chars,
+ * computes alignment/random values, and applies CSS vars.
  */
 declare class StringSplit extends StringModule {
-    /**
-     * Initializes the StringSplit module and its tools.
-     * @param context - The global StringContext.
-     */
     constructor(context: StringContext);
-    /**
-     * Called when the module initializes.
-     * Processes elements already present in the DOM on load.
-     */
-    onInit(): void;
-    /**
-     * Called when the window is resized.
-     * Re-processes already split elements as their layout might have changed.
-     */
     onResize(): void;
-    /**
-     * Called when a new StringObject associated with this module connects.
-     * Processes the newly connected element.
-     * @param object - The StringObject representing the connected element.
-     */
     onObjectConnected(object: StringObject): void;
+    split(element: HTMLElement, options: ISplitOptions): {
+        fragment: DocumentFragment;
+        result: DocumentFragment;
+    };
     /**
-     * Central method to process splitting for a given HTML element for automatic DOM manipulation.
-     * Orchestrates the use of various tools: parsing options, calculating layout,
-     * indexing words and characters, building the final HTML, and updating the DOM.
-     * Includes error handling.
-     * @param element - The HTMLElement to process.
-     * @private
-     */
-    private processElement;
-    /**
-     * Generates an HTML string with split text based on the provided text,
-     * a reference element for layout measurement, and options. Does not modify the DOM.
+     * Computes a numeric value based on the provided split option, index, and total count.
+     *
+     * @param opt - The split option item containing alignment and optional random range.
+     * @param index - The current index in the sequence.
+     * @param total - The total number of items in the sequence.
+     * @returns A computed numeric value based on the alignment strategy:
+     *          - "random": A random value within the specified range or default range.
+     *          - "start": The current index.
+     *          - "end": The reverse index from the end of the sequence.
+     *          - "center": The distance from the center index.
+     *          - Default: The current index.
+     */
+    private computeValue;
+    /**
+     * Applies calculated values to the provided layout lines and their components (words and characters)
+     * based on the given options. This method computes and assigns various calculated values
+     * (e.g., alignment and value) to lines, words, and characters, depending on the specified options.
+     *
+     * @param lines - An array of `LayoutLine` objects representing the lines of text to process.
+     * @param options - An `ISplitOptions` object specifying the calculation options for lines, words, and characters.
      *
-     * @param textToSplit - The text or HTML string to split.
-     * @param layoutReferenceElement - The HTMLElement used for layout calculations. Should be in the DOM for accurate results.
-     * @param options - The splitting options (ISplitOptions).
-     * @returns The generated HTML string with split elements, or an empty string on error.
-     * @public
+     * The `options` parameter can include the following properties:
+     * - `line`: An array of options for calculating values at the line level.
+     * - `word`: An array of options for calculating values at the word level.
+     * - `wordLine`: An array of options for calculating values at the word level relative to the line.
+     * - `char`: An array of options for calculating values at the character level.
+     * - `charWord`: An array of options for calculating values at the character level relative to the word.
+     * - `charLine`: An array of options for calculating values at the character level relative to the line.
+     *
+     * Each calculated value is assigned to the corresponding `calculatedValues` property of the line, word, or character.
+     * The method ensures that all specified options are processed and the calculated values are appended accordingly.
      */
-    generateSplitHtml(textToSplit: string, layoutReferenceElement: HTMLElement, options: ISplitOptions): string;
+    private applyCalculatedValues;
     /**
-     * Example demonstrating how to use generateSplitHtml.
-     * @param spanElement - The element to split and use for layout reference.
-     * @returns The resulting HTML string.
-     * @public
+     * Escapes the `src` attribute in a given string by removing the quotes around the URL.
+     *
+     * This method searches for occurrences of `src="URL"` where `URL` is an HTTP or HTTPS link,
+     * and replaces it with `src=URL` (removing the quotes around the URL).
+     *
+     * @param str - The input string containing the `src` attributes to be escaped.
+     * @returns The modified string with escaped `src` attributes.
      */
-    exampleUsage(spanElement: HTMLElement): string;
+    private escapeAttribute;
 }
 
 /**
@@ -1887,6 +1684,48 @@ declare class StringVideoAutoplay extends StringModule {
     private tryPlay;
 }
 
+/**
+ * Represents a rule for triggering actions based on scroll events.
+ */
+interface ScrollMarkRule {
+    /**
+     * A unique identifier for the scroll trigger rule.
+     */
+    id: string;
+    /**
+     * The offset value (in pixels) from the top of the viewport where the rule is triggered.
+     */
+    offset: number;
+    /**
+     * The direction of the scroll that activates the rule.
+     * - `"forward"`: Trigger when scrolling down.
+     * - `"backward"`: Trigger when scrolling up.
+     * - `"any"`: Trigger regardless of scroll direction.
+     */
+    direction: "forward" | "backward" | "any";
+    /**
+     * Optional callback function to execute when the scroll position enters the trigger zone.
+     */
+    onEnter?: () => void;
+    /**
+     * Optional callback function to execute when the scroll position leaves the trigger zone.
+     */
+    onLeave?: () => void;
+    /**
+     * Optional configuration for toggling a CSS class on a target element.
+     */
+    toggleClass?: {
+        /**
+         * The target HTML element on which the class will be toggled.
+         */
+        target: HTMLElement;
+        /**
+         * The name of the CSS class to toggle.
+         */
+        className: string;
+    };
+}
+
 declare class StringTune {
     /** Bound handler for the scroll start event */
     private onScrollStartBind;
@@ -2015,6 +1854,31 @@ declare class StringTune {
      * @param id Optional ID used during subscription.
      */
     off(eventName: string, callback: EventCallback<any>, id?: string): void;
+    /**
+     * Adds a scroll trigger rule that activates when the user scrolls past a defined offset
+     * in a specific direction. This can be used to toggle CSS classes or execute callbacks
+     * when elements come into view or go out of view.
+     *
+     * @param rule - The scroll trigger configuration object.
+     *   - `id`: A unique identifier for this rule.
+     *   - `offset`: The vertical scroll offset (in pixels) where the rule should activate.
+     *   - `direction`: Defines the scroll direction required to activate the rule.
+     *                 Can be `"forward"`, `"backward"`, or `"any"`.
+     *   - `onEnter`: (Optional) A function that will be called when the scroll position enters the trigger zone
+     *                in the specified direction.
+     *   - `onLeave`: (Optional) A function that will be called when the scroll position leaves the trigger zone
+     *                or scrolls in the opposite direction.
+     *   - `toggleClass`: (Optional) An object defining a class toggle behavior.
+     *                    It contains a target element and a class name to be added when the trigger is active
+     *                    and removed when it's not.
+     */
+    addScrollMark(rule: ScrollMarkRule): void;
+    /**
+     * Removes a scroll trigger by its unique identifier.
+     *
+     * @param id - The unique identifier of the scroll trigger to be removed.
+     */
+    removeScrollMark(id: string): void;
     /**
      * Starts the scroll engine and initializes all listeners, observers, and modules.
      *
@@ -2088,4 +1952,4 @@ declare class StringTune {
     destroy(): void;
 }
 
-export { StringAnchor, type StringContext, StringCursor, StringData, StringDelayLerpTracker, StringFPSTracker, StringGlide, StringLazy, StringLerp, StringLerpTracker, StringLoading, StringMagnetic, StringModule, StringObject, StringParallax, StringPositionTracker, StringProgress, StringResponsive, StringScrollbar, StringSplit, StringTune, StringVideoAutoplay, StringTune as default };
+export { type ScrollMarkRule as ScrollTriggerRule, StringAnchor, type StringContext, StringCursor, StringData, StringDelayLerpTracker, StringFPSTracker, StringGlide, StringLazy, StringLerp, StringLerpTracker, StringLoading, StringMagnetic, StringModule, StringObject, StringParallax, StringPositionTracker, StringProgress, StringResponsive, StringScrollbar, StringSplit, StringTune, StringVideoAutoplay, StringTune as default };