@syncfusion/ej2-pdf/src/pdf/core/graphics/rightToLeft/bidirectional.d.ts

Feature-rich JavaScript PDF library with built-in support for loading and manipulating PDF document.

import { Dictionary } from './../../pdf-primitives';
/**
 * Provides bidirectional visual reordering support for text, including
 * level-based runs reordering and mirrored glyph shaping for RTL contexts.
 *
 * @private
 */
export declare class _Bidirectional {
    /**
     * Stores the reordering indexes computed by the bidi algorithm.
     *
     * @private
     */
    _indexes: number[];
    /**
     * Stores the resolved embedding levels for each code point.
     *
     * @private
     */
    _indexLevels: number[];
    /**
     * Maps code points to their mirrored counterparts for RTL shaping.
     *
     * @private
     */
    _mirroringShape: Dictionary<number, number>;
    /**
     * Creates a new instance of the `_Bidirectional` class.
     *
     * @private
     */
    constructor();
    /**
     * Applies Unicode symmetric mirroring to characters whose resolved embedding level
     * is odd, using an internal mirroring map.
     *
     * @private
     * @param {string} text The source text to mirror where required.
     * @returns {string} The string with mirrored characters applied at odd levels.
     */
    _doMirrorShaping(text: string): string;
    /**
     * Computes visual order from logical input using BiDi levels and mirroring, and
     * returns the visually ordered string.
     *
     * @private
     * @param {string} inputText The original logical-order string.
     * @param {boolean} isRtl Whether the paragraph base direction is RTL.
     * @returns {string} The visually ordered (reordered) string.
     */
    _getLogicalToVisualString(inputText: string, isRtl: boolean): string;
    /**
     * Initializes the index map to identity based on the
     * current `_indexLevels` length.
     *
     * @private
     * @returns {void}
     */
    _setDefaultIndexLevel(): void;
    /**
     * Reorders indices in the range `[sIndex, eIndex]` according to the BiDi algorithm
     * by processing embedding levels from maximum to minimum odd levels.
     *
     * @private
     * @param {number} sIndex The start index (inclusive).
     * @param {number} eIndex The end index (inclusive).
     * @returns {void}
     */
    _doOrder(sIndex: number, eIndex: number): void;
    /**
     * Reverses the `_indexes` segment in the range.
     *
     * @private
     * @param {number} i The inclusive starting index of the segment.
     * @param {number} j The exclusive ending index of the segment.
     * @returns {void}
     */
    _reArrange(i: number, j: number): void;
    /**
     * Reverses the `_indexes` segment in the range.
     *
     * @private
     * @returns {void}
     */
    _update(): void;
}
/**
 * Implements a lightweight Unicode BiDi classifier and visual ordering engine.
 * It classifies characters into BiDi classes, computes levels, normalizes runs,
 * and produces per-character embedding levels for visual reordering.
 *
 * @private
 */
export declare class _RtlCharacters {
    /**
     * Bidi character types for the input text sequence.
     *
     * @private
     */
    _type: number[];
    /**
     * Selected text order for shaping (-1 = auto).
     *
     * @private
     */
    _textOrder: number;
    /**
     * Length of the input text sequence.
     *
     * @private
     */
    _length: number;
    /**
     * Resulting visual order index map after processing.
     *
     * @private
     */
    _result: number[];
    /**
     * Resolved embedding levels for each input character.
     *
     * @private
     */
    _levels: number[];
    /**
     * Table that maps BMP code points to RTL character types.
     *
     * @private
     */
    _rtlCharacterTypes: number[];
    L: number;
    lre: number;
    lro: number;
    R: number;
    AL: number;
    rle: number;
    rlo: number;
    pdf: number;
    EN: number;
    ES: number;
    ET: number;
    AN: number;
    CS: number;
    nsm: number;
    BN: number;
    B: number;
    S: number;
    WS: number;
    ON: number;
    /**
     * Compact range table mapping Unicode intervals to bidi types.
     *
     * @private
     */
    _charTypes: number[];
    /**
     * Creates an instance of the 'RtlCharacters' class.
     *
     * @private
     */
    constructor();
    /**
     * Produces per-character embedding levels for the input by classifying characters,
     * resolving paragraph direction, and executing a simplified BiDi pass.
     *
     * @private
     * @param {string} inputText The logical-order text to analyze.
     * @param {boolean} isRtl When `true`, sets the paragraph base type to LRE; otherwise `L`.
     * @returns {number[]} A shallow copy of the resolved embedding levels for each character.
     */
    _getVisualOrder(inputText: string, isRtl: boolean): number[];
    /**
     * Maps each character in `text` to its BiDi class using `_rtlCharacterTypes`.
     *
     * @private
     * @param {string} text The input string.
     * @returns {number[]} The array of BiDi class codes for each character.
     */
    _getCharacterCode(text: string): number[];
    /**
     * Initializes `_levels` to the paragraph base level for all characters.
     *
     * @private
     * @returns {void}
     */
    _setDefaultLevels(): void;
    /**
     * Seeds the `_levels` array from default values.
     *
     * @private
     * @returns {void}
     */
    _setLevels(): void;
    /**
     * Adjusts levels for the resolved run , incrementing even/odd
     * runs according to BiDi rules for neutral and number classes.
     *
     * @private
     * @param {number} index The start index of the run.
     * @param {number} level The current level of the run.
     * @param {number} length The end index (exclusive) of the run.
     * @returns {void}
     */
    _updateLevels(index: number, level: number, length: number): void;
    /**
     * Executes the main BiDi resolution pass:
     * - initializes levels,
     * - removes embeddings/overrides/BN for processing,
     * - resolves runs and types (EN/AN/AL/neutral handling),
     * - reapplies embeddings, and fills sentinel levels.
     *
     * @private
     * @returns {void}
     */
    _doVisualOrder(): void;
    /**
     * Compacts `_result` and `_levels` by skipping embedding/override/BN codes
     * and returns the resulting logical length.
     *
     * @private
     * @returns {number} The compacted length excluding embedding/override/BN controls.
     */
    _getEmbeddedCharactersLength(): number;
    /**
     * Re-expands the compacted `_result` and `_levels` back to full length, restoring
     * embedding/override/BN positions and carrying over levels as needed.
     *
     * @private
     * @param {number} length The compacted logical length.
     * @returns {void}
     */
    _checkEmbeddedCharacters(length: number): void;
    /**
     * Normalizes combining marks to inherit the preceding strong type and
     * starts class resolution by dispatching to digit/Arabic/neutral handlers.
     *
     * @private
     * @param {number} index Start index of the current run.
     * @param {number} length End index (exclusive) of the current run.
     * @param {number} level Resolved embedding level of the run.
     * @param {number} startType The effective type before the run.
     * @param {number} endType The effective type after the run.
     * @returns {void}
     */
    _check(index: number, length: number, level: number, startType: number, endType: number): void;
    /**
     * Resolves European numbers to Arabic numbers when preceded by `AL`,
     * per BiDi rules, within the given run.
     *
     * @private
     * @param {number} index Start index of the run.
     * @param {number} length End index (exclusive) of the run.
     * @param {number} level Embedding level.
     * @param {number} startType Type before the run.
     * @param {number} endType Type after the run.
     * @returns {void}
     */
    _checkEuropeanDigits(index: number, length: number, level: number, startType: number, endType: number): void;
    /**
     * Converts Arabic letters (`AL`) to right-to-left (`R`) within the run.
     *
     * @private
     * @param {number} index Start index of the run.
     * @param {number} length End index (exclusive) of the run.
     * @param {number} level Embedding level.
     * @param {number} startType Type before the run.
     * @param {number} endType Type after the run.
     * @returns {void}
     */
    _checkArabicCharacters(index: number, length: number, level: number, startType: number, endType: number): void;
    /**
     * Resolves European number separators `ES` and common separators `CS`
     * to `EN`/`AN` when flanked by matching number classes on both sides.
     *
     * @private
     * @param {number} index Start index of the run.
     * @param {number} length End index (exclusive) of the run.
     * @param {number} level Embedding level.
     * @param {number} startType Type before the run.
     * @param {number} endType Type after the run.
     * @returns {void}
     */
    _checkEuropeanNumberSeparator(index: number, length: number, level: number, startType: number, endType: number): void;
    /**
     * Normalizes number terminators `ET` by collapsing contiguous ranges and
     * resolving their type based on surrounding strong/number classes.
     *
     * @private
     * @param {number} index Start index of the run.
     * @param {number} length End index (exclusive) of the run.
     * @param {number} level Embedding level.
     * @param {number} startType Type before the run.
     * @param {number} endType Type after the run.
     * @returns {void}
     */
    _checkEuropeanNumberTerminator(index: number, length: number, level: number, startType: number, endType: number): void;
    /**
     * Converts remaining `ES`/`ET`/`CS` to `ON` for further resolution.
     *
     * @private
     * @param {number} index Start index of the run.
     * @param {number} length End index (exclusive) of the run.
     * @param {number} level Embedding level.
     * @param {number} startType Type before the run.
     * @param {number} endType Type after the run.
     * @returns {void}
     */
    _checkOtherNeutrals(index: number, length: number, level: number, startType: number, endType: number): void;
    /**
     * Resolves European numbers `EN` to `L` when preceded by a left-to-right
     * strong type within the run, per BiDi rules.
     *
     * @private
     * @param {number} index Start index of the run.
     * @param {number} length End index (exclusive) of the run.
     * @param {number} level Embedding level.
     * @param {number} startType Type before the run.
     * @param {number} endType Type after the run.
     * @returns {void}
     */
    _checkOtherCharacters(index: number, length: number, level: number, startType: number, endType: number): void;
    /**
     * Scans forward from `index` while the current type matches any of `validSet`,
     * returning the first index not in the set or `length` if none.
     *
     * @private
     * @param {number} index The starting index (inclusive).
     * @param {number} length The maximum index (exclusive).
     * @param {number[]} validSet The set of types to consume.
     * @returns {number} The next index after the consumed range.
     */
    _getLength(index: number, length: number, validSet: number[]): number;
    /**
     * Resolves whitespace, neutrals, and separators (`WS`, `ON`, `B`, `S`) by
     * assigning them the surrounding strong type (or the default based on the level),
     * per the BiDi resolution steps.
     *
     * @private
     * @param {number} index Start index of the run.
     * @param {number} length End index (exclusive) of the run.
     * @param {number} level Embedding level.
     * @param {number} startType Type before the run.
     * @param {number} endType Type after the run.
     * @returns {void}
     */
    _checkCharacters(index: number, length: number, level: number, startType: number, endType: number): void;
}