linkify-it-for-enhancer/dist/linkify-it.d.ts

Links recognition library with FULL unicode support

import { Match } from './match';
import { LinkifyItNormalizedOptions, LinkifyItNormalizedSchemas, LinkifyItOptions, LinkifyItRegExp, LinkifyItSchemas, LinkifyItSchemasObject } from './types';
/**
 * new LinkifyIt(schemas, options)
 * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)
 * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }
 *
 * Creates new linkifier instance with optional additional schemas.
 * Can be called without `new` keyword for convenience.
 *
 * By default understands:
 *
 * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
 * - "fuzzy" links and emails (example.com, foo@bar.com).
 *
 * `schemas` is an object, where each key/value describes protocol/rule:
 *
 * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`
 *   for example). `linkify-it` makes shure that prefix is not preceeded with
 *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.
 * - __value__ - rule to check tail after link prefix
 *   - _String_ - just alias to existing rule
 *   - _Object_
 *     - _validate_ - validator function (should return matched length on success),
 *       or `RegExp`.
 *     - _normalize_ - optional function to normalize text & url of matched result
 *       (for example, for @twitter mentions).
 *
 * `options`:
 *
 * - __fuzzyLink__ - recognige URL-s without `http(s):` prefix. Default `true`.
 * - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts
 *   like version numbers. Default `false`.
 * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.
 *
 **/
export declare class LinkifyIt {
    #private;
    __opts__: LinkifyItNormalizedOptions;
    __index__: number;
    __last_index__: number;
    __schema__: string;
    __text_cache__: string;
    __schemas__: LinkifyItSchemas;
    __compiled__: LinkifyItNormalizedSchemas;
    __tlds__: string[];
    __tlds_replaced__: boolean;
    re: LinkifyItRegExp;
    constructor(schemas?: LinkifyItSchemas | LinkifyItOptions, options?: LinkifyItOptions);
    /** chainable
     * LinkifyIt#add(schema, definition)
     * - schema (String): rule name (fixed pattern prefix)
     * - definition (String|RegExp|Object): schema definition
     *
     * Add new rule definition. See constructor description for details.
     **/
    add(schema: string, definition: string): this;
    add(schema: string, definition: LinkifyItSchemasObject): this;
    /** chainable
     * LinkifyIt#set(options)
     * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }
     *
     * Set recognition options for links without schema.
     **/
    set(options: LinkifyItOptions): this;
    /**
     * LinkifyIt#test(text) -> Boolean
     *
     * Searches linkifiable pattern and returns `true` on success or `false` on fail.
     **/
    test(text: string): boolean;
    /**
     * LinkifyIt#pretest(text) -> Boolean
     *
     * Very quick check, that can give false positives. Returns true if link MAY BE
     * can exists. Can be used for speed optimization, when you need to check that
     * link NOT exists.
     **/
    pretest(text: string): boolean;
    /**
     * LinkifyIt#testSchemaAt(text, name, position) -> Number
     * - text (String): text to scan
     * - name (String): rule (schema) name
     * - position (Number): text offset to check from
     *
     * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly
     * at given position. Returns length of found pattern (0 on fail).
     **/
    testSchemaAt(text: string, schema: string, pos: number): number;
    /**
     * LinkifyIt#match(text) -> Array|null
     *
     * Returns array of found link descriptions or `null` on fail. We strongly
     * recommend to use [[LinkifyIt#test]] first, for best speed.
     *
     * ##### Result match description
     *
     * - __schema__ - link schema, can be empty for fuzzy links, or `//` for
     *   protocol-neutral  links.
     * - __index__ - offset of matched text
     * - __lastIndex__ - index of next char after mathch end
     * - __raw__ - matched text
     * - __text__ - normalized text
     * - __url__ - link, generated from matched text
     **/
    match(text: string): Match[] | null;
    /**
     * LinkifyIt#matchAtStart(text) -> Match|null
     *
     * Returns fully-formed (not fuzzy) link if it starts at the beginning
     * of the string, and null otherwise.
     **/
    matchAtStart(text: string): Match | null;
    /** chainable
     * LinkifyIt#tlds(list [, keepOld]) -> this
     * - list (Array): list of tlds
     * - keepOld (Boolean): merge with current list if `true` (`false` by default)
     *
     * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)
     * to avoid false positives. By default this algorythm used:
     *
     * - hostname with any 2-letter root zones are ok.
     * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф
     *   are ok.
     * - encoded (`xn--...`) root zones are ok.
     *
     * If list is replaced, then exact match for 2-chars root zones will be checked.
     **/
    tlds(list: Array<string> | string, keepOld?: boolean): this;
    /**
     * LinkifyIt#normalize(match)
     *
     * Default normalizer (if schema does not define it's own).
     **/
    normalize(match: Match): void;
    /**
     * LinkifyIt#onCompile()
     *
     * Override to modify basic RegExp-s.
     **/
    onCompile(): void;
}