gdpr audit implemented, email log, vollmachten, pdf delete cancel data privacy and vollmachten, removed message no id card in engergy car, and other contracts that are not telecom contracts, added insert counter for engery
This commit is contained in:
+1857
File diff suppressed because it is too large
Load Diff
+637
@@ -0,0 +1,637 @@
|
||||
export type Transition<T> = null | T;
|
||||
/**
|
||||
* Scanner output token:
|
||||
* - `t` is the token name (e.g., 'NUM', 'EMOJI', 'TLD')
|
||||
* - `v` is the value of the token (e.g., '123', '❤️', 'com')
|
||||
* - `s` is the start index of the token in the original string
|
||||
* - `e` is the end index of the token in the original string
|
||||
*/
|
||||
export type Token = {
|
||||
t: string;
|
||||
v: string;
|
||||
s: number;
|
||||
e: number;
|
||||
};
|
||||
export type Collections<T> = {
|
||||
[collection: string]: T[];
|
||||
};
|
||||
export type ScannerInit = {
|
||||
start: State<string>;
|
||||
tokens: {
|
||||
groups: Collections<string>;
|
||||
} & typeof tk;
|
||||
};
|
||||
export type ParserInit = {
|
||||
start: State<MultiToken>;
|
||||
tokens: typeof multi;
|
||||
};
|
||||
export type TokenPlugin = (arg: {
|
||||
scanner: ScannerInit;
|
||||
}) => void;
|
||||
export type Plugin = (arg: {
|
||||
scanner: ScannerInit;
|
||||
parser: ParserInit;
|
||||
}) => void;
|
||||
export type Flags = {
|
||||
[group: string]: true;
|
||||
};
|
||||
/**
|
||||
* An object where each key is a valid DOM Event Name such as `click` or `focus`
|
||||
* and each value is an event handler function.
|
||||
*
|
||||
* https://developer.mozilla.org/en-US/docs/Web/API/Element#events
|
||||
*/
|
||||
export type EventListeners = {
|
||||
[event: string]: Function;
|
||||
} | null;
|
||||
/**
|
||||
* All formatted properties required to render a link, including `tagName`,
|
||||
* `attributes`, `content` and `eventListeners`.
|
||||
*/
|
||||
export type IntermediateRepresentation = {
|
||||
tagName: any;
|
||||
attributes: {
|
||||
[attr: string]: any;
|
||||
};
|
||||
content: string;
|
||||
eventListeners: EventListeners;
|
||||
};
|
||||
/**
|
||||
* Specify either an object described by the template type `O` or a function.
|
||||
*
|
||||
* The function takes a string value (usually the link's href attribute), the
|
||||
* link type (`'url'`, `'hashtag`', etc.) and an internal token representation
|
||||
* of the link. It should return an object of the template type `O`
|
||||
*/
|
||||
export type OptObj<O> = O | ((value: string, type: string, token: MultiToken) => O);
|
||||
/**
|
||||
* Specify either a function described by template type `F` or an object.
|
||||
*
|
||||
* Each key in the object should be a link type (`'url'`, `'hashtag`', etc.). Each
|
||||
* value should be a function with template type `F` that is called when the
|
||||
* corresponding link type is encountered.
|
||||
*/
|
||||
export type OptFn<F> = F | {
|
||||
[type: string]: F;
|
||||
};
|
||||
/**
|
||||
* Specify either a value with template type `V`, a function that returns `V` or
|
||||
* an object where each value resolves to `V`.
|
||||
*
|
||||
* The function takes a string value (usually the link's href attribute), the
|
||||
* link type (`'url'`, `'hashtag`', etc.) and an internal token representation
|
||||
* of the link. It should return an object of the template type `V`
|
||||
*
|
||||
* For the object, each key should be a link type (`'url'`, `'hashtag`', etc.).
|
||||
* Each value should either have type `V` or a function that returns V. This
|
||||
* function similarly takes a string value and a token.
|
||||
*
|
||||
* Example valid types for `Opt<string>`:
|
||||
*
|
||||
* ```js
|
||||
* 'hello'
|
||||
* (value, type, token) => 'world'
|
||||
* { url: 'hello', email: (value, token) => 'world'}
|
||||
* ```
|
||||
*/
|
||||
export type Opt<V> = V | ((value: string, type: string, token: MultiToken) => V) | {
|
||||
[type: string]: V | ((value: string, token: MultiToken) => V);
|
||||
};
|
||||
/**
|
||||
* See available options: https://linkify.js.org/docs/options.html
|
||||
*/
|
||||
export type Opts = {
|
||||
defaultProtocol?: string;
|
||||
events?: OptObj<EventListeners>;
|
||||
format?: Opt<string>;
|
||||
formatHref?: Opt<string>;
|
||||
nl2br?: boolean;
|
||||
tagName?: Opt<any>;
|
||||
target?: Opt<string>;
|
||||
rel?: Opt<string>;
|
||||
validate?: Opt<boolean>;
|
||||
truncate?: Opt<number>;
|
||||
className?: Opt<string>;
|
||||
attributes?: OptObj<({
|
||||
[attr: string]: any;
|
||||
})>;
|
||||
ignoreTags?: string[];
|
||||
render?: OptFn<((ir: IntermediateRepresentation) => any)>;
|
||||
};
|
||||
/******************************************************************************
|
||||
Multi-Tokens
|
||||
Tokens composed of arrays of TextTokens
|
||||
******************************************************************************/
|
||||
/**
|
||||
* @param {string} value
|
||||
* @param {Token[]} tokens
|
||||
*/
|
||||
export function MultiToken(value: string, tokens: Token[]): void;
|
||||
export class MultiToken {
|
||||
/******************************************************************************
|
||||
Multi-Tokens
|
||||
Tokens composed of arrays of TextTokens
|
||||
******************************************************************************/
|
||||
/**
|
||||
* @param {string} value
|
||||
* @param {Token[]} tokens
|
||||
*/
|
||||
constructor(value: string, tokens: Token[]);
|
||||
t: string;
|
||||
v: string;
|
||||
tk: Token[];
|
||||
isLink: boolean;
|
||||
/**
|
||||
* Return the string this token represents.
|
||||
* @return {string}
|
||||
*/
|
||||
toString(): string;
|
||||
/**
|
||||
* What should the value for this token be in the `href` HTML attribute?
|
||||
* Returns the `.toString` value by default.
|
||||
* @param {string} [scheme]
|
||||
* @return {string}
|
||||
*/
|
||||
toHref(scheme?: string): string;
|
||||
/**
|
||||
* @param {Options} options Formatting options
|
||||
* @returns {string}
|
||||
*/
|
||||
toFormattedString(options: Options): string;
|
||||
/**
|
||||
*
|
||||
* @param {Options} options
|
||||
* @returns {string}
|
||||
*/
|
||||
toFormattedHref(options: Options): string;
|
||||
/**
|
||||
* The start index of this token in the original input string
|
||||
* @returns {number}
|
||||
*/
|
||||
startIndex(): number;
|
||||
/**
|
||||
* The end index of this token in the original input string (up to this
|
||||
* index but not including it)
|
||||
* @returns {number}
|
||||
*/
|
||||
endIndex(): number;
|
||||
/**
|
||||
Returns an object of relevant values for this token, which includes keys
|
||||
* type - Kind of token ('url', 'email', etc.)
|
||||
* value - Original text
|
||||
* href - The value that should be added to the anchor tag's href
|
||||
attribute
|
||||
@method toObject
|
||||
@param {string} [protocol] `'http'` by default
|
||||
*/
|
||||
toObject(protocol?: string): {
|
||||
type: string;
|
||||
value: string;
|
||||
isLink: boolean;
|
||||
href: string;
|
||||
start: number;
|
||||
end: number;
|
||||
};
|
||||
/**
|
||||
*
|
||||
* @param {Options} options Formatting option
|
||||
*/
|
||||
toFormattedObject(options: Options): {
|
||||
type: string;
|
||||
value: string;
|
||||
isLink: boolean;
|
||||
href: string;
|
||||
start: number;
|
||||
end: number;
|
||||
};
|
||||
/**
|
||||
* Whether this token should be rendered as a link according to the given options
|
||||
* @param {Options} options
|
||||
* @returns {boolean}
|
||||
*/
|
||||
validate(options: Options): boolean;
|
||||
/**
|
||||
* Return an object that represents how this link should be rendered.
|
||||
* @param {Options} options Formattinng options
|
||||
*/
|
||||
render(options: Options): {
|
||||
tagName: any;
|
||||
attributes: {
|
||||
href: any;
|
||||
class: any;
|
||||
target: any;
|
||||
rel: any;
|
||||
};
|
||||
content: string;
|
||||
eventListeners: any;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Utility class for linkify interfaces to apply specified
|
||||
* {@link Opts formatting and rendering options}.
|
||||
*
|
||||
* @param {Opts | Options} [opts] Option value overrides.
|
||||
* @param {(ir: IntermediateRepresentation) => any} [defaultRender] (For
|
||||
* internal use) default render function that determines how to generate an
|
||||
* HTML element based on a link token's derived tagName, attributes and HTML.
|
||||
* Similar to render option
|
||||
*/
|
||||
export function Options(opts?: Opts | Options, defaultRender?: (ir: IntermediateRepresentation) => any): void;
|
||||
export class Options {
|
||||
/**
|
||||
* Utility class for linkify interfaces to apply specified
|
||||
* {@link Opts formatting and rendering options}.
|
||||
*
|
||||
* @param {Opts | Options} [opts] Option value overrides.
|
||||
* @param {(ir: IntermediateRepresentation) => any} [defaultRender] (For
|
||||
* internal use) default render function that determines how to generate an
|
||||
* HTML element based on a link token's derived tagName, attributes and HTML.
|
||||
* Similar to render option
|
||||
*/
|
||||
constructor(opts?: Opts | Options, defaultRender?: (ir: IntermediateRepresentation) => any);
|
||||
/** @protected */
|
||||
o: Required<Opts>;
|
||||
defaultRender: any;
|
||||
ignoreTags: string[];
|
||||
/**
|
||||
* Returns true or false based on whether a token should be displayed as a
|
||||
* link based on the user options.
|
||||
* @param {MultiToken} token
|
||||
* @returns {boolean}
|
||||
*/
|
||||
check(token: MultiToken): boolean;
|
||||
/**
|
||||
* Resolve an option's value based on the value of the option and the given
|
||||
* params. If operator and token are specified and the target option is
|
||||
* callable, automatically calls the function with the given argument.
|
||||
* @template {keyof Opts} K
|
||||
* @param {K} key Name of option to use
|
||||
* @param {string} [operator] will be passed to the target option if it's a
|
||||
* function. If not specified, RAW function value gets returned
|
||||
* @param {MultiToken} [token] The token from linkify.tokenize
|
||||
* @returns {Opts[K] | any}
|
||||
*/
|
||||
get<K extends keyof Opts>(key: K, operator?: string, token?: MultiToken): Opts[K] | any;
|
||||
/**
|
||||
* @template {keyof Opts} L
|
||||
* @param {L} key Name of options object to use
|
||||
* @param {string} [operator]
|
||||
* @param {MultiToken} [token]
|
||||
* @returns {Opts[L] | any}
|
||||
*/
|
||||
getObj<L extends keyof Opts>(key: L, operator?: string, token?: MultiToken): Opts[L] | any;
|
||||
/**
|
||||
* Convert the given token to a rendered element that may be added to the
|
||||
* calling-interface's DOM
|
||||
* @param {MultiToken} token Token to render to an HTML element
|
||||
* @returns {any} Render result; e.g., HTML string, DOM element, React
|
||||
* Component, etc.
|
||||
*/
|
||||
render(token: MultiToken): any;
|
||||
}
|
||||
/**
|
||||
* @template T
|
||||
* @typedef {null | T } Transition
|
||||
*/
|
||||
/**
|
||||
* Define a basic state machine state. j is the list of character transitions,
|
||||
* jr is the list of regex-match transitions, jd is the default state to
|
||||
* transition to t is the accepting token type, if any. If this is the terminal
|
||||
* state, then it does not emit a token.
|
||||
*
|
||||
* The template type T represents the type of the token this state accepts. This
|
||||
* should be a string (such as of the token exports in `text.js`) or a
|
||||
* MultiToken subclass (from `multi.js`)
|
||||
*
|
||||
* @template T
|
||||
* @param {T} [token] Token that this state emits
|
||||
*/
|
||||
export function State<T>(token?: T): void;
|
||||
export class State<T> {
|
||||
/**
|
||||
* @template T
|
||||
* @typedef {null | T } Transition
|
||||
*/
|
||||
/**
|
||||
* Define a basic state machine state. j is the list of character transitions,
|
||||
* jr is the list of regex-match transitions, jd is the default state to
|
||||
* transition to t is the accepting token type, if any. If this is the terminal
|
||||
* state, then it does not emit a token.
|
||||
*
|
||||
* The template type T represents the type of the token this state accepts. This
|
||||
* should be a string (such as of the token exports in `text.js`) or a
|
||||
* MultiToken subclass (from `multi.js`)
|
||||
*
|
||||
* @template T
|
||||
* @param {T} [token] Token that this state emits
|
||||
*/
|
||||
constructor(token?: T);
|
||||
/** @type {{ [input: string]: State<T> }} j */
|
||||
j: {
|
||||
[input: string]: State<T>;
|
||||
};
|
||||
/** @type {[RegExp, State<T>][]} jr */
|
||||
jr: [RegExp, State<T>][];
|
||||
/** @type {?State<T>} jd */
|
||||
jd: State<T> | null;
|
||||
/** @type {?T} t */
|
||||
t: T | null;
|
||||
accepts(): boolean;
|
||||
/**
|
||||
* Follow an existing transition from the given input to the next state.
|
||||
* Does not mutate.
|
||||
* @param {string} input character or token type to transition on
|
||||
* @returns {?State<T>} the next state, if any
|
||||
*/
|
||||
go(input: string): State<T> | null;
|
||||
/**
|
||||
* Whether the state has a transition for the given input. Set the second
|
||||
* argument to true to only look for an exact match (and not a default or
|
||||
* regular-expression-based transition)
|
||||
* @param {string} input
|
||||
* @param {boolean} exactOnly
|
||||
*/
|
||||
has(input: string, exactOnly?: boolean): boolean;
|
||||
/**
|
||||
* Short for "transition all"; create a transition from the array of items
|
||||
* in the given list to the same final resulting state.
|
||||
* @param {string | string[]} inputs Group of inputs to transition on
|
||||
* @param {Transition<T> | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of token groups
|
||||
*/
|
||||
ta(inputs: string | string[], next?: Transition<T> | State<T>, flags?: Flags, groups?: Collections<T>): void;
|
||||
/**
|
||||
* Short for "take regexp transition"; defines a transition for this state
|
||||
* when it encounters a token which matches the given regular expression
|
||||
* @param {RegExp} regexp Regular expression transition (populate first)
|
||||
* @param {T | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of token groups
|
||||
* @returns {State<T>} taken after the given input
|
||||
*/
|
||||
tr(regexp: RegExp, next?: T | State<T>, flags?: Flags, groups?: Collections<T>): State<T>;
|
||||
/**
|
||||
* Short for "take transitions", will take as many sequential transitions as
|
||||
* the length of the given input and returns the
|
||||
* resulting final state.
|
||||
* @param {string | string[]} input
|
||||
* @param {T | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of token groups
|
||||
* @returns {State<T>} taken after the given input
|
||||
*/
|
||||
ts(input: string | string[], next?: T | State<T>, flags?: Flags, groups?: Collections<T>): State<T>;
|
||||
/**
|
||||
* Short for "take transition", this is a method for building/working with
|
||||
* state machines.
|
||||
*
|
||||
* If a state already exists for the given input, returns it.
|
||||
*
|
||||
* If a token is specified, that state will emit that token when reached by
|
||||
* the linkify engine.
|
||||
*
|
||||
* If no state exists, it will be initialized with some default transitions
|
||||
* that resemble existing default transitions.
|
||||
*
|
||||
* If a state is given for the second argument, that state will be
|
||||
* transitioned to on the given input regardless of what that input
|
||||
* previously did.
|
||||
*
|
||||
* Specify a token group flags to define groups that this token belongs to.
|
||||
* The token will be added to corresponding entires in the given groups
|
||||
* object.
|
||||
*
|
||||
* @param {string} input character, token type to transition on
|
||||
* @param {T | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of groups
|
||||
* @returns {State<T>} taken after the given input
|
||||
*/
|
||||
tt(input: string, next?: T | State<T>, flags?: Flags, groups?: Collections<T>): State<T>;
|
||||
}
|
||||
export namespace State {
|
||||
export { groups };
|
||||
}
|
||||
/**
|
||||
* Create a new token that can be emitted by the parser state machine
|
||||
* @param {string} type readable type of the token
|
||||
* @param {object} props properties to assign or override, including isLink = true or false
|
||||
* @returns {new (value: string, tokens: Token[]) => MultiToken} new token class
|
||||
*/
|
||||
export function createTokenClass(type: string, props: object): new (value: string, tokens: Token[]) => MultiToken;
|
||||
/**
|
||||
* Find a list of linkable items in the given string.
|
||||
* @param {string} str string to find links in
|
||||
* @param {string | Opts} [type] either formatting options or specific type of
|
||||
* links to find, e.g., 'url' or 'email'
|
||||
* @param {Opts} [opts] formatting options for final output. Cannot be specified
|
||||
* if opts already provided in `type` argument
|
||||
*/
|
||||
export function find(str: string, type?: string | Opts, opts?: Opts): {
|
||||
type: string;
|
||||
value: string;
|
||||
isLink: boolean;
|
||||
href: string;
|
||||
start: number;
|
||||
end: number;
|
||||
}[];
|
||||
/**
|
||||
* Initialize the linkify state machine. Called automatically the first time
|
||||
* linkify is called on a string, but may be called manually as well.
|
||||
*/
|
||||
export function init(): {
|
||||
scanner: any;
|
||||
parser: any;
|
||||
tokenQueue: any[];
|
||||
pluginQueue: any[];
|
||||
customSchemes: any[];
|
||||
initialized: boolean;
|
||||
};
|
||||
export var multi: Readonly<{
|
||||
__proto__: any;
|
||||
Base: typeof MultiToken;
|
||||
Email: new (value: string, tokens: Token[]) => MultiToken;
|
||||
MultiToken: typeof MultiToken;
|
||||
Nl: new (value: string, tokens: Token[]) => MultiToken;
|
||||
Text: new (value: string, tokens: Token[]) => MultiToken;
|
||||
Url: new (value: string, tokens: Token[]) => MultiToken;
|
||||
createTokenClass: typeof createTokenClass;
|
||||
}>;
|
||||
export var options: Readonly<{
|
||||
__proto__: any;
|
||||
Options: typeof Options;
|
||||
defaults: Required<Opts>;
|
||||
}>;
|
||||
export var regexp: Readonly<{
|
||||
__proto__: any;
|
||||
ASCII_LETTER: RegExp;
|
||||
DIGIT: RegExp;
|
||||
EMOJI: RegExp;
|
||||
EMOJI_VARIATION: RegExp;
|
||||
LETTER: RegExp;
|
||||
SPACE: RegExp;
|
||||
}>;
|
||||
/**
|
||||
* Detect URLs with the following additional protocol. Anything with format
|
||||
* "protocol://..." will be considered a link. If `optionalSlashSlash` is set to
|
||||
* `true`, anything with format "protocol:..." will be considered a link.
|
||||
* @param {string} scheme
|
||||
* @param {boolean} [optionalSlashSlash]
|
||||
*/
|
||||
export function registerCustomProtocol(scheme: string, optionalSlashSlash?: boolean): void;
|
||||
/**
|
||||
* Register a linkify plugin
|
||||
* @param {string} name of plugin to register
|
||||
* @param {Plugin} plugin function that accepts the parser state machine and
|
||||
* extends the parser to recognize additional link types
|
||||
*/
|
||||
export function registerPlugin(name: string, plugin: Plugin): void;
|
||||
/**
|
||||
* Register a token plugin to allow the scanner to recognize additional token
|
||||
* types before the parser state machine is constructed from the results.
|
||||
* @param {string} name of plugin to register
|
||||
* @param {TokenPlugin} plugin function that accepts the scanner state machine
|
||||
* and available scanner tokens and collections and extends the state machine to
|
||||
* recognize additional tokens or groups.
|
||||
*/
|
||||
export function registerTokenPlugin(name: string, plugin: TokenPlugin): void;
|
||||
/**
|
||||
* @typedef {{
|
||||
* start: State<string>,
|
||||
* tokens: { groups: Collections<string> } & typeof tk
|
||||
* }} ScannerInit
|
||||
*/
|
||||
/**
|
||||
* @typedef {{
|
||||
* start: State<MultiToken>,
|
||||
* tokens: typeof multi
|
||||
* }} ParserInit
|
||||
*/
|
||||
/**
|
||||
* @typedef {(arg: { scanner: ScannerInit }) => void} TokenPlugin
|
||||
*/
|
||||
/**
|
||||
* @typedef {(arg: { scanner: ScannerInit, parser: ParserInit }) => void} Plugin
|
||||
*/
|
||||
/**
|
||||
* De-register all plugins and reset the internal state-machine. Used for
|
||||
* testing; not required in practice.
|
||||
* @private
|
||||
*/
|
||||
export function reset(): {
|
||||
scanner: any;
|
||||
parser: any;
|
||||
tokenQueue: any[];
|
||||
pluginQueue: any[];
|
||||
customSchemes: any[];
|
||||
initialized: boolean;
|
||||
};
|
||||
/**
|
||||
* Convert a String to an Array of characters, taking into account that some
|
||||
* characters like emojis take up two string indexes.
|
||||
*
|
||||
* Adapted from core-js (MIT license)
|
||||
* https://github.com/zloirock/core-js/blob/2d69cf5f99ab3ea3463c395df81e5a15b68f49d9/packages/core-js/internals/string-multibyte.js
|
||||
*
|
||||
* @function stringToArray
|
||||
* @param {string} str
|
||||
* @returns {string[]}
|
||||
*/
|
||||
export function stringToArray(str: string): string[];
|
||||
/**
|
||||
* Is the given string valid linkable text of some sort. Note that this does not
|
||||
* trim the text for you.
|
||||
*
|
||||
* Optionally pass in a second `type` param, which is the type of link to test
|
||||
* for.
|
||||
*
|
||||
* For example,
|
||||
*
|
||||
* linkify.test(str, 'email');
|
||||
*
|
||||
* Returns `true` if str is a valid email.
|
||||
* @param {string} str string to test for links
|
||||
* @param {string} [type] optional specific link type to look for
|
||||
* @returns boolean true/false
|
||||
*/
|
||||
export function test(str: string, type?: string): boolean;
|
||||
/**
|
||||
* Parse a string into tokens that represent linkable and non-linkable sub-components
|
||||
* @param {string} str
|
||||
* @return {MultiToken[]} tokens
|
||||
*/
|
||||
export function tokenize(str: string): MultiToken[];
|
||||
export namespace tokenize {
|
||||
export { run$1 as scan };
|
||||
}
|
||||
declare var tk: Readonly<{
|
||||
__proto__: any;
|
||||
ALPHANUMERICAL: "ALPHANUMERICAL";
|
||||
AMPERSAND: "AMPERSAND";
|
||||
APOSTROPHE: "APOSTROPHE";
|
||||
ASCIINUMERICAL: "ASCIINUMERICAL";
|
||||
ASTERISK: "ASTERISK";
|
||||
AT: "AT";
|
||||
BACKSLASH: "BACKSLASH";
|
||||
BACKTICK: "BACKTICK";
|
||||
CARET: "CARET";
|
||||
CLOSEANGLEBRACKET: "CLOSEANGLEBRACKET";
|
||||
CLOSEBRACE: "CLOSEBRACE";
|
||||
CLOSEBRACKET: "CLOSEBRACKET";
|
||||
CLOSEPAREN: "CLOSEPAREN";
|
||||
COLON: "COLON";
|
||||
COMMA: "COMMA";
|
||||
DOLLAR: "DOLLAR";
|
||||
DOT: "DOT";
|
||||
EMOJI: "EMOJI";
|
||||
EQUALS: "EQUALS";
|
||||
EXCLAMATION: "EXCLAMATION";
|
||||
FULLWIDTHGREATERTHAN: "FULLWIDTHGREATERTHAN";
|
||||
FULLWIDTHLEFTPAREN: "FULLWIDTHLEFTPAREN";
|
||||
FULLWIDTHLESSTHAN: "FULLWIDTHLESSTHAN";
|
||||
FULLWIDTHMIDDLEDOT: "FULLWIDTHMIDDLEDOT";
|
||||
FULLWIDTHRIGHTPAREN: "FULLWIDTHRIGHTPAREN";
|
||||
HYPHEN: "HYPHEN";
|
||||
LEFTCORNERBRACKET: "LEFTCORNERBRACKET";
|
||||
LEFTWHITECORNERBRACKET: "LEFTWHITECORNERBRACKET";
|
||||
LOCALHOST: "LOCALHOST";
|
||||
NL: "NL";
|
||||
NUM: "NUM";
|
||||
OPENANGLEBRACKET: "OPENANGLEBRACKET";
|
||||
OPENBRACE: "OPENBRACE";
|
||||
OPENBRACKET: "OPENBRACKET";
|
||||
OPENPAREN: "OPENPAREN";
|
||||
PERCENT: "PERCENT";
|
||||
PIPE: "PIPE";
|
||||
PLUS: "PLUS";
|
||||
POUND: "POUND";
|
||||
QUERY: "QUERY";
|
||||
QUOTE: "QUOTE";
|
||||
RIGHTCORNERBRACKET: "RIGHTCORNERBRACKET";
|
||||
RIGHTWHITECORNERBRACKET: "RIGHTWHITECORNERBRACKET";
|
||||
SCHEME: "SCHEME";
|
||||
SEMI: "SEMI";
|
||||
SLASH: "SLASH";
|
||||
SLASH_SCHEME: "SLASH_SCHEME";
|
||||
SYM: "SYM";
|
||||
TILDE: "TILDE";
|
||||
TLD: "TLD";
|
||||
UNDERSCORE: "UNDERSCORE";
|
||||
UTLD: "UTLD";
|
||||
UWORD: "UWORD";
|
||||
WORD: "WORD";
|
||||
WS: "WS";
|
||||
}>;
|
||||
declare var groups: Collections<string>;
|
||||
/**
|
||||
Given a string, returns an array of TOKEN instances representing the
|
||||
composition of that string.
|
||||
|
||||
@method run
|
||||
@param {State<string>} start scanner starting state
|
||||
@param {string} str input string to scan
|
||||
@return {Token[]} list of tokens, each with a type and value
|
||||
*/
|
||||
declare function run$1(start: State<string>, str: string): Token[];
|
||||
export { multi as text };
|
||||
+637
@@ -0,0 +1,637 @@
|
||||
export type Transition<T> = null | T;
|
||||
/**
|
||||
* Scanner output token:
|
||||
* - `t` is the token name (e.g., 'NUM', 'EMOJI', 'TLD')
|
||||
* - `v` is the value of the token (e.g., '123', '❤️', 'com')
|
||||
* - `s` is the start index of the token in the original string
|
||||
* - `e` is the end index of the token in the original string
|
||||
*/
|
||||
export type Token = {
|
||||
t: string;
|
||||
v: string;
|
||||
s: number;
|
||||
e: number;
|
||||
};
|
||||
export type Collections<T> = {
|
||||
[collection: string]: T[];
|
||||
};
|
||||
export type ScannerInit = {
|
||||
start: State<string>;
|
||||
tokens: {
|
||||
groups: Collections<string>;
|
||||
} & typeof tk;
|
||||
};
|
||||
export type ParserInit = {
|
||||
start: State<MultiToken>;
|
||||
tokens: typeof multi;
|
||||
};
|
||||
export type TokenPlugin = (arg: {
|
||||
scanner: ScannerInit;
|
||||
}) => void;
|
||||
export type Plugin = (arg: {
|
||||
scanner: ScannerInit;
|
||||
parser: ParserInit;
|
||||
}) => void;
|
||||
export type Flags = {
|
||||
[group: string]: true;
|
||||
};
|
||||
/**
|
||||
* An object where each key is a valid DOM Event Name such as `click` or `focus`
|
||||
* and each value is an event handler function.
|
||||
*
|
||||
* https://developer.mozilla.org/en-US/docs/Web/API/Element#events
|
||||
*/
|
||||
export type EventListeners = {
|
||||
[event: string]: Function;
|
||||
} | null;
|
||||
/**
|
||||
* All formatted properties required to render a link, including `tagName`,
|
||||
* `attributes`, `content` and `eventListeners`.
|
||||
*/
|
||||
export type IntermediateRepresentation = {
|
||||
tagName: any;
|
||||
attributes: {
|
||||
[attr: string]: any;
|
||||
};
|
||||
content: string;
|
||||
eventListeners: EventListeners;
|
||||
};
|
||||
/**
|
||||
* Specify either an object described by the template type `O` or a function.
|
||||
*
|
||||
* The function takes a string value (usually the link's href attribute), the
|
||||
* link type (`'url'`, `'hashtag`', etc.) and an internal token representation
|
||||
* of the link. It should return an object of the template type `O`
|
||||
*/
|
||||
export type OptObj<O> = O | ((value: string, type: string, token: MultiToken) => O);
|
||||
/**
|
||||
* Specify either a function described by template type `F` or an object.
|
||||
*
|
||||
* Each key in the object should be a link type (`'url'`, `'hashtag`', etc.). Each
|
||||
* value should be a function with template type `F` that is called when the
|
||||
* corresponding link type is encountered.
|
||||
*/
|
||||
export type OptFn<F> = F | {
|
||||
[type: string]: F;
|
||||
};
|
||||
/**
|
||||
* Specify either a value with template type `V`, a function that returns `V` or
|
||||
* an object where each value resolves to `V`.
|
||||
*
|
||||
* The function takes a string value (usually the link's href attribute), the
|
||||
* link type (`'url'`, `'hashtag`', etc.) and an internal token representation
|
||||
* of the link. It should return an object of the template type `V`
|
||||
*
|
||||
* For the object, each key should be a link type (`'url'`, `'hashtag`', etc.).
|
||||
* Each value should either have type `V` or a function that returns V. This
|
||||
* function similarly takes a string value and a token.
|
||||
*
|
||||
* Example valid types for `Opt<string>`:
|
||||
*
|
||||
* ```js
|
||||
* 'hello'
|
||||
* (value, type, token) => 'world'
|
||||
* { url: 'hello', email: (value, token) => 'world'}
|
||||
* ```
|
||||
*/
|
||||
export type Opt<V> = V | ((value: string, type: string, token: MultiToken) => V) | {
|
||||
[type: string]: V | ((value: string, token: MultiToken) => V);
|
||||
};
|
||||
/**
|
||||
* See available options: https://linkify.js.org/docs/options.html
|
||||
*/
|
||||
export type Opts = {
|
||||
defaultProtocol?: string;
|
||||
events?: OptObj<EventListeners>;
|
||||
format?: Opt<string>;
|
||||
formatHref?: Opt<string>;
|
||||
nl2br?: boolean;
|
||||
tagName?: Opt<any>;
|
||||
target?: Opt<string>;
|
||||
rel?: Opt<string>;
|
||||
validate?: Opt<boolean>;
|
||||
truncate?: Opt<number>;
|
||||
className?: Opt<string>;
|
||||
attributes?: OptObj<({
|
||||
[attr: string]: any;
|
||||
})>;
|
||||
ignoreTags?: string[];
|
||||
render?: OptFn<((ir: IntermediateRepresentation) => any)>;
|
||||
};
|
||||
/******************************************************************************
|
||||
Multi-Tokens
|
||||
Tokens composed of arrays of TextTokens
|
||||
******************************************************************************/
|
||||
/**
|
||||
* @param {string} value
|
||||
* @param {Token[]} tokens
|
||||
*/
|
||||
export function MultiToken(value: string, tokens: Token[]): void;
|
||||
export class MultiToken {
|
||||
/******************************************************************************
|
||||
Multi-Tokens
|
||||
Tokens composed of arrays of TextTokens
|
||||
******************************************************************************/
|
||||
/**
|
||||
* @param {string} value
|
||||
* @param {Token[]} tokens
|
||||
*/
|
||||
constructor(value: string, tokens: Token[]);
|
||||
t: string;
|
||||
v: string;
|
||||
tk: Token[];
|
||||
isLink: boolean;
|
||||
/**
|
||||
* Return the string this token represents.
|
||||
* @return {string}
|
||||
*/
|
||||
toString(): string;
|
||||
/**
|
||||
* What should the value for this token be in the `href` HTML attribute?
|
||||
* Returns the `.toString` value by default.
|
||||
* @param {string} [scheme]
|
||||
* @return {string}
|
||||
*/
|
||||
toHref(scheme?: string): string;
|
||||
/**
|
||||
* @param {Options} options Formatting options
|
||||
* @returns {string}
|
||||
*/
|
||||
toFormattedString(options: Options): string;
|
||||
/**
|
||||
*
|
||||
* @param {Options} options
|
||||
* @returns {string}
|
||||
*/
|
||||
toFormattedHref(options: Options): string;
|
||||
/**
|
||||
* The start index of this token in the original input string
|
||||
* @returns {number}
|
||||
*/
|
||||
startIndex(): number;
|
||||
/**
|
||||
* The end index of this token in the original input string (up to this
|
||||
* index but not including it)
|
||||
* @returns {number}
|
||||
*/
|
||||
endIndex(): number;
|
||||
/**
|
||||
Returns an object of relevant values for this token, which includes keys
|
||||
* type - Kind of token ('url', 'email', etc.)
|
||||
* value - Original text
|
||||
* href - The value that should be added to the anchor tag's href
|
||||
attribute
|
||||
@method toObject
|
||||
@param {string} [protocol] `'http'` by default
|
||||
*/
|
||||
toObject(protocol?: string): {
|
||||
type: string;
|
||||
value: string;
|
||||
isLink: boolean;
|
||||
href: string;
|
||||
start: number;
|
||||
end: number;
|
||||
};
|
||||
/**
|
||||
*
|
||||
* @param {Options} options Formatting option
|
||||
*/
|
||||
toFormattedObject(options: Options): {
|
||||
type: string;
|
||||
value: string;
|
||||
isLink: boolean;
|
||||
href: string;
|
||||
start: number;
|
||||
end: number;
|
||||
};
|
||||
/**
|
||||
* Whether this token should be rendered as a link according to the given options
|
||||
* @param {Options} options
|
||||
* @returns {boolean}
|
||||
*/
|
||||
validate(options: Options): boolean;
|
||||
/**
|
||||
* Return an object that represents how this link should be rendered.
|
||||
* @param {Options} options Formattinng options
|
||||
*/
|
||||
render(options: Options): {
|
||||
tagName: any;
|
||||
attributes: {
|
||||
href: any;
|
||||
class: any;
|
||||
target: any;
|
||||
rel: any;
|
||||
};
|
||||
content: string;
|
||||
eventListeners: any;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Utility class for linkify interfaces to apply specified
|
||||
* {@link Opts formatting and rendering options}.
|
||||
*
|
||||
* @param {Opts | Options} [opts] Option value overrides.
|
||||
* @param {(ir: IntermediateRepresentation) => any} [defaultRender] (For
|
||||
* internal use) default render function that determines how to generate an
|
||||
* HTML element based on a link token's derived tagName, attributes and HTML.
|
||||
* Similar to render option
|
||||
*/
|
||||
export function Options(opts?: Opts | Options, defaultRender?: (ir: IntermediateRepresentation) => any): void;
|
||||
export class Options {
|
||||
/**
|
||||
* Utility class for linkify interfaces to apply specified
|
||||
* {@link Opts formatting and rendering options}.
|
||||
*
|
||||
* @param {Opts | Options} [opts] Option value overrides.
|
||||
* @param {(ir: IntermediateRepresentation) => any} [defaultRender] (For
|
||||
* internal use) default render function that determines how to generate an
|
||||
* HTML element based on a link token's derived tagName, attributes and HTML.
|
||||
* Similar to render option
|
||||
*/
|
||||
constructor(opts?: Opts | Options, defaultRender?: (ir: IntermediateRepresentation) => any);
|
||||
/** @protected */
|
||||
o: Required<Opts>;
|
||||
defaultRender: any;
|
||||
ignoreTags: string[];
|
||||
/**
|
||||
* Returns true or false based on whether a token should be displayed as a
|
||||
* link based on the user options.
|
||||
* @param {MultiToken} token
|
||||
* @returns {boolean}
|
||||
*/
|
||||
check(token: MultiToken): boolean;
|
||||
/**
|
||||
* Resolve an option's value based on the value of the option and the given
|
||||
* params. If operator and token are specified and the target option is
|
||||
* callable, automatically calls the function with the given argument.
|
||||
* @template {keyof Opts} K
|
||||
* @param {K} key Name of option to use
|
||||
* @param {string} [operator] will be passed to the target option if it's a
|
||||
* function. If not specified, RAW function value gets returned
|
||||
* @param {MultiToken} [token] The token from linkify.tokenize
|
||||
* @returns {Opts[K] | any}
|
||||
*/
|
||||
get<K extends keyof Opts>(key: K, operator?: string, token?: MultiToken): Opts[K] | any;
|
||||
/**
|
||||
* @template {keyof Opts} L
|
||||
* @param {L} key Name of options object to use
|
||||
* @param {string} [operator]
|
||||
* @param {MultiToken} [token]
|
||||
* @returns {Opts[L] | any}
|
||||
*/
|
||||
getObj<L extends keyof Opts>(key: L, operator?: string, token?: MultiToken): Opts[L] | any;
|
||||
/**
|
||||
* Convert the given token to a rendered element that may be added to the
|
||||
* calling-interface's DOM
|
||||
* @param {MultiToken} token Token to render to an HTML element
|
||||
* @returns {any} Render result; e.g., HTML string, DOM element, React
|
||||
* Component, etc.
|
||||
*/
|
||||
render(token: MultiToken): any;
|
||||
}
|
||||
/**
|
||||
* @template T
|
||||
* @typedef {null | T } Transition
|
||||
*/
|
||||
/**
|
||||
* Define a basic state machine state. j is the list of character transitions,
|
||||
* jr is the list of regex-match transitions, jd is the default state to
|
||||
* transition to t is the accepting token type, if any. If this is the terminal
|
||||
* state, then it does not emit a token.
|
||||
*
|
||||
* The template type T represents the type of the token this state accepts. This
|
||||
* should be a string (such as of the token exports in `text.js`) or a
|
||||
* MultiToken subclass (from `multi.js`)
|
||||
*
|
||||
* @template T
|
||||
* @param {T} [token] Token that this state emits
|
||||
*/
|
||||
export function State<T>(token?: T): void;
|
||||
export class State<T> {
|
||||
/**
|
||||
* @template T
|
||||
* @typedef {null | T } Transition
|
||||
*/
|
||||
/**
|
||||
* Define a basic state machine state. j is the list of character transitions,
|
||||
* jr is the list of regex-match transitions, jd is the default state to
|
||||
* transition to t is the accepting token type, if any. If this is the terminal
|
||||
* state, then it does not emit a token.
|
||||
*
|
||||
* The template type T represents the type of the token this state accepts. This
|
||||
* should be a string (such as of the token exports in `text.js`) or a
|
||||
* MultiToken subclass (from `multi.js`)
|
||||
*
|
||||
* @template T
|
||||
* @param {T} [token] Token that this state emits
|
||||
*/
|
||||
constructor(token?: T);
|
||||
/** @type {{ [input: string]: State<T> }} j */
|
||||
j: {
|
||||
[input: string]: State<T>;
|
||||
};
|
||||
/** @type {[RegExp, State<T>][]} jr */
|
||||
jr: [RegExp, State<T>][];
|
||||
/** @type {?State<T>} jd */
|
||||
jd: State<T> | null;
|
||||
/** @type {?T} t */
|
||||
t: T | null;
|
||||
accepts(): boolean;
|
||||
/**
|
||||
* Follow an existing transition from the given input to the next state.
|
||||
* Does not mutate.
|
||||
* @param {string} input character or token type to transition on
|
||||
* @returns {?State<T>} the next state, if any
|
||||
*/
|
||||
go(input: string): State<T> | null;
|
||||
/**
|
||||
* Whether the state has a transition for the given input. Set the second
|
||||
* argument to true to only look for an exact match (and not a default or
|
||||
* regular-expression-based transition)
|
||||
* @param {string} input
|
||||
* @param {boolean} exactOnly
|
||||
*/
|
||||
has(input: string, exactOnly?: boolean): boolean;
|
||||
/**
|
||||
* Short for "transition all"; create a transition from the array of items
|
||||
* in the given list to the same final resulting state.
|
||||
* @param {string | string[]} inputs Group of inputs to transition on
|
||||
* @param {Transition<T> | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of token groups
|
||||
*/
|
||||
ta(inputs: string | string[], next?: Transition<T> | State<T>, flags?: Flags, groups?: Collections<T>): void;
|
||||
/**
|
||||
* Short for "take regexp transition"; defines a transition for this state
|
||||
* when it encounters a token which matches the given regular expression
|
||||
* @param {RegExp} regexp Regular expression transition (populate first)
|
||||
* @param {T | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of token groups
|
||||
* @returns {State<T>} taken after the given input
|
||||
*/
|
||||
tr(regexp: RegExp, next?: T | State<T>, flags?: Flags, groups?: Collections<T>): State<T>;
|
||||
/**
|
||||
* Short for "take transitions", will take as many sequential transitions as
|
||||
* the length of the given input and returns the
|
||||
* resulting final state.
|
||||
* @param {string | string[]} input
|
||||
* @param {T | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of token groups
|
||||
* @returns {State<T>} taken after the given input
|
||||
*/
|
||||
ts(input: string | string[], next?: T | State<T>, flags?: Flags, groups?: Collections<T>): State<T>;
|
||||
/**
|
||||
* Short for "take transition", this is a method for building/working with
|
||||
* state machines.
|
||||
*
|
||||
* If a state already exists for the given input, returns it.
|
||||
*
|
||||
* If a token is specified, that state will emit that token when reached by
|
||||
* the linkify engine.
|
||||
*
|
||||
* If no state exists, it will be initialized with some default transitions
|
||||
* that resemble existing default transitions.
|
||||
*
|
||||
* If a state is given for the second argument, that state will be
|
||||
* transitioned to on the given input regardless of what that input
|
||||
* previously did.
|
||||
*
|
||||
* Specify a token group flags to define groups that this token belongs to.
|
||||
* The token will be added to corresponding entires in the given groups
|
||||
* object.
|
||||
*
|
||||
* @param {string} input character, token type to transition on
|
||||
* @param {T | State<T>} [next] Transition options
|
||||
* @param {Flags} [flags] Collections flags to add token to
|
||||
* @param {Collections<T>} [groups] Master list of groups
|
||||
* @returns {State<T>} taken after the given input
|
||||
*/
|
||||
tt(input: string, next?: T | State<T>, flags?: Flags, groups?: Collections<T>): State<T>;
|
||||
}
|
||||
export namespace State {
|
||||
export { groups };
|
||||
}
|
||||
/**
|
||||
* Create a new token that can be emitted by the parser state machine
|
||||
* @param {string} type readable type of the token
|
||||
* @param {object} props properties to assign or override, including isLink = true or false
|
||||
* @returns {new (value: string, tokens: Token[]) => MultiToken} new token class
|
||||
*/
|
||||
export function createTokenClass(type: string, props: object): new (value: string, tokens: Token[]) => MultiToken;
|
||||
/**
|
||||
* Find a list of linkable items in the given string.
|
||||
* @param {string} str string to find links in
|
||||
* @param {string | Opts} [type] either formatting options or specific type of
|
||||
* links to find, e.g., 'url' or 'email'
|
||||
* @param {Opts} [opts] formatting options for final output. Cannot be specified
|
||||
* if opts already provided in `type` argument
|
||||
*/
|
||||
export function find(str: string, type?: string | Opts, opts?: Opts): {
|
||||
type: string;
|
||||
value: string;
|
||||
isLink: boolean;
|
||||
href: string;
|
||||
start: number;
|
||||
end: number;
|
||||
}[];
|
||||
/**
|
||||
* Initialize the linkify state machine. Called automatically the first time
|
||||
* linkify is called on a string, but may be called manually as well.
|
||||
*/
|
||||
export function init(): {
|
||||
scanner: any;
|
||||
parser: any;
|
||||
tokenQueue: any[];
|
||||
pluginQueue: any[];
|
||||
customSchemes: any[];
|
||||
initialized: boolean;
|
||||
};
|
||||
export var multi: Readonly<{
|
||||
__proto__: any;
|
||||
Base: typeof MultiToken;
|
||||
Email: new (value: string, tokens: Token[]) => MultiToken;
|
||||
MultiToken: typeof MultiToken;
|
||||
Nl: new (value: string, tokens: Token[]) => MultiToken;
|
||||
Text: new (value: string, tokens: Token[]) => MultiToken;
|
||||
Url: new (value: string, tokens: Token[]) => MultiToken;
|
||||
createTokenClass: typeof createTokenClass;
|
||||
}>;
|
||||
export var options: Readonly<{
|
||||
__proto__: any;
|
||||
Options: typeof Options;
|
||||
defaults: Required<Opts>;
|
||||
}>;
|
||||
export var regexp: Readonly<{
|
||||
__proto__: any;
|
||||
ASCII_LETTER: RegExp;
|
||||
DIGIT: RegExp;
|
||||
EMOJI: RegExp;
|
||||
EMOJI_VARIATION: RegExp;
|
||||
LETTER: RegExp;
|
||||
SPACE: RegExp;
|
||||
}>;
|
||||
/**
|
||||
* Detect URLs with the following additional protocol. Anything with format
|
||||
* "protocol://..." will be considered a link. If `optionalSlashSlash` is set to
|
||||
* `true`, anything with format "protocol:..." will be considered a link.
|
||||
* @param {string} scheme
|
||||
* @param {boolean} [optionalSlashSlash]
|
||||
*/
|
||||
export function registerCustomProtocol(scheme: string, optionalSlashSlash?: boolean): void;
|
||||
/**
|
||||
* Register a linkify plugin
|
||||
* @param {string} name of plugin to register
|
||||
* @param {Plugin} plugin function that accepts the parser state machine and
|
||||
* extends the parser to recognize additional link types
|
||||
*/
|
||||
export function registerPlugin(name: string, plugin: Plugin): void;
|
||||
/**
|
||||
* Register a token plugin to allow the scanner to recognize additional token
|
||||
* types before the parser state machine is constructed from the results.
|
||||
* @param {string} name of plugin to register
|
||||
* @param {TokenPlugin} plugin function that accepts the scanner state machine
|
||||
* and available scanner tokens and collections and extends the state machine to
|
||||
* recognize additional tokens or groups.
|
||||
*/
|
||||
export function registerTokenPlugin(name: string, plugin: TokenPlugin): void;
|
||||
/**
|
||||
* @typedef {{
|
||||
* start: State<string>,
|
||||
* tokens: { groups: Collections<string> } & typeof tk
|
||||
* }} ScannerInit
|
||||
*/
|
||||
/**
|
||||
* @typedef {{
|
||||
* start: State<MultiToken>,
|
||||
* tokens: typeof multi
|
||||
* }} ParserInit
|
||||
*/
|
||||
/**
|
||||
* @typedef {(arg: { scanner: ScannerInit }) => void} TokenPlugin
|
||||
*/
|
||||
/**
|
||||
* @typedef {(arg: { scanner: ScannerInit, parser: ParserInit }) => void} Plugin
|
||||
*/
|
||||
/**
|
||||
* De-register all plugins and reset the internal state-machine. Used for
|
||||
* testing; not required in practice.
|
||||
* @private
|
||||
*/
|
||||
export function reset(): {
|
||||
scanner: any;
|
||||
parser: any;
|
||||
tokenQueue: any[];
|
||||
pluginQueue: any[];
|
||||
customSchemes: any[];
|
||||
initialized: boolean;
|
||||
};
|
||||
/**
|
||||
* Convert a String to an Array of characters, taking into account that some
|
||||
* characters like emojis take up two string indexes.
|
||||
*
|
||||
* Adapted from core-js (MIT license)
|
||||
* https://github.com/zloirock/core-js/blob/2d69cf5f99ab3ea3463c395df81e5a15b68f49d9/packages/core-js/internals/string-multibyte.js
|
||||
*
|
||||
* @function stringToArray
|
||||
* @param {string} str
|
||||
* @returns {string[]}
|
||||
*/
|
||||
export function stringToArray(str: string): string[];
|
||||
/**
|
||||
* Is the given string valid linkable text of some sort. Note that this does not
|
||||
* trim the text for you.
|
||||
*
|
||||
* Optionally pass in a second `type` param, which is the type of link to test
|
||||
* for.
|
||||
*
|
||||
* For example,
|
||||
*
|
||||
* linkify.test(str, 'email');
|
||||
*
|
||||
* Returns `true` if str is a valid email.
|
||||
* @param {string} str string to test for links
|
||||
* @param {string} [type] optional specific link type to look for
|
||||
* @returns boolean true/false
|
||||
*/
|
||||
export function test(str: string, type?: string): boolean;
|
||||
/**
|
||||
* Parse a string into tokens that represent linkable and non-linkable sub-components
|
||||
* @param {string} str
|
||||
* @return {MultiToken[]} tokens
|
||||
*/
|
||||
export function tokenize(str: string): MultiToken[];
|
||||
export namespace tokenize {
|
||||
export { run$1 as scan };
|
||||
}
|
||||
declare var tk: Readonly<{
|
||||
__proto__: any;
|
||||
ALPHANUMERICAL: "ALPHANUMERICAL";
|
||||
AMPERSAND: "AMPERSAND";
|
||||
APOSTROPHE: "APOSTROPHE";
|
||||
ASCIINUMERICAL: "ASCIINUMERICAL";
|
||||
ASTERISK: "ASTERISK";
|
||||
AT: "AT";
|
||||
BACKSLASH: "BACKSLASH";
|
||||
BACKTICK: "BACKTICK";
|
||||
CARET: "CARET";
|
||||
CLOSEANGLEBRACKET: "CLOSEANGLEBRACKET";
|
||||
CLOSEBRACE: "CLOSEBRACE";
|
||||
CLOSEBRACKET: "CLOSEBRACKET";
|
||||
CLOSEPAREN: "CLOSEPAREN";
|
||||
COLON: "COLON";
|
||||
COMMA: "COMMA";
|
||||
DOLLAR: "DOLLAR";
|
||||
DOT: "DOT";
|
||||
EMOJI: "EMOJI";
|
||||
EQUALS: "EQUALS";
|
||||
EXCLAMATION: "EXCLAMATION";
|
||||
FULLWIDTHGREATERTHAN: "FULLWIDTHGREATERTHAN";
|
||||
FULLWIDTHLEFTPAREN: "FULLWIDTHLEFTPAREN";
|
||||
FULLWIDTHLESSTHAN: "FULLWIDTHLESSTHAN";
|
||||
FULLWIDTHMIDDLEDOT: "FULLWIDTHMIDDLEDOT";
|
||||
FULLWIDTHRIGHTPAREN: "FULLWIDTHRIGHTPAREN";
|
||||
HYPHEN: "HYPHEN";
|
||||
LEFTCORNERBRACKET: "LEFTCORNERBRACKET";
|
||||
LEFTWHITECORNERBRACKET: "LEFTWHITECORNERBRACKET";
|
||||
LOCALHOST: "LOCALHOST";
|
||||
NL: "NL";
|
||||
NUM: "NUM";
|
||||
OPENANGLEBRACKET: "OPENANGLEBRACKET";
|
||||
OPENBRACE: "OPENBRACE";
|
||||
OPENBRACKET: "OPENBRACKET";
|
||||
OPENPAREN: "OPENPAREN";
|
||||
PERCENT: "PERCENT";
|
||||
PIPE: "PIPE";
|
||||
PLUS: "PLUS";
|
||||
POUND: "POUND";
|
||||
QUERY: "QUERY";
|
||||
QUOTE: "QUOTE";
|
||||
RIGHTCORNERBRACKET: "RIGHTCORNERBRACKET";
|
||||
RIGHTWHITECORNERBRACKET: "RIGHTWHITECORNERBRACKET";
|
||||
SCHEME: "SCHEME";
|
||||
SEMI: "SEMI";
|
||||
SLASH: "SLASH";
|
||||
SLASH_SCHEME: "SLASH_SCHEME";
|
||||
SYM: "SYM";
|
||||
TILDE: "TILDE";
|
||||
TLD: "TLD";
|
||||
UNDERSCORE: "UNDERSCORE";
|
||||
UTLD: "UTLD";
|
||||
UWORD: "UWORD";
|
||||
WORD: "WORD";
|
||||
WS: "WS";
|
||||
}>;
|
||||
declare var groups: Collections<string>;
|
||||
/**
|
||||
Given a string, returns an array of TOKEN instances representing the
|
||||
composition of that string.
|
||||
|
||||
@method run
|
||||
@param {State<string>} start scanner starting state
|
||||
@param {string} str input string to scan
|
||||
@return {Token[]} list of tokens, each with a type and value
|
||||
*/
|
||||
declare function run$1(start: State<string>, str: string): Token[];
|
||||
export { multi as text };
|
||||
+1862
File diff suppressed because it is too large
Load Diff
+1
File diff suppressed because one or more lines are too long
+1839
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user