@myrmidon/gve-snapshot-rendition 2.0.4 → 2.0.6

package/dist/src/rendering/feature-resolver.d.ts

@@ -1,98 +0,0 @@
-import { Feature, CharNode } from "../models";
-import { GveRenditionSettings } from "../settings/settings";
-import { Logger } from "../core/logger";
-/**
- * Hint property overrides from r_h-* features.
- */
-export interface HintOverrides {
-    position?: string;
-    offsetX?: string;
-    offsetY?: string;
-    scaleX?: string;
-    scaleY?: string;
-    rotation?: string;
-    displacedSpan?: {
-        nodeId: number;
-        count: number;
-    };
-}
-/**
- * Resolved rendition configuration for text rendering.
- */
-export interface RenditionConfig {
-    fontSize: number;
-    fontFamily: string;
-    foreColor: string;
-    backColor: string;
-    italic: boolean;
-    bold: boolean;
-    underline?: number;
-    overline?: number;
-    strike?: number;
-    textLineStyle?: string;
-    textLineColor?: string;
-    rotate?: number;
-    textPosition?: string;
-    textOffsetX: number | string;
-    textOffsetY: number | string;
-    textDisplacedSpan?: {
-        nodeId: number;
-        count: number;
-    };
-    textValue?: string;
-    hints?: string[];
-    hintOverrides?: Map<string | number, HintOverrides>;
-    hintVars?: Map<string, string>;
-}
-/**
- * Feature resolver converts features into rendition configuration.
- * This handles all the r_* rendition features and applies them to create
- * a complete configuration for rendering.
- */
-export declare class FeatureResolver {
-    private _logger;
-    constructor(logger: Logger);
-    /**
-     * Resolve rendition features into a complete configuration.
-     * Features override the base settings.
-     *
-     * @param baseSettings - The base settings from component
-     * @param features - Array of features to apply
-     * @param nodeFeatureContext - Optional context for extracting node features for placeholder resolution
-     * @returns Resolved rendition configuration
-     */
-    resolve(baseSettings: GveRenditionSettings, features: Feature[] | undefined, nodeFeatureContext?: {
-        refNodes: CharNode[];
-        outputTag: string;
-    }): RenditionConfig;
-    /**
-     * Extract character offsets from init features.
-     * This is used for base text layout adjustments.
-     *
-     * @param features - Features from the first annotate operation (init features)
-     * @returns Map of node IDs to their offsets (values may be numbers or "Ntw"/"Nth" strings)
-     */
-    extractCharOffsets(features: Feature[] | undefined): Map<number, {
-        x?: number | string;
-        y?: number | string;
-    }>;
-    /**
-     * Check if features contain a specific rendition feature.
-     */
-    hasRenditionFeature(features: Feature[] | undefined, featureName: string): boolean;
-    /**
-     * Get the value of a rendition feature.
-     */
-    getRenditionFeatureValue(features: Feature[] | undefined, featureName: string): string | undefined;
-    /**
-     * Parse r_h-* hint override features.
-     * Format: "value" applies to all hints, or "@target1 target2:value" applies to specific hints.
-     * Targets can be hint ID strings or 1-based ordinal integers (e.g., "@1 beta:e" targets
-     * the first hint by position and all hints with key "beta"). Numbers and keys can be mixed.
-     *
-     * @param featureName - The feature name (e.g., "r_h-position")
-     * @param value - The feature value
-     * @param config - The rendition config to update
-     */
-    private parseHintOverride;
-}

package/dist/src/rendering/hint-renderer.d.ts

@@ -1,103 +0,0 @@
-import { CharNode } from "../models";
-import { GveRenditionSettings } from "../settings/settings";
-import { OperationHint } from "../settings/hint-models";
-import { Logger } from "../core/logger";
-import { AnimationEngine } from "../animation/animation-engine";
-import { BoundsCache } from "./bounds-cache";
-import { HintOverrides } from "./feature-resolver";
-/**
- * Hint renderer handles rendering of operation hints.
- * Hints are visual counterparts of editing operations.
- */
-export declare class HintRenderer {
-    private _settings;
-    private _logger;
-    private _animationEngine;
-    private _boundsCache;
-    constructor(settings: GveRenditionSettings, logger: Logger, animationEngine: AnimationEngine, boundsCache: BoundsCache);
-    /**
-     * Render a hint for an operation.
-     *
-     * @param hintId - ID of the hint from settings.hints
-     * @param hint - The hint configuration
-     * @param referenceNodes - Nodes referenced by the operation (for RBR calculation)
-     * @param rootSvg - Root SVG element to append hint to
-     * @param variables - Variables from r_hint-vars for placeholder resolution
-     * @param operationId - ID of the operation (for unique hint ID)
-     * @param hintOrdinal - Ordinal number of this hint for the operation (1, 2, 3...)
-     * @param allBaseNodes - All base text nodes (for displaced span)
-     * @param versionTag - Version tag to add as CSS class
-     * @param hintOverrides - Optional overrides from r_h-* features
-     * @param panZoomInstance - The svg-pan-zoom instance (for prolog)
-     * @param viewportWidth - Width of the visible viewport (for prolog)
-     * @param viewportHeight - Height of the visible viewport (for prolog)
-     * @returns Promise that resolves when rendering completes
-     */
-    renderHint(hintId: string, hint: OperationHint, referenceNodes: CharNode[], rootSvg: SVGElement, variables: Map<string, string>, operationId: string, hintOrdinal: number, allBaseNodes: CharNode[], versionTag: string, hintOverrides?: Map<string | number, HintOverrides>, panZoomInstance?: any, viewportWidth?: number, viewportHeight?: number): Promise<void>;
-    /**
-     * Calculate Reference Bounding Rectangles (RBRs) from reference nodes.
-     * Nodes on different lines create separate RBRs.
-     */
-    private calculateRBRs;
-    /**
-     * Calculate RBRs from a displaced span reference (IDxN format).
-     */
-    private calculateDisplacedRBRs;
-    /**
-     * Calculate scaling information for the hint.
-     * Returns scale factors and target dimensions.
-     */
-    private calculateScalingInfo;
-    /**
-     * Apply size transforms (scale and rotation) to the hint.
-     * Per documentation, these are applied BEFORE positioning.
-     *
-     * IMPORTANT: We DON'T actually apply these as transforms on the element.
-     * Instead, we just return the scaling info and rotation, and later we'll create
-     * a combined transform that includes both sizing and positioning.
-     */
-    private applyHintSizeTransforms;
-    /**
-     * Apply complete transform to the hint (both sizing and positioning).
-     * This builds a single transform that:
-     * 1. Translates so the EBR alignment point is at origin
-     * 2. Scales and rotates the hint
-     * 3. Translates to the final RBR position
-     *
-     * Per documentation: hints use the handle's bounding box as EBR if a handle element exists,
-     * otherwise they use the whole hint's bounding box as EBR.
-     */
-    private applyHintPositionTransform;
-    /**
-     * Get the EBR (Element Bounding Rectangle) for positioning.
-     * Per documentation: if the hint has a handle element, use its bounding box.
-     * Otherwise, use the whole hint's bounding box.
-     */
-    private getEBRBounds;
-    /**
-     * Calculate the alignment point on the RBR based on position type.
-     * This is where the EBR's corresponding alignment point should be positioned.
-     */
-    private calculateRBRAlignmentPoint;
-    /**
-     * Calculate the alignment point on the EBR based on position type.
-     * This is the point on the EBR that should align with the RBR alignment point.
-     */
-    private calculateEBRAlignmentPoint;
-    /**
-     * Apply r_h-* overrides to hint properties.
-     * Priority (lowest to highest): wildcard ("*") < key-based < ordinal-based.
-     *
-     * @param hint - Original hint design
-     * @param hintId - ID (key) of the hint being rendered
-     * @param hintOrdinal - 1-based ordinal position of this hint within the operation
-     * @param hintOverrides - Map of overrides from r_h-* features (keyed by ID string or ordinal number)
-     * @param allBaseNodes - All base nodes for displaced span resolution
-     * @returns Modified hint with overrides applied
-     */
-    private applyHintOverrides;
-    /**
-     * Update settings.
-     */
-    updateSettings(settings: GveRenditionSettings): void;
-}

package/dist/src/rendering/spreading-engine.d.ts

@@ -1,98 +0,0 @@
-import { BoundsCache, BoundingRect } from "./bounds-cache";
-import { Logger } from "../core/logger";
-/**
- * Result of spreading calculation.
- */
-export interface SpreadingResult {
-    /** Map of element ID to its horizontal shift amount */
-    horizontalShifts: Map<string, number>;
-    /** Map of element ID to its vertical shift amount */
-    verticalShifts: Map<string, number>;
-    /** Whether any spreading was needed */
-    hasShifts: boolean;
-}
-/**
- * Metadata about spreading applied to an element for a specific version.
- */
-export interface SpreadingMetadata {
-    /** Version index that caused this spreading */
-    versionIndex: number;
-    /** Horizontal shift applied (in pixels) */
-    horizontalShift: number;
-    /** Vertical shift applied (in pixels) */
-    verticalShift: number;
-}
-/**
- * Engine for calculating spreading (making room for new elements).
- * Implements the "stone in pond" ripple effect to preserve layout.
- */
-export declare class SpreadingEngine {
-    private _boundsCache;
-    private _logger;
-    /**
-     * Map of element ID to array of spreading metadata (one per version).
-     * Each element can be shifted multiple times by different versions.
-     */
-    private _spreadingHistory;
-    constructor(boundsCache: BoundsCache, logger: Logger);
-    /**
-     * Track spreading metadata for elements affected by a version.
-     * Called after spreading is applied to record what happened.
-     *
-     * @param versionIndex - Version index that caused the spreading
-     * @param horizontalShifts - Map of element IDs to horizontal shifts
-     * @param verticalShifts - Map of element IDs to vertical shifts
-     */
-    trackSpreading(versionIndex: number, horizontalShifts: Map<string, number>, verticalShifts: Map<string, number>): void;
-    /**
-     * Get spreading metadata for elements affected by a specific version.
-     * Used when reversing spreading during backward navigation.
-     *
-     * @param versionIndex - Version index to get spreading for
-     * @returns Map of element ID to spreading metadata
-     */
-    getSpreadingForVersion(versionIndex: number): Map<string, SpreadingMetadata>;
-    /**
-     * Remove spreading history for a specific version.
-     * Called after spreading is reversed during backward navigation.
-     *
-     * @param versionIndex - Version index to remove history for
-     */
-    clearSpreadingForVersion(versionIndex: number): void;
-    /**
-     * Calculate spreading required to make room for a new element.
-     *
-     * @param newElementBounds - Bounds of the element to be added
-     * @param excludeIds - Element IDs to exclude from shifting (e.g., the new element itself)
-     * @returns Spreading result with shift amounts for each affected element
-     */
-    calculateSpreading(newElementBounds: BoundingRect, excludeIds?: string[]): SpreadingResult;
-    /**
-     * Calculate horizontal spreading.
-     * Elements overlapping on the left are shifted left, those on the right are shifted right.
-     */
-    private calculateHorizontalSpreading;
-    /**
-     * Calculate vertical spreading.
-     * Elements overlapping from above are shifted up, those from below are shifted down.
-     */
-    private calculateVerticalSpreading;
-    /**
-     * Calculate the horizontal overlap between two bounding rectangles.
-     * Returns 0 if there is no overlap.
-     */
-    private calculateHorizontalOverlap;
-    /**
-     * Calculate the vertical overlap between two bounding rectangles.
-     * Returns 0 if there is no overlap.
-     */
-    private calculateVerticalOverlap;
-    /**
-     * Check if two bounding rectangles overlap.
-     */
-    checkOverlap(rect1: BoundingRect, rect2: BoundingRect): boolean;
-    /**
-     * Find all elements that overlap with given bounds.
-     */
-    findOverlappingElements(bounds: BoundingRect, excludeIds?: string[]): string[];
-}

package/dist/src/rendering/svg-utils.d.ts

@@ -1,133 +0,0 @@
-/**
- * SVG utility functions for creating and manipulating SVG elements.
- */
-/**
- * Create an SVG element with the given tag name.
- */
-export declare function createSVGElement<K extends keyof SVGElementTagNameMap>(tagName: K): SVGElementTagNameMap[K];
-/**
- * Set multiple attributes on an SVG element.
- */
-export declare function setAttributes(element: SVGElement, attributes: Record<string, string | number>): void;
-/**
- * Create an SVG text element with content and attributes.
- */
-export declare function createTextElement(content: string, attributes?: Record<string, string | number>): SVGTextElement;
-/**
- * Create an SVG group element.
- */
-export declare function createGroup(id?: string, classes?: string[]): SVGGElement;
-/**
- * Create an SVG rect element.
- */
-export declare function createRect(x: number, y: number, width: number, height: number, attributes?: Record<string, string | number>): SVGRectElement;
-/**
- * Create an SVG line element.
- */
-export declare function createLine(x1: number, y1: number, x2: number, y2: number, attributes?: Record<string, string | number>): SVGLineElement;
-/**
- * Apply text styling attributes based on settings.
- */
-export declare function applyTextStyle(element: SVGTextElement, style: {
-    fontFamily?: string;
-    fontSize?: number;
-    foreColor?: string;
-    backColor?: string;
-    italic?: boolean;
-    bold?: boolean;
-    underline?: number;
-    overline?: number;
-    strike?: number;
-    rotate?: number;
-}): void;
-/**
- * Apply line decoration to text (for custom thickness support).
- * This creates actual line elements for better control over thickness.
- */
-export declare function applyLineDecoration(parentGroup: SVGGElement, textElement: SVGTextElement, type: "underline" | "overline" | "strike", thickness: number, color: string, style?: string): SVGLineElement;
-/**
- * Parse SVG from string and return the root element.
- * Assumes the SVG content has a root <g> element.
- */
-export declare function parseSVGContent(svgString: string): SVGGElement | null;
-/**
- * Clone an SVG element and all its children.
- */
-export declare function cloneSVGElement<T extends SVGElement>(element: T): T;
-/**
- * Get the bounding box of an SVG element in a safe way.
- * Returns a default rectangle if getBBox() fails.
- *
- * IMPORTANT: This returns the bbox in LOCAL coordinates (without transforms).
- * Use getTransformedBBox() if you need the actual screen/SVG coordinates.
- */
-export declare function getSafeBBox(element: SVGElement): DOMRect;
-/**
- * Get the bounding box of an SVG element WITH transforms applied.
- * This returns the actual position in the SVG coordinate system.
- *
- * This is crucial for visibility checks because getBBox() returns local coords
- * which don't reflect the element's actual position after transforms.
- *
- * @param element - The SVG element
- * @returns The bounding box in SVG coordinate space (with transforms applied)
- */
-export declare function getTransformedBBox(element: SVGElement): DOMRect;
-/**
- * Apply a transform to an SVG element.
- */
-export declare function applyTransform(element: SVGElement, transform: {
-    translateX?: number;
-    translateY?: number;
-    scaleX?: number;
-    scaleY?: number;
-    rotate?: number;
-    originX?: number;
-    originY?: number;
-}): void;
-/**
- * Calculate the center point of a bounding rectangle.
- */
-export declare function getRectCenter(rect: DOMRect | {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}): {
-    x: number;
-    y: number;
-};
-/**
- * Get computed text width for a given text and style.
- * Creates a temporary SVG element to measure.
- *
- * IMPORTANT: The measurementRoot parameter is critical for correct measurements
- * when the component runs inside Angular or other frameworks that apply global
- * CSS styles (like font-family) to document.body. Without it, measurements
- * happen in document.body where inherited styles may affect font metrics,
- * but actual rendering happens inside Shadow DOM where styles are isolated.
- * This mismatch causes text positions and hint placements to be incorrect.
- *
- * When measurementRoot is provided (typically the component's root SVG element),
- * measurements happen in the same CSS context as the actual rendering,
- * ensuring consistent font metrics.
- *
- * @param text - The text to measure
- * @param fontFamily - Font family to use
- * @param fontSize - Font size in pixels
- * @param bold - Whether text is bold
- * @param italic - Whether text is italic
- * @param measurementRoot - Optional SVG element to use as measurement context.
- *                          If provided, a temporary text element is appended here
- *                          for measurement (same CSS context as rendering).
- *                          If not provided, falls back to document.body (legacy behavior).
- */
-export declare function getTextWidth(text: string, fontFamily: string, fontSize: number, bold?: boolean, italic?: boolean, measurementRoot?: SVGElement): number;
-/**
- * Move an element to the back (lowest z-index in SVG).
- */
-export declare function moveToBack(element: SVGElement): void;
-/**
- * Move an element to the front (highest z-index in SVG).
- */
-export declare function moveToFront(element: SVGElement): void;

package/dist/src/rendering/text-layout.d.ts

@@ -1,100 +0,0 @@
-import { CharNode } from "../models";
-import { GveRenditionSettings } from "../settings/settings";
-import { Logger } from "../core/logger";
-import { RenditionConfig } from "./feature-resolver";
-/**
- * Position information for a character node.
- */
-export interface CharPosition {
-    x: number;
-    y: number;
-    nodeId: number;
-    lineNumber: number;
-}
-/**
- * Text layout calculator.
- * Handles positioning of base text characters, respecting line breaks,
- * spaces, and character offsets.
- */
-export declare class TextLayout {
-    private _settings;
-    private _logger;
-    private _spaceWidth;
-    /**
-     * The SVG element used as the measurement context for text width calculations.
-     * This ensures measurements happen in the same CSS context as actual rendering,
-     * which is critical when the component runs inside frameworks like Angular
-     * that may apply global CSS styles affecting font metrics.
-     *
-     * When this is undefined, measurements fall back to document.body (legacy behavior)
-     * which can cause position mismatches if global styles differ from Shadow DOM styles.
-     */
-    private _measurementRoot?;
-    constructor(settings: GveRenditionSettings, logger: Logger);
-    /**
-     * Set the measurement root for text width calculations.
-     * This should be called with the root SVG element after it's created,
-     * before any layout calculations are performed.
-     *
-     * IMPORTANT: This ensures text measurements happen in the same CSS context
-     * as actual rendering (inside Shadow DOM), avoiding position mismatches
-     * caused by different font metrics in document.body vs Shadow DOM.
-     *
-     * @param root - The SVG element to use as measurement context
-     */
-    setMeasurementRoot(root: SVGElement): void;
-    /**
-     * Calculate the width of a space character based on reference character.
-     */
-    private calculateSpaceWidth;
-    /**
-     * Calculate positions for all base text nodes.
-     *
-     * @param nodes - The character nodes to position
-     * @param charOffsets - Map of node IDs to their offset overrides (from r_char-offsets feature).
-     *   Offset values may be plain numbers (px) or strings with units "tw"/"th"
-     *   (average character width / height of the current font).
-     * @returns Array of character positions
-     */
-    calculateBaseTextPositions(nodes: CharNode[], charOffsets?: Map<number, {
-        x?: number | string;
-        y?: number | string;
-    }>, nodeConfigs?: Map<number, RenditionConfig>): CharPosition[];
-    /**
-     * Calculate position for a single additional text node.
-     * Additional text positioning is driven by rendition features.
-     *
-     * @param referencePosition - The position to use as reference (e.g., from RBR)
-     * @param position - Position type (n, ne, e, se, s, sw, w, nw, o)
-     * @param offsetX - X offset (can be number or string like "0.5th")
-     * @param offsetY - Y offset (can be number or string like "0.5tw")
-     * @param refBounds - Reference bounding rectangle dimensions
-     * @returns Calculated position
-     */
-    calculateAdditionalTextPosition(referencePosition: {
-        x: number;
-        y: number;
-    }, position: string, offsetX: number, offsetY: number, refBounds: {
-        width: number;
-        height: number;
-    }): {
-        x: number;
-        y: number;
-    };
-    /**
-     * Get the line number for a given node ID from positions.
-     */
-    getLineNumber(positions: CharPosition[], nodeId: number): number;
-    /**
-     * Get all positions for a specific line.
-     */
-    getLinePositions(positions: CharPosition[], lineNumber: number): CharPosition[];
-    /**
-     * Update settings and recalculate space width.
-     */
-    updateSettings(settings: GveRenditionSettings): void;
-    /**
-     * Get the computed space width.
-     */
-    getSpaceWidth(): number;
-}

package/dist/src/rendering/text-renderer.d.ts

@@ -1,81 +0,0 @@
-import { CharNode } from "../models";
-import { GveRenditionSettings } from "../settings/settings";
-import { Logger } from "../core/logger";
-import { AnimationEngine } from "../animation/animation-engine";
-import { BoundsCache } from "./bounds-cache";
-import { RenditionConfig } from "./feature-resolver";
-/**
- * Text renderer handles rendering of base text and additional text.
- */
-export declare class TextRenderer {
-    private _settings;
-    private _logger;
-    private _animationEngine;
-    private _boundsCache;
-    private _textLayout;
-    /**
-     * Reference to the root SVG element for text width measurements.
-     * This ensures measurements happen in the same CSS context as rendering,
-     * which is critical when running inside Angular or other frameworks
-     * that apply global CSS styles to document.body.
-     */
-    private _measurementRoot?;
-    constructor(settings: GveRenditionSettings, logger: Logger, animationEngine: AnimationEngine, boundsCache: BoundsCache);
-    /**
-     * Render base text (v0).
-     *
-     * @param nodes - Character nodes to render
-     * @param rootSvg - Root SVG element
-     * @param charOffsets - Optional character offset overrides
-     * @returns Promise that resolves when rendering completes
-     */
-    renderBaseText(nodes: CharNode[], rootSvg: SVGElement, charOffsets?: Map<number, {
-        x?: number | string;
-        y?: number | string;
-    }>, nodeConfigs?: Map<number, RenditionConfig>): Promise<void>;
-    /**
-     * Render a single character node.
-     */
-    private renderCharacter;
-    /**
-     * Render additional text added by operations.
-     *
-     * @param nodes - Nodes to render
-     * @param rootSvg - Root SVG element
-     * @param config - Rendition configuration
-     * @param versionTag - Version tag for class
-     * @param referenceNodes - Reference nodes for RBR calculation
-     * @param allBaseNodes - All base text nodes (for displaced span)
-     * @param panZoomInstance - The svg-pan-zoom instance (for prolog)
-     * @param viewportWidth - Width of the visible viewport (for prolog)
-     * @param viewportHeight - Height of the visible viewport (for prolog)
-     * @returns Promise that resolves when rendering completes
-     */
-    renderAdditionalText(nodes: CharNode[], rootSvg: SVGElement, config: RenditionConfig, versionTag: string, referenceNodes: CharNode[], allBaseNodes: CharNode[], panZoomInstance?: any, viewportWidth?: number, viewportHeight?: number): Promise<void>;
-    /**
-     * Calculate positions for additional text characters.
-     * Additional text flows left to right from the base position.
-     * When config is provided its font metrics are used for character width
-     * measurement, matching what applyTextStyle will actually render.
-     */
-    private calculateAdditionalTextPositions;
-    /**
-     * Calculate the RBR anchor point for a given position type.
-     * This is the point on the RBR where the corresponding EBR point will land.
-     */
-    private calculateRBRAlignmentPoint;
-    /**
-     * Calculate the EBR anchor point for a given position type.
-     * This is the point on the EBR that should coincide with the RBR anchor point.
-     */
-    private calculateEBRAlignmentPoint;
-    /**
-     * Calculate RBRs from reference nodes.
-     * Nodes on different lines create separate RBRs.
-     */
-    private calculateRBRs;
-    /**
-     * Update settings.
-     */
-    updateSettings(settings: GveRenditionSettings): void;
-}

package/dist/src/settings/hint-models.d.ts

@@ -1,61 +0,0 @@
-/**
- * Models for operation hints.
- */
-import { RelativePosition } from "../core/gve-snapshot-rendition";
-/**
- * An editing operation's hint.
- * Hints represent the visual counterpart of an operation.
- */
-export interface OperationHint {
-    /**
-     * SVG code for hint's visuals.
-     * Always has a root `g` element.
-     * May contain placeholders in {{name}} format.
-     */
-    svg: string;
-    /**
-     * Relative position for the hint with respect to the reference bounding rectangle.
-     */
-    position: RelativePosition;
-    /**
-     * X offset from the computed position.
-     * Can be:
-     * - A number (pixels)
-     * - A string with suffix: "0.5th" (half text height), "0.5tw" (half text width)
-     */
-    offsetX: number | string;
-    /**
-     * Y offset from the computed position.
-     * Can be:
-     * - A number (pixels)
-     * - A string with suffix: "0.5th" (half text height), "0.5tw" (half text width)
-     */
-    offsetY: number | string;
-    /**
-     * Horizontal scale: 1 = match bounds width, 1.1 = 110% of bounds width.
-     * Default: 1
-     */
-    scaleX: number;
-    /**
-     * Vertical scale: 1 = match bounds height, 1.1 = 110% of bounds height.
-     * Default: 1
-     */
-    scaleY: number;
-    /**
-     * Rotation in degrees. 0 = no rotation.
-     * Rotation is applied with reference to the origin of the reference bounding rectangle.
-     */
-    rotation: number;
-    /**
-     * JS code for animating the hint's entrance via GSAP.
-     * If it starts with "#", it references an animation from settings.animations.
-     * The code receives parameters: (gsap, hintEl, rootEl)
-     */
-    animation?: string;
-    /**
-     * A span of base text with format IDxN where ID=node ID and N=count of chars,
-     * to be used as the RBR instead of the default RBR.
-     * Used for displaced hints.
-     */
-    displacedRefSpan?: string;
-}