@types/prosemirror-view

  • Version 1.23.3
  • Published
  • 36.6 kB
  • 3 dependencies
  • MIT license

Install

npm i @types/prosemirror-view
yarn add @types/prosemirror-view
pnpm add @types/prosemirror-view

Overview

TypeScript definitions for prosemirror-view

Index

Classes

class Decoration

class Decoration<T extends object = { [key: string]: any }> {}
  • Decoration objects can be provided to the view through the [decorations prop](#view.EditorProps.decorations). They come in several variants—see the static members of this class for details.

property from

from: number;
  • The start position of the decoration.

property spec

spec: {};
  • The spec provided when creating this decoration. Can be useful if you've stored extra information in that object.

property to

to: number;
  • The end position. Will be the same as from for [widget decorations](#view.Decoration^widget).

method inline

static inline: <T extends object = { [key: string]: any }>(
from: number,
to: number,
attrs: DecorationAttrs,
spec?: T & InlineDecorationSpec
) => Decoration<T & InlineDecorationSpec>;
  • Creates an inline decoration, which adds the given attributes to each inline node between from and to.

method node

static node: <T extends object = { [key: string]: any }>(
from: number,
to: number,
attrs: DecorationAttrs,
spec?: T
) => Decoration<T>;
  • Creates a node decoration. from and to should point precisely before and after a node in the document. That node, and only that node, will receive the given attributes.

method widget

static widget: <T extends object = { [key: string]: any }>(
pos: number,
toDOM: Node | ((view: EditorView, getPos: () => number) => Node),
spec?: T & WidgetDecorationSpec
) => Decoration<T & WidgetDecorationSpec>;
  • Creates a widget decoration, which is a DOM node that's shown in the document at the given position. It is recommended that you delay rendering the widget by passing a function that will be called when the widget is actually drawn in a view, but you can also directly pass a DOM node. getPos can be used to find the widget's current document position.

class DecorationSet

class DecorationSet<S extends Schema = any> {}
  • A collection of [decorations](#view.Decoration), organized in such a way that the drawing algorithm can efficiently use and compare them. This is a persistent data structure—it is not modified, updates create a new value.

property empty

static empty: DecorationSet<any>;
  • The empty set of decorations.

method add

add: (doc: ProsemirrorNode<S>, decorations: Decoration[]) => DecorationSet<S>;
  • Add the given array of decorations to the ones in the set, producing a new set. Needs access to the current document to create the appropriate tree structure.

method create

static create: <S extends Schema = any>(
doc: ProsemirrorNode<S>,
decorations: Decoration[]
) => DecorationSet<S>;
  • Create a set of decorations, using the structure of the given document.

method find

find: (
start?: number,
end?: number,
predicate?: (spec: { [key: string]: any }) => boolean
) => Decoration[];
  • Find all decorations in this set which touch the given range (including decorations that start or end directly at the boundaries) and match the given predicate on their spec. When start and end are omitted, all decorations in the set are considered. When predicate isn't given, all decorations are assumed to match.

method map

map: (
mapping: Mapping,
doc: ProsemirrorNode<S>,
options?: { onRemove?: (decorationSpec: { [key: string]: any }) => void }
) => DecorationSet<S>;
  • Map the set of decorations in response to a change in the document.

method remove

remove: (decorations: Decoration[]) => DecorationSet<S>;
  • Create a new set that contains the decorations in this set, minus the ones in the given array.

class EditorView

class EditorView<S extends Schema = any> {}
  • An editor view manages the DOM structure that represents an editable document. Its state and behavior are determined by its [props](#view.DirectEditorProps).

constructor

constructor(
place: Node | ((p: Node) => void) | { mount: Node },
props: DirectEditorProps<S>
);
  • Create a view. place may be a DOM node that the editor should be appended to, a function that will place it into the document, or an object whose mount property holds the node to use as the document container. If it is null, the editor will not be added to the document.

property composing

composing: boolean;
  • Holds true when a composition is active.

property dom

dom: Element;
  • An editable DOM node containing the document. (You probably should not directly interfere with its content.)

property dragging

dragging?: { slice: Slice<S>; move: boolean };
  • When editor content is being dragged, this object contains information about the dragged slice and whether it is being copied or moved. At any other time, it is null.

property editable

editable: boolean;
  • Indicates whether the editor is currently [editable](#view.EditorProps.editable).

property isDestroyed

isDestroyed: boolean;
  • This is true when the view has been [destroyed](#view.EditorView.destroy) (and thus should not be used anymore).

property props

props: DirectEditorProps<S>;
  • The view's current [props](#view.EditorProps).

property root

root: Document | DocumentFragment;
  • Get the document root in which the editor exists. This will usually be the top-level document, but might be a [shadow DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Shadow_DOM) root if the editor is inside one.

property state

state: EditorState<S>;
  • The view's current [state](#state.EditorState).

method coordsAtPos

coordsAtPos: (
pos: number,
side?: number
) => { left: number; right: number; top: number; bottom: number };
  • Returns the viewport rectangle at a given document position. left and right will be the same number, as this returns a flat cursor-ish rectangle. If the position is between two things that aren't directly adjacent, side determines which element is used. When < 0, the element before the position is used, otherwise the element after.

method destroy

destroy: () => void;
  • Removes the editor from the DOM and destroys all [node views](#view.NodeView).

method dispatch

dispatch: (tr: Transaction<S>) => void;
  • Dispatch a transaction. Will call [dispatchTransaction](#view.DirectEditorProps.dispatchTransaction) when given, and otherwise defaults to applying the transaction to the current state and calling [updateState](#view.EditorView.updateState) with the result. This method is bound to the view instance, so that it can be easily passed around.

method domAtPos

domAtPos: (pos: number, side?: number) => { node: Node; offset: number };
  • Find the DOM position that corresponds to the given document position. When side is negative, find the position as close as possible to the content before the position. When positive, prefer positions close to the content after the position. When zero, prefer as shallow a position as possible.

    Note that you should **not** mutate the editor's internal DOM, only inspect it (and even that is usually not necessary).

method endOfTextblock

endOfTextblock: (
dir: 'up' | 'down' | 'left' | 'right' | 'forward' | 'backward',
state?: EditorState<S>
) => boolean;
  • Find out whether the selection is at the end of a textblock when moving in a given direction. When, for example, given "left", it will return true if moving left from the current cursor position would leave that position's parent textblock. Will apply to the view's current state by default, but it is possible to pass a different state.

method focus

focus: () => void;
  • Focus the editor.

method hasFocus

hasFocus: () => boolean;
  • Query whether the view has focus.

method nodeDOM

nodeDOM: (pos: number) => Node | null | undefined;
  • Find the DOM node that represents the document node after the given position. May return null when the position doesn't point in front of a node or if the node is inside an opaque node view.

    This is intended to be able to call things like getBoundingClientRect on that DOM node. Do not mutate the editor DOM directly, or add styling this way, since that will be immediately overriden by the editor as it redraws the node.

method posAtCoords

posAtCoords: (coords: {
left: number;
top: number;
}) => { pos: number; inside: number } | null | undefined;
  • Given a pair of viewport coordinates, return the document position that corresponds to them. May return null if the given coordinates aren't inside of the editor. When an object is returned, its pos property is the position nearest to the coordinates, and its inside property holds the position of the inner node that the position falls inside of, or -1 if it is at the top level, not in any node.

method posAtDOM

posAtDOM: (node: Node, offset: number, bias?: number | null) => number;
  • Find the document position that corresponds to a given DOM position. (Whenever possible, it is preferable to inspect the document structure directly, rather than poking around in the DOM, but sometimes—for example when interpreting an event target—you don't have a choice.)

    The bias (default: -1) parameter can be used to influence which side of a DOM node to use when the position is inside a leaf node.

method setProps

setProps: (props: Partial<DirectEditorProps<S>>) => void;
  • Update the view by updating existing props object with the object given as argument. Equivalent to `view.update(Object.assign({}, view.props, props))`.

method someProp

someProp: (propName: string, f?: (prop: any) => any) => any;
  • Goes over the values of a prop, first those provided directly, then those from plugins (in order), and calls f every time a non-undefined value is found. When f returns a truthy value, that is immediately returned. When f isn't provided, it is treated as the identity function (the prop value is returned directly).

method update

update: (props: DirectEditorProps<S>) => void;
  • Update the view's props. Will immediately cause an update to the DOM.

method updateState

updateState: (state: EditorState<S>) => void;
  • Update the editor's state prop, without touching any of the other props.

Interfaces

interface DecorationAttrs

interface DecorationAttrs {}
  • A set of attributes to add to a decorated node. Most properties simply directly correspond to DOM attributes of the same name, which will be set to the property's value. These are exceptions:

property class

class?: string | null | undefined;
  • A CSS class name or a space-separated set of class names to be _added_ to the classes that the node already had.

property nodeName

nodeName?: string | null | undefined;
  • When non-null, the target node is wrapped in a DOM element of this type (and the other attributes are applied to this element).

property style

style?: string | null | undefined;
  • A string of CSS to be _added_ to the node's existing style property.

index signature

[key: string]: string | null | undefined;
  • Specify additional attrs that will be mapped directly to the target node's DOM attributes.

interface DirectEditorProps

interface DirectEditorProps<S extends Schema = any>
extends EditorProps<unknown, S> {}
  • The props object given directly to the editor view supports some fields that can't be used in plugins:

property dispatchTransaction

dispatchTransaction?:
| ((this: EditorView<S>, tr: Transaction<S>) => void)
| null
| undefined;
  • The callback over which to send transactions (state updates) produced by the view. If you specify this, you probably want to make sure this ends up calling the view's [updateState](#view.EditorView.updateState) method with a new state that has the transaction [applied](#state.EditorState.apply). The callback will be bound to have the view instance as its this binding.

property plugins

plugins?: Plugin[];
  • A set of plugins to use in the view, applying their [plugin view](#state.PluginSpec.view) and [props](#state.PluginSpec.props). Passing plugins with a state component (a [state field](#state.PluginSpec.state) field or a [transaction](#state.PluginSpec.filterTransaction) filter or appender) will result in an error, since such plugins must be present in the state to work.

property state

state: EditorState<S>;
  • The current state of the editor.

interface EditorProps

interface EditorProps<ThisT = unknown, S extends Schema = any> {}
  • Props are configuration values that can be passed to an editor view or included in a plugin. This interface lists the supported props.

    The various event-handling functions may all return true to indicate that they handled the given event. The view will then take care to call preventDefault on the event, except with handleDOMEvents, where the handler itself is responsible for that.

    How a prop is resolved depends on the prop. Handler functions are called one at a time, starting with the base props and then searching through the plugins (in order of appearance) until one of them returns true. For some props, the first plugin that yields a value gets precedence.

property attributes

attributes?:
| { [name: string]: string }
| ((
this: ThisT,
p: EditorState<S>
) => { [name: string]: string } | null | undefined | void)
| null
| undefined;
  • Control the DOM attributes of the editable element. May be either an object or a function going from an editor state to an object. By default, the element will get a class "ProseMirror", and will have its contentEditable attribute determined by the [editable prop](#view.EditorProps.editable). Additional classes provided here will be added to the class. For other attributes, the value provided first (as in [someProp](#view.EditorView.someProp)) will be used.

property clipboardParser

clipboardParser?: DOMParser<S> | null | undefined;
  • The [parser](#model.DOMParser) to use when reading content from the clipboard. When not given, the value of the [domParser](#view.EditorProps.domParser) prop is used.

property clipboardSerializer

clipboardSerializer?: DOMSerializer<S> | null | undefined;
  • The DOM serializer to use when putting content onto the clipboard. If not given, the result of [DOMSerializer.fromSchema](#model.DOMSerializer^fromSchema) will be used.

property clipboardTextParser

clipboardTextParser?:
| ((
this: ThisT,
text: string,
$context: ResolvedPos<S>,
plain: boolean
) => Slice<S>)
| null
| undefined;
  • A function to parse text from the clipboard into a document slice. Called after [transformPastedText](#view.EditorProps.transformPastedText). The default behavior is to split the text into lines, wrap them in <p> tags, and call [clipboardParser](#view.EditorProps.clipboardParser) on it. The plain flag will be true when the text is pasted as plain text.

property clipboardTextSerializer

clipboardTextSerializer?:
| ((this: ThisT, p: Slice<S>) => string)
| null
| undefined;
  • A function that will be called to get the text for the current selection when copying text to the clipboard. By default, the editor will use [textBetween](#model.Node.textBetween) on the selected range.

property createSelectionBetween

createSelectionBetween?:
| ((
this: ThisT,
view: EditorView<S>,
anchor: ResolvedPos<S>,
head: ResolvedPos<S>
) => Selection<S> | null | undefined)
| null
| undefined;
  • Can be used to override the way a selection is created when reading a DOM selection between the given anchor and head.

property decorations

decorations?:
| ((
this: ThisT,
state: EditorState<S>
) => DecorationSet<S> | null | undefined)
| null
| undefined;
  • A set of [document decorations](#view.Decoration) to show in the view.

property domParser

domParser?: DOMParser<S> | null | undefined;
  • The [parser](#model.DOMParser) to use when reading editor changes from the DOM. Defaults to calling [DOMParser.fromSchema](#model.DOMParser^fromSchema) on the editor's schema.

property editable

editable?: ((this: ThisT, state: EditorState<S>) => boolean) | null | undefined;
  • When this returns false, the content of the view is not directly editable.

property handleClick

handleClick?:
| ((
this: ThisT,
view: EditorView<S>,
pos: number,
event: MouseEvent
) => boolean)
| null
| undefined;
  • Called when the editor is clicked, after handleClickOn handlers have been called.

property handleClickOn

handleClickOn?:
| ((
this: ThisT,
view: EditorView<S>,
pos: number,
node: ProsemirrorNode<S>,
nodePos: number,
event: MouseEvent,
direct: boolean
) => boolean)
| null
| undefined;
  • Called for each node around a click, from the inside out. The direct flag will be true for the inner node.

property handleDOMEvents

handleDOMEvents?: HandleDOMEventsProp<ThisT, S> | null | undefined;
  • Can be an object mapping DOM event type names to functions that handle them. Such functions will be called before any handling ProseMirror does of events fired on the editable DOM element. Contrary to the other event handling props, when returning true from such a function, you are responsible for calling preventDefault yourself (or not, if you want to allow the default behavior).

property handleDoubleClick

handleDoubleClick?:
| ((
this: ThisT,
view: EditorView<S>,
pos: number,
event: MouseEvent
) => boolean)
| null
| undefined;
  • Called when the editor is double-clicked, after handleDoubleClickOn.

property handleDoubleClickOn

handleDoubleClickOn?:
| ((
this: ThisT,
view: EditorView<S>,
pos: number,
node: ProsemirrorNode<S>,
nodePos: number,
event: MouseEvent,
direct: boolean
) => boolean)
| null
| undefined;
  • Called for each node around a double click.

property handleDrop

handleDrop?:
| ((
this: ThisT,
view: EditorView<S>,
event: Event,
slice: Slice<S>,
moved: boolean
) => boolean)
| null
| undefined;
  • Called when something is dropped on the editor. moved will be true if this drop moves from the current selection (which should thus be deleted).

property handleKeyDown

handleKeyDown?:
| ((this: ThisT, view: EditorView<S>, event: KeyboardEvent) => boolean)
| null
| undefined;
  • Called when the editor receives a keydown event.

property handleKeyPress

handleKeyPress?:
| ((this: ThisT, view: EditorView<S>, event: KeyboardEvent) => boolean)
| null
| undefined;
  • Handler for keypress events.

property handlePaste

handlePaste?:
| ((
this: ThisT,
view: EditorView<S>,
event: ClipboardEvent,
slice: Slice<S>
) => boolean)
| null
| undefined;
  • Can be used to override the behavior of pasting. slice is the pasted content parsed by the editor, but you can directly access the event to get at the raw content.

property handleScrollToSelection

handleScrollToSelection?:
| ((this: ThisT, view: EditorView<S>) => boolean)
| null
| undefined;
  • Called when the view, after updating its state, tries to scroll the selection into view. A handler function may return false to indicate that it did not handle the scrolling and further handlers or the default behavior should be tried.

property handleTextInput

handleTextInput?:
| ((
this: ThisT,
view: EditorView<S>,
from: number,
to: number,
text: string
) => boolean)
| null
| undefined;
  • Whenever the user directly input text, this handler is called before the input is applied. If it returns true, the default behavior of actually inserting the text is suppressed.

property handleTripleClick

handleTripleClick?:
| ((
this: ThisT,
view: EditorView<S>,
pos: number,
event: MouseEvent
) => boolean)
| null
| undefined;
  • Called when the editor is triple-clicked, after handleTripleClickOn.

property handleTripleClickOn

handleTripleClickOn?:
| ((
this: ThisT,
view: EditorView<S>,
pos: number,
node: ProsemirrorNode<S>,
nodePos: number,
event: MouseEvent,
direct: boolean
) => boolean)
| null
| undefined;
  • Called for each node around a triple click.

property nodeViews

nodeViews?:
| {
[name: string]:
| ((
node: ProsemirrorNode<S>,
view: EditorView<S>,
/** get the node's current position */
getPos: () => number,
decorations: Decoration[]
) => NodeView<S>)
| ((
mark: Mark<S>,
view: EditorView<S>,
/** indicates whether the mark's content is inline */
inline: boolean
) => Pick<NodeView<S>, 'dom' | 'contentDOM'>);
}
| null
| undefined;
  • Allows you to pass custom rendering and behavior logic for nodes and marks. Should map node and mark names to constructor functions that produce a [NodeView](#view.NodeView) object implementing the node's display behavior. For nodes, the third argument getPos is a function that can be called to get the node's current position, which can be useful when creating transactions to update it. For marks, the third argument is a boolean that indicates whether the mark's content is inline.

    decorations is an array of node or inline decorations that are active around the node. They are automatically drawn in the normal way, and you will usually just want to ignore this, but they can also be used as a way to provide context information to the node view without adding it to the document itself.

property scrollMargin

scrollMargin?:
| number
| { top: number; right: number; bottom: number; left: number }
| null
| undefined;
  • Determines the extra space (in pixels) that is left above or below the cursor when it is scrolled into view. Defaults to 5.

property scrollThreshold

scrollThreshold?:
| number
| { top: number; right: number; bottom: number; left: number }
| null
| undefined;
  • Determines the distance (in pixels) between the cursor and the end of the visible viewport at which point, when scrolling the cursor into view, scrolling takes place. Defaults to 0.

property transformPasted

transformPasted?: ((this: ThisT, p: Slice<S>) => Slice<S>) | null | undefined;
  • Can be used to transform pasted content before it is applied to the document.

property transformPastedHTML

transformPastedHTML?: ((this: ThisT, html: string) => string) | null | undefined;
  • Can be used to transform pasted HTML text, _before_ it is parsed, for example to clean it up.

property transformPastedText

transformPastedText?:
| ((this: ThisT, text: string, plain: boolean) => string)
| null
| undefined;
  • Transform pasted plain text. The plain flag will be true when the text is pasted as plain text.

interface InlineDecorationSpec

interface InlineDecorationSpec {}
  • The spec for the inline decoration.

property inclusiveEnd

inclusiveEnd?: boolean | null | undefined;
  • Determines how the right side of the decoration is mapped.

property inclusiveStart

inclusiveStart?: boolean | null | undefined;
  • Determines how the left side of the decoration is [mapped](#transform.Position_Mapping) when content is inserted directly at that position. By default, the decoration won't include the new content, but you can set this to true to make it inclusive.

interface NodeView

interface NodeView<S extends Schema = any> {}
  • By default, document nodes are rendered using the result of the [toDOM](#model.NodeSpec.toDOM) method of their spec, and managed entirely by the editor. For some use cases, such as embedded node-specific editing interfaces, you want more control over the behavior of a node's in-editor representation, and need to [define](#view.EditorProps.nodeViews) a custom node view.

    Objects returned as node views must conform to this interface.

property contentDOM

contentDOM?: Node | null | undefined;
  • The DOM node that should hold the node's content. Only meaningful if the node view also defines a dom property and if its node type is not a leaf node type. When this is present, ProseMirror will take care of rendering the node's children into it. When it is not present, the node view itself is responsible for rendering (or deciding not to render) its child nodes.

property deselectNode

deselectNode?: (() => void) | null | undefined;
  • When defining a selectNode method, you should also provide a deselectNode method to remove the effect again.

property destroy

destroy?: (() => void) | null | undefined;
  • Called when the node view is removed from the editor or the whole editor is destroyed.

property dom

dom?: Node | null | undefined;
  • The outer DOM node that represents the document node. When not given, the default strategy is used to create a DOM node.

property ignoreMutation

ignoreMutation?:
| ((
p:
| MutationRecord
| {
type: 'selection';
target: Element;
}
) => boolean)
| null
| undefined;
  • Called when a DOM [mutation](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver) or a selection change happens within the view. When the change is a selection change, the record will have a type property of "selection" (which doesn't occur for native mutation records). Return false if the editor should re-read the selection or re-parse the range around the mutation, true if it can safely be ignored.

property selectNode

selectNode?: (() => void) | null | undefined;
  • Can be used to override the way the node's selected status (as a node selection) is displayed.

property setSelection

setSelection?:
| ((anchor: number, head: number, root: Document) => void)
| null
| undefined;
  • This will be called to handle setting the selection inside the node. The anchor and head positions are relative to the start of the node. By default, a DOM selection will be created between the DOM positions corresponding to those positions, but if you override it you can do something else.

property stopEvent

stopEvent?: ((event: Event) => boolean) | null | undefined;
  • Can be used to prevent the editor view from trying to handle some or all DOM events that bubble up from the node view. Events for which this returns true are not handled by the editor.

property update

update?:
| ((
node: ProsemirrorNode<S>,
decorations: Decoration[],
innerDecorations: DecorationSet
) => boolean)
| null
| undefined;
  • When given, this will be called when the view is updating itself. It will be given a node (possibly of a different type), and an array of active decorations (which are automatically drawn, and the node view may ignore if it isn't interested in them), and should return true if it was able to update to that node, and false otherwise. If the node view has a contentDOM property (or no dom property), updating its child nodes will be handled by ProseMirror.

interface WidgetDecorationSpec

interface WidgetDecorationSpec {}
  • The spec for a widget decoration

property destroy

destroy?: (node: Node) => void;
  • Called when the widget decoration is removed as a result of mapping

property ignoreSelection

ignoreSelection?: boolean;
  • When set (defaults to false), selection changes inside the widget are ignored, and don't cause ProseMirror to try and re-sync the selection with its selection state.

property key

key?: string | null | undefined;
  • When comparing decorations of this type (in order to decide whether it needs to be redrawn), ProseMirror will by default compare the widget DOM node by identity. If you pass a key, that key will be compared instead, which can be useful when you generate decorations on the fly and don't want to store and reuse DOM nodes. Make sure that any widgets with the same key are interchangeable—if widgets differ in, for example, the behavior of some event handler, they should get different keys.

property marks

marks?: Mark[] | null | undefined;
  • The precise set of marks to draw around the widget.

property side

side?: number | null | undefined;
  • Controls which side of the document position this widget is associated with. When negative, it is drawn before a cursor at its position, and content inserted at that position ends up after the widget. When zero (the default) or positive, the widget is drawn after the cursor and content inserted there ends up before the widget.

    When there are multiple widgets at a given position, their side values determine the order in which they appear. Those with lower values appear first. The ordering of widgets with the same side value is unspecified.

    When marks is null, side also determines the marks that the widget is wrapped in—those of the node before when negative, those of the node after when positive.

property stopEvent

stopEvent?: ((event: Event) => boolean) | null | undefined;
  • Can be used to control which DOM events, when they bubble out of this widget, the editor view should ignore.

Type Aliases

type HandleDOMEventsProp

type HandleDOMEventsProp<ThisT = unknown, S extends Schema = any> = Partial<{
[K in keyof DocumentEventMap]: (
this: ThisT,
view: EditorView<S>,
event: DocumentEventMap[K]
) => boolean;
}> & {
[key: string]: (this: ThisT, view: EditorView<S>, event: any) => boolean;
};
  • A mapping of dom events.

Package Files (1)

Dependencies (3)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/prosemirror-view.

  • Markdown
    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/prosemirror-view)
  • HTML
    <a href="https://www.jsdocs.io/package/@types/prosemirror-view"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>