proyectos/claudia-docs-web
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: resolve TypeScript errors in frontend build

Browse Source
This commit is contained in:
Hiro
2026-03-30 23:16:07 +00:00
parent b733306773
commit 24925e1acb
2941 changed files with 418042 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
node_modules/linkifyjs/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,19 @@
Copyright (c) 2024 Nick Frasser
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

45
node_modules/linkifyjs/README.md generated vendored Normal file
View File

@@ -0,0 +1,45 @@
linkifyjs
===
[![npm version](https://badge.fury.io/js/linkifyjs.svg)](https://www.npmjs.com/package/linkifyjs)
Core [Linkify](https://linkify.js.org/) JavaScript library. Use Linkify and its
related packages to detect URLs, email addresses and more in plain-text strings and convert them to HTML `<a>` anchor tags.
## Installation
Install from the command line with NPM
```
npm install linkifyjs
```
Import into your JavaScript with `require`
```js
const linkify = require('linkifyjs');
```
or with ES modules
```js
import * as linkify from 'linkifyjs';
```
Separate packages are available for each of the following features:
- [HTML strings](../linkify-html)
- [React component](../linkify-react)
- [jQuery plugin](../linkify-jquery)
- [DOM Elements](../linkify-element)
- [Plain-text](../linkify-string)
- [#hashtag plugin](../linkify-plugin-hashtag)
- [@mention plugin](../linkify-plugin-mention)
- [#ticket plugin](../linkify-plugin-ticket)
- [IP address plugin](../linkify-plugin-ip)
- [Keyword plugin](../linkify-plugin-keyword)
## Usage
[Read the full documentation](https://linkify.js.org/docs/linkifyjs.html).
## License
MIT

1857
node_modules/linkifyjs/dist/linkify.cjs generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

637
node_modules/linkifyjs/dist/linkify.d.cts generated vendored Normal file
View File

@@ -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
node_modules/linkifyjs/dist/linkify.d.mts generated vendored Normal file
View File

@@ -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
node_modules/linkifyjs/dist/linkify.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
node_modules/linkifyjs/dist/linkify.min.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

1839
node_modules/linkifyjs/dist/linkify.mjs generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

38
node_modules/linkifyjs/package.json generated vendored Normal file
View File

@@ -0,0 +1,38 @@
{
"name": "linkifyjs",
"type": "module",
"version": "4.3.2",
"description": "Find URLs, email addresses, #hashtags and @mentions in plain-text strings, then convert them into HTML <a> links.",
"main": "dist/linkify.cjs",
"module": "dist/linkify.mjs",
"scripts": {
"build": "rollup -c rollup.config.js",
"clean": "rm -rf lib dist *.tgz *.d.ts",
"prepack": "run-s clean build tsc",
"tsc": "tsc",
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/nfrasser/linkifyjs.git",
"directory": "packages/linkifyjs"
},
"keywords": [
"autolink",
"email",
"hashtag",
"html",
"jquery",
"link",
"mention",
"react",
"twitter",
"url"
],
"author": "Nick Frasser (https://nfrasser.com)",
"license": "MIT",
"bugs": {
"url": "https://github.com/nfrasser/linkifyjs/issues"
},
"homepage": "https://linkify.js.org"
}