suneditor 3.0.0-alpha.9 → 3.0.0-beta.2

package/types/helper/dom/domUtils.d.ts

@@ -0,0 +1,226 @@
+/**
+ * @template {Node} T
+ * @description Clones a node while preserving its type.
+ * @param {T} node - The node to clone.
+ * @param {boolean} [deep=false] - Whether to perform a deep clone.
+ * @returns {T} - The cloned node.
+ */
+export function clone<T extends Node>(node: T, deep?: boolean): T;
+/**
+ * @template {HTMLElement} T
+ * @description Create Element node
+ * @param {string} elementName Element name
+ * @param {?Object<string, string>=} attributes The attributes of the tag. {style: 'font-size:12px;..', class: 'el_class',..}
+ * @param {?string|Node=} inner A innerHTML string or inner node.
+ * @returns {T}
+ */
+export function createElement<T extends HTMLElement>(
+	elementName: string,
+	attributes?:
+		| ({
+				[x: string]: string;
+		  } | null)
+		| undefined,
+	inner?: ((string | Node) | null) | undefined
+): T;
+/**
+ * @description Create text node
+ * @param {string} text text content
+ * @returns {Text}
+ */
+export function createTextNode(text: string): Text;
+/**
+ * @description Get attributes of argument element to string ('class="---" name="---" ')
+ * @param {Node} element Element object
+ * @param {Array<string>|null} exceptAttrs Array of attribute names to exclude from the result
+ * @returns {string}
+ */
+export function getAttributesToString(element: Node, exceptAttrs: Array<string> | null): string;
+/**
+ * @description Get the items array from the array that matches the condition.
+ * @param {__se__NodeCollection} array Array to get item
+ * @param {?(current: *) => boolean} validation Conditional function
+ * @returns {Array<Node>|null}
+ */
+export function arrayFilter(array: __se__NodeCollection, validation: ((current: any) => boolean) | null): Array<Node> | null;
+/**
+ * @description Get the item from the array that matches the condition.
+ * @param {__se__NodeCollection} array Array to get item
+ * @param {?(current: *) => boolean} validation Conditional function
+ * @returns {Node|null}
+ */
+export function arrayFind(array: __se__NodeCollection, validation: ((current: any) => boolean) | null): Node | null;
+/**
+ * @description Check if an array contains an element
+ * @param {__se__NodeCollection} array element array
+ * @param {Node} node The node to check for
+ * @returns {boolean}
+ */
+export function arrayIncludes(array: __se__NodeCollection, node: Node): boolean;
+/**
+ * @description Get the index of the argument value in the element array
+ * @param {__se__NodeCollection} array element array
+ * @param {Node} node The element to find index
+ * @returns {number}
+ */
+export function getArrayIndex(array: __se__NodeCollection, node: Node): number;
+/**
+ * @description Get the next index of the argument value in the element array
+ * @param {__se__NodeCollection} array element array
+ * @param {Node} item The element to find index
+ * @returns {number}
+ */
+export function nextIndex(array: __se__NodeCollection, item: Node): number;
+/**
+ * @description Get the previous index of the argument value in the element array
+ * @param {__se__NodeCollection} array Element array
+ * @param {Node} item The element to find index
+ * @returns {number}
+ */
+export function prevIndex(array: __se__NodeCollection, item: Node): number;
+/**
+ * @description Add style and className of copyEl to originEl
+ * @param {Node} originEl Origin element
+ * @param {Node} copyEl Element to copy
+ * @param {?Array<string>=} blacklist Blacklist array(LowerCase)
+ */
+export function copyTagAttributes(originEl: Node, copyEl: Node, blacklist?: (Array<string> | null) | undefined): void;
+/**
+ * @description Copy and apply attributes of format tag that should be maintained. (style, class) Ignore "__se__format__" class
+ * @param {Node} originEl Origin element
+ * @param {Node} copyEl Element to copy
+ */
+export function copyFormatAttributes(originEl: Node, copyEl: Node): void;
+/**
+ * @description Delete argumenu value element
+ * @param {Node} item Node to be remove
+ */
+export function removeItem(item: Node): void;
+/**
+ * @description Replace element
+ * @param {Node} element Target element
+ * @param {string|Node} newElement String or element of the new element to apply
+ */
+export function changeElement(element: Node, newElement: string | Node): void;
+/**
+ * @description Set the text content value of the argument value element
+ * @param {Node} node Element to replace text content
+ * @param {string} txt Text to be applied
+ */
+export function changeTxt(node: Node, txt: string): void;
+/**
+ * @description Set style, if all styles are deleted, the style properties are deleted.
+ * @param {Node|Node[]} elements Element to set style
+ * @param {string} styleName Style attribute name (marginLeft, textAlign...)
+ * @param {string|number} value Style value
+ */
+export function setStyle(elements: Node | Node[], styleName: string, value: string | number): void;
+/**
+ * @description In the predefined code view mode, the buttons except the executable button are changed to the 'disabled' state.
+ * @param {Array<HTMLButtonElement|HTMLInputElement>} buttonList (Button | Input) Element array
+ * @param {boolean} disabled Disabled value
+ * @param {boolean} [important=false] If priveleged mode should be used (Necessary to switch importantDisabled buttons)
+ */
+export function setDisabled(buttonList: Array<HTMLButtonElement | HTMLInputElement>, disabled: boolean, important?: boolean): void;
+/**
+ * @description Determine whether any of the matched elements are assigned the given class
+ * @param {?Node} element Elements to search class name
+ * @param {string} className Class name to search for
+ * @returns {boolean}
+ */
+export function hasClass(element: Node | null, className: string): boolean;
+/**
+ * @description Append the className value of the argument value element
+ * @param {Node|__se__NodeCollection} element Elements to add class name
+ * @param {string} className Class name to be add
+ */
+export function addClass(element: Node | __se__NodeCollection, className: string): void;
+/**
+ * @description Delete the className value of the argument value element
+ * @param {Node|__se__NodeCollection} element Elements to remove class name
+ * @param {string} className Class name to be remove
+ */
+export function removeClass(element: Node | __se__NodeCollection, className: string): void;
+/**
+ * @description Argument value If there is no class name, insert it and delete the class name if it exists
+ * @param {Node} element Element to replace class name
+ * @param {string} className Class name to be change
+ * @returns {boolean|undefined}
+ */
+export function toggleClass(element: Node, className: string): boolean | undefined;
+/**
+ * @description Flash the class name of the argument value element for a certain time
+ * @param {Node} element Element to flash class name
+ * @param {string} className class name
+ * @param {number} [duration=120] duration milliseconds
+ */
+export function flashClass(element: Node, className: string, duration?: number): void;
+/**
+ * @description Gets the size of the documentElement client size.
+ * @param {Document} doc Document object
+ * @returns {{w: number, h: number}} documentElement.clientWidth, documentElement.clientHeight
+ */
+export function getClientSize(doc?: Document): {
+	w: number;
+	h: number;
+};
+/**
+ * @description Gets the size of the window visualViewport size
+ * @returns {{top: number, left: number, scale: number}}
+ */
+export function getViewportSize(): {
+	top: number;
+	left: number;
+	scale: number;
+};
+/**
+ * @description Copies the "wwTarget" element and returns it with inline all styles applied.
+ * @param {Node} wwTarget Target element to copy(.sun-editor.sun-editor-editable)
+ * @param {boolean} includeWW Include the "wwTarget" element in the copy
+ * @param {Array<string>} styles Style list - kamel case
+ * @returns
+ */
+export function applyInlineStylesAll(wwTarget: Node, includeWW: boolean, styles: Array<string>): HTMLElement;
+/**
+ * @description Wait for media elements to load
+ * @param {Node} target Target element
+ * @param {number} timeout Timeout milliseconds
+ * @returns {Promise<void>}
+ */
+export function waitForMediaLoad(target: Node, timeout?: number): Promise<void>;
+/**
+ * @description Create tooltip HTML
+ * @param {string} text Tooltip text
+ * @returns {string} Tooltip HTML
+ */
+export function createTooltipInner(text: string): string;
+export default utils;
+declare namespace utils {
+	export { clone };
+	export { createElement };
+	export { createTextNode };
+	export { getAttributesToString };
+	export { arrayFilter };
+	export { arrayFind };
+	export { arrayIncludes };
+	export { getArrayIndex };
+	export { nextIndex };
+	export { prevIndex };
+	export { copyTagAttributes };
+	export { copyFormatAttributes };
+	export { removeItem };
+	export { changeElement };
+	export { changeTxt };
+	export { setStyle };
+	export { setDisabled };
+	export { hasClass };
+	export { addClass };
+	export { removeClass };
+	export { toggleClass };
+	export { flashClass };
+	export { getClientSize };
+	export { getViewportSize };
+	export { applyInlineStylesAll };
+	export { waitForMediaLoad };
+	export { createTooltipInner };
+}

package/types/helper/dom/index.d.ts

@@ -0,0 +1,9 @@
+export default dom;
+declare namespace dom {
+	export { query };
+	export { check };
+	export { utils };
+}
+import query from './domQuery';
+import check from './domCheck';
+import utils from './domUtils';

package/types/helper/env.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @description Gets XMLHttpRequest object
+ * @returns {XMLHttpRequest}
+ */
+export function getXMLHttpRequest(): XMLHttpRequest;
+/**
+ * @deprecated
+ * @description Returns the CSS text that has been applied to the current page.
+ * @param {Document|null} doc To get the CSS text of an document. If null get the current document.
+ * @returns {string} Styles string
+ */
+export function getPageStyle(doc: Document | null): string;
+/**
+ * @deprecated
+ * @description Get the the tag path of the arguments value
+ * @param {Array<string>} nameArray File name array
+ * @param {string} extension js, css
+ * @returns {string} If not found, return the first found value
+ */
+export function getIncludePath(nameArray: Array<string>, extension: string): string;
+/**
+ * @fileoverview Environment  helper functions
+ */
+/** @type {Window} */
+export const _w: Window;
+/** @type {Document} */
+export const _d: Document;
+/**
+ * @description No event symbol
+ * @type {Symbol}
+ */
+export const NO_EVENT: symbol;
+/**
+ * @description On over component symbol
+ * @type {Symbol}
+ */
+export const ON_OVER_COMPONENT: symbol;
+/** --- Check browser --- */
+/**
+ * @description Check if support ResizeObserver function
+ * @returns {boolean} Whether support ResizeObserver function or not.
+ */
+export const isResizeObserverSupported: boolean;
+/**
+ * @description Check if support navigator.clipboard
+ * @returns {boolean} Whether support navigator.clipboard or not.
+ */
+export const isClipboardSupported: boolean;
+/**
+ * @description Check if User Agent is Edge
+ * @returns {boolean} Whether User Agent is Edge or not.
+ */
+export const isEdge: boolean;
+/**
+ * @description Check if User Agent is OSX or IOS
+ * @type {boolean}
+ */
+export const isOSX_IOS: boolean;
+/**
+ * @description Check if User Agent Blink engine.
+ * @type {boolean}
+ */
+export const isBlink: boolean;
+/**
+ * @description Check if User Agent is Firefox (Gecko).
+ * @type {boolean}
+ */
+export const isGecko: boolean;
+/**
+ * @description Check if User Agent is Chromium browser.
+ * @type {boolean}
+ */
+export const isChromium: boolean;
+/**
+ * @description Check if User Agent is Safari.
+ * @type {boolean}
+ */
+export const isSafari: boolean;
+/**
+ * @description Check if User Agent is Mobile device.
+ * - when the device is touchable, it is judged as a mobile device.
+ * @type {boolean}
+ */
+export const isMobile: boolean;
+/**
+ * @description Check if User Agent is Android mobile device.
+ * @type {boolean}
+ */
+export const isAndroid: boolean;
+/**
+ * @description Command(Mac) or CTRL(Window) icon.
+ * @type {string}
+ */
+export const cmdIcon: string;
+/**
+ * @description SHIFT(Mac, Window) icon.
+ * @type {string}
+ */
+export const shiftIcon: string;
+/**
+ * @description Device pixel ratio
+ * @type {number}
+ */
+export const DPI: number;
+/** --- editor env --- */
+export const KATEX_WEBSITE: 'https://katex.org/docs/supported.html';
+export const MATHJAX_WEBSITE: 'https://www.mathjax.org/';
+export default env;
+declare namespace env {
+	export { _w };
+	export { _d };
+	export { NO_EVENT };
+	export { ON_OVER_COMPONENT };
+	export { getXMLHttpRequest };
+	export { getPageStyle };
+	export { getIncludePath };
+	export { isResizeObserverSupported };
+	export { isClipboardSupported };
+	export { isEdge };
+	export { isBlink };
+	export { isGecko };
+	export { isChromium };
+	export { isSafari };
+	export { isOSX_IOS };
+	export { isAndroid };
+	export { isMobile };
+	export { cmdIcon };
+	export { shiftIcon };
+	export { DPI };
+	export { KATEX_WEBSITE };
+	export { MATHJAX_WEBSITE };
+}

package/types/helper/index.d.ts

@@ -0,0 +1,174 @@
+export const env: {
+	_w: Window;
+	_d: Document;
+	NO_EVENT: symbol;
+	ON_OVER_COMPONENT: symbol;
+	getXMLHttpRequest: typeof import('./env').getXMLHttpRequest;
+	getPageStyle: typeof import('./env').getPageStyle;
+	getIncludePath: typeof import('./env').getIncludePath;
+	isResizeObserverSupported: boolean;
+	isClipboardSupported: boolean;
+	isEdge: boolean;
+	isBlink: boolean;
+	isGecko: boolean;
+	isChromium: boolean;
+	isSafari: boolean;
+	isOSX_IOS: boolean;
+	isAndroid: boolean;
+	isMobile: boolean;
+	cmdIcon: string;
+	shiftIcon: string;
+	DPI: number;
+	KATEX_WEBSITE: string;
+	MATHJAX_WEBSITE: string;
+};
+export const unicode: {
+	zeroWidthSpace: string;
+	zeroWidthRegExp: RegExp;
+	onlyZeroWidthRegExp: RegExp;
+	escapeStringRegexp: typeof import('./unicode').escapeStringRegexp;
+};
+export const converter: {
+	htmlToJson: typeof import('./converter').htmlToJson;
+	jsonToHtml: typeof import('./converter').jsonToHtml;
+	htmlToEntity: typeof import('./converter').htmlToEntity;
+	entityToHTML: typeof import('./converter').entityToHTML;
+	debounce: typeof import('./converter').debounce;
+	syncMaps: typeof import('./converter').syncMaps;
+	getValues: typeof import('./converter').getValues;
+	camelToKebabCase: typeof import('./converter').camelToKebabCase;
+	kebabToCamelCase: typeof import('./converter').kebabToCamelCase;
+	toFontUnit: typeof import('./converter').toFontUnit;
+	nodeListToArray: typeof import('./converter').nodeListToArray;
+	swapKeyValue: typeof import('./converter').swapKeyValue;
+	createElementWhitelist: typeof import('./converter').createElementWhitelist;
+	createElementBlacklist: typeof import('./converter').createElementBlacklist;
+	isHexColor: typeof import('./converter').isHexColor;
+	rgb2hex: typeof import('./converter').rgb2hex;
+	getWidthInPercentage: typeof import('./converter').getWidthInPercentage;
+	textToAnchor: typeof import('./converter').textToAnchor;
+	spanToStyleNode: typeof import('./converter').spanToStyleNode;
+	addUrlQuery: typeof import('./converter').addUrlQuery;
+	_setDefaultOptionStyle: typeof import('./converter')._setDefaultOptionStyle;
+	_setIframeStyleLinks: typeof import('./converter')._setIframeStyleLinks;
+	_setAutoHeightStyle: typeof import('./converter')._setAutoHeightStyle;
+};
+export const dom: {
+	query: {
+		getPositionIndex: typeof import('./dom/domQuery').getPositionIndex;
+		getNodePath: typeof import('./dom/domQuery').getNodePath;
+		getNodeFromPath: typeof import('./dom/domQuery').getNodeFromPath;
+		getListChildren: typeof import('./dom/domQuery').getListChildren;
+		getListChildNodes: typeof import('./dom/domQuery').getListChildNodes;
+		getNodeDepth: typeof import('./dom/domQuery').getNodeDepth;
+		sortNodeByDepth: typeof import('./dom/domQuery').sortNodeByDepth;
+		compareElements: typeof import('./dom/domQuery').compareElements;
+		getParentElement: typeof import('./dom/domQuery').getParentElement;
+		getParentElements: typeof import('./dom/domQuery').getParentElements;
+		getCommandTarget: typeof import('./dom/domQuery').getCommandTarget;
+		getEventTarget: typeof import('./dom/domQuery').getEventTarget;
+		getEdgeChild: typeof import('./dom/domQuery').getEdgeChild;
+		getEdgeChildNodes: typeof import('./dom/domQuery').getEdgeChildNodes;
+		getPreviousDeepestNode: typeof import('./dom/domQuery').getPreviousDeepestNode;
+		getNextDeepestNode: typeof import('./dom/domQuery').getNextDeepestNode;
+		findTextIndexOnLine: typeof import('./dom/domQuery').findTextIndexOnLine;
+		findTabEndIndex: typeof import('./dom/domQuery').findTabEndIndex;
+		findVisualLastCell: typeof import('./dom/domQuery').findVisualLastCell;
+		getScrollParent: typeof import('./dom/domQuery').getScrollParent;
+		getIframeDocument: typeof import('./dom/domQuery').getIframeDocument;
+	};
+	check: {
+		isZeroWidth: typeof import('./dom/domCheck').isZeroWidth;
+		isEdgePoint: typeof import('./dom/domCheck').isEdgePoint;
+		isText: typeof import('./dom/domCheck').isText;
+		isElement: typeof import('./dom/domCheck').isElement;
+		isInputElement: typeof import('./dom/domCheck').isInputElement;
+		isButtonElement: typeof import('./dom/domCheck').isButtonElement;
+		isList: typeof import('./dom/domCheck').isList;
+		isListCell: typeof import('./dom/domCheck').isListCell;
+		isTable: typeof import('./dom/domCheck').isTable;
+		isTableElements: typeof import('./dom/domCheck').isTableElements;
+		isTableCell: typeof import('./dom/domCheck').isTableCell;
+		isTableRow: typeof import('./dom/domCheck').isTableRow;
+		isBreak: typeof import('./dom/domCheck').isBreak;
+		isAnchor: typeof import('./dom/domCheck').isAnchor;
+		isMedia: typeof import('./dom/domCheck').isMedia;
+		isIFrame: typeof import('./dom/domCheck').isIFrame;
+		isFigure: typeof import('./dom/domCheck').isFigure;
+		isContentLess: typeof import('./dom/domCheck').isContentLess;
+		isEmptyLine: typeof import('./dom/domCheck').isEmptyLine;
+		isWysiwygFrame: typeof import('./dom/domCheck').isWysiwygFrame;
+		isNonEditable: typeof import('./dom/domCheck').isNonEditable;
+		isSpanWithoutAttr: typeof import('./dom/domCheck').isSpanWithoutAttr;
+		isSameAttributes: typeof import('./dom/domCheck').isSameAttributes;
+		isExcludeFormat: typeof import('./dom/domCheck').isExcludeFormat;
+		isUneditable: typeof import('./dom/domCheck').isUneditable;
+		isImportantDisabled: typeof import('./dom/domCheck').isImportantDisabled;
+	};
+	utils: {
+		clone: typeof import('./dom/domUtils').clone;
+		createElement: typeof import('./dom/domUtils').createElement;
+		createTextNode: typeof import('./dom/domUtils').createTextNode;
+		getAttributesToString: typeof import('./dom/domUtils').getAttributesToString;
+		arrayFilter: typeof import('./dom/domUtils').arrayFilter;
+		arrayFind: typeof import('./dom/domUtils').arrayFind;
+		arrayIncludes: typeof import('./dom/domUtils').arrayIncludes;
+		getArrayIndex: typeof import('./dom/domUtils').getArrayIndex;
+		nextIndex: typeof import('./dom/domUtils').nextIndex;
+		prevIndex: typeof import('./dom/domUtils').prevIndex;
+		copyTagAttributes: typeof import('./dom/domUtils').copyTagAttributes;
+		copyFormatAttributes: typeof import('./dom/domUtils').copyFormatAttributes;
+		removeItem: typeof import('./dom/domUtils').removeItem;
+		changeElement: typeof import('./dom/domUtils').changeElement;
+		changeTxt: typeof import('./dom/domUtils').changeTxt;
+		setStyle: typeof import('./dom/domUtils').setStyle;
+		setDisabled: typeof import('./dom/domUtils').setDisabled;
+		hasClass: typeof import('./dom/domUtils').hasClass;
+		addClass: typeof import('./dom/domUtils').addClass;
+		removeClass: typeof import('./dom/domUtils').removeClass;
+		toggleClass: typeof import('./dom/domUtils').toggleClass;
+		flashClass: typeof import('./dom/domUtils').flashClass;
+		getClientSize: typeof import('./dom/domUtils').getClientSize;
+		getViewportSize: typeof import('./dom/domUtils').getViewportSize;
+		applyInlineStylesAll: typeof import('./dom/domUtils').applyInlineStylesAll;
+		waitForMediaLoad: typeof import('./dom/domUtils').waitForMediaLoad;
+		createTooltipInner: typeof import('./dom/domUtils').createTooltipInner;
+	};
+};
+export const numbers: {
+	is: typeof import('./numbers').is;
+	get: typeof import('./numbers').get;
+	getOverlapRangeAtIndex: typeof import('./numbers').getOverlapRangeAtIndex;
+	isEven: typeof import('./numbers').isEven;
+	isOdd: typeof import('./numbers').isOdd;
+};
+export const keyCodeMap: {
+	isShift: typeof import('./keyCodeMap').isShift;
+	isCtrl: typeof import('./keyCodeMap').isCtrl;
+	isAlt: typeof import('./keyCodeMap').isAlt;
+	isComposing: typeof import('./keyCodeMap').isComposing;
+	isBackspace: typeof import('./keyCodeMap').isBackspace;
+	isTab: typeof import('./keyCodeMap').isTab;
+	isEnter: typeof import('./keyCodeMap').isEnter;
+	isEsc: typeof import('./keyCodeMap').isEsc;
+	isSpace: typeof import('./keyCodeMap').isSpace;
+	isDirectionKey: typeof import('./keyCodeMap').isDirectionKey;
+	isRemoveKey: typeof import('./keyCodeMap').isRemoveKey;
+	isNonTextKey: typeof import('./keyCodeMap').isNonTextKey;
+	isHistoryRelevantKey: typeof import('./keyCodeMap').isHistoryRelevantKey;
+	isDocumentTypeObserverKey: typeof import('./keyCodeMap').isDocumentTypeObserverKey;
+	isNonResponseKey: typeof import('./keyCodeMap').isNonResponseKey;
+};
+export const clipboard: {
+	write: typeof import('./clipboard').write;
+};
+declare namespace _default {
+	export { env };
+	export { unicode };
+	export { converter };
+	export { dom };
+	export { numbers };
+	export { keyCodeMap };
+	export { clipboard };
+}
+export default _default;

package/types/helper/keyCodeMap.d.ts

@@ -0,0 +1,110 @@
+/** ------------------------------------------------------- [meta] -------------------------------------------------------  */
+/**
+ * @description Shift check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isShift(e: KeyboardEvent): boolean;
+/**
+ * @description [Ctrl|Meta] check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isCtrl(e: KeyboardEvent): boolean;
+/**
+ * @description Alt check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isAlt(e: KeyboardEvent): boolean;
+/**
+ * @description event.isComposing check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isComposing(e: KeyboardEvent): boolean;
+/**
+ * @description Backspace key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isBackspace(code: string): boolean;
+/**
+ * @description Tab key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isTab(code: string): boolean;
+/**
+ * @description Enter key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isEnter(code: string): boolean;
+/**
+ * @description ESC key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isEsc(code: string): boolean;
+/**
+ * @description Space key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isSpace(code: string): boolean;
+/** ------------------------------------------------------- [key] -------------------------------------------------------  */
+/**
+ * @description Direction key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isDirectionKey(code: string): boolean;
+/**
+ * @description [delete, backspace] key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isRemoveKey(code: string): boolean;
+/**
+ * @description Non-text key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isNonTextKey(code: string): boolean;
+/**
+ * @description Check if the given key is relevant for history push
+ * @param {string} code - Event.code
+ * @returns {boolean}
+ */
+export function isHistoryRelevantKey(code: string): boolean;
+/**
+ * @description Document type observer key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isDocumentTypeObserverKey(code: string): boolean;
+/**
+ * @description Non-response key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isNonResponseKey(code: string): boolean;
+export default keyCodeMap;
+declare namespace keyCodeMap {
+	export { isShift };
+	export { isCtrl };
+	export { isAlt };
+	export { isComposing };
+	export { isBackspace };
+	export { isTab };
+	export { isEnter };
+	export { isEsc };
+	export { isSpace };
+	export { isDirectionKey };
+	export { isRemoveKey };
+	export { isNonTextKey };
+	export { isHistoryRelevantKey };
+	export { isDocumentTypeObserverKey };
+	export { isNonResponseKey };
+}