argous 1.2.216 → 1.2.218

package/dist/components/TextToHtml/TextToHtml.js

@@ -0,0 +1,484 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textToHtmlInitialValue = exports.initialStateCursor = exports.initialStateCharacter = exports.TEXT_TO_HTML_ID = void 0;
+var Cursor_1 = __importDefault(require("./Cursor"));
+var TextStyles_1 = __importDefault(require("./TextStyles"));
+var utils_1 = require("./utils");
+var core_1 = require("@material-ui/core");
+var lodash_1 = require("lodash");
+var react_1 = __importStar(require("react"));
+require("./style.css");
+var resizeStyle = {
+    resize: 'both',
+    overflow: 'auto'
+};
+exports.TEXT_TO_HTML_ID = 'text-to-html';
+var TEXT_TO_HTML_CURSOR_ID = 'text-to-html-cursor';
+var TEXT_TO_HTML_TEXT_CONTAINER_ID = 'text-to-html-text-container';
+exports.initialStateCharacter = {
+    key: undefined,
+    keyCode: undefined,
+    code: undefined,
+    string: '',
+    dead: false,
+    shift: false,
+    mark: []
+};
+exports.initialStateCursor = __assign(__assign({}, exports.initialStateCharacter), { string: 'cursor' });
+exports.textToHtmlInitialValue = { text: '', cssText: '' };
+var initialStateMove = {
+    isDown: false,
+    offset: []
+};
+var initialStateKeyboardRef = { altGraph: false };
+var initialStateTextStyle = {
+    color: { r: 255, g: 255, b: 255, a: 1 },
+    textAlign: 'center',
+    fontSize: 2,
+    fontFamily: 'Roboto, Helvetica, Arial, sans-serif',
+    letterSpacing: '0.01em'
+};
+var initialState = {
+    textStyle: initialStateTextStyle,
+    createCursorClick: false,
+    clickAway: undefined,
+    tap: 0,
+    resize: false,
+    move: initialStateMove,
+    characters: []
+};
+var TextToHtml = function (_a, ref) {
+    var _b = _a.initialValue, initialValue = _b === void 0 ? exports.textToHtmlInitialValue : _b, onChange = _a.onChange, onDelete = _a.onDelete, defaultSpacing = _a.defaultSpacing, setExternalValues = _a.setExternalValues;
+    var keyboardRef = react_1.useRef(initialStateKeyboardRef);
+    var _c = react_1.useState(initialState), state = _c[0], setState = _c[1];
+    var createCursorClick = state.createCursorClick, characters = state.characters, move = state.move, resize = state.resize, tap = state.tap, textStyle = state.textStyle;
+    var color = textStyle.color, fontSize = textStyle.fontSize, fontFamily = textStyle.fontFamily, textAlign = textStyle.textAlign, letterSpacing = textStyle.letterSpacing;
+    var propsRef = react_1.useRef({
+        onChange: onChange
+    });
+    var cursor = characters.findIndex(function (_a) {
+        var string = _a.string;
+        return (string === 'cursor');
+    });
+    var canWrite = (cursor > -1);
+    var logicSetState = function (_a) {
+        var type = _a.type, field = _a.field, value = _a.value;
+        return setState(function (values) {
+            var _a, _b;
+            return (__assign(__assign({}, values), (_a = {}, _a[type] = (type && field) ? __assign(__assign({}, values[type]), (_b = {}, _b[field] = value, _b)) : value, _a)));
+        });
+    };
+    var setCharacters = react_1.useCallback(function (value) { return logicSetState({ type: 'characters', value: value }); }, []);
+    var focusToWrite = function () {
+        var element = document.getElementById(exports.TEXT_TO_HTML_ID);
+        if (element)
+            element.focus();
+    };
+    var toggleResize = function () { return logicSetState({ type: 'resize', value: !resize }); };
+    var toggleClickAway = function () { return logicSetState({ type: 'clickAway', value: (state.clickAway === undefined) ? false : undefined }); };
+    var disableResize = react_1.useCallback(function () { return logicSetState({ type: 'resize', value: false }); }, []);
+    var handleCreateCursorClick = react_1.useCallback(function (boolean) { return logicSetState({ type: 'createCursorClick', value: boolean }); }, []);
+    var deleteCursor = react_1.useCallback(function () { return logicSetState({ type: 'characters', value: characters.filter(function (_a) {
+            var string = _a.string;
+            return string !== 'cursor';
+        }) }); }, [characters]);
+    var createCursor = react_1.useCallback(function (e) {
+        var newCharacters = __spreadArray([], characters);
+        newCharacters.push(exports.initialStateCursor);
+        focusToWrite();
+        logicSetState({ type: 'characters', value: newCharacters });
+    }, [characters]);
+    var clickAway = react_1.useCallback(function (e) {
+        if (createCursorClick) {
+            handleCreateCursorClick(false);
+            return;
+        }
+        disableResize();
+        deleteCursor();
+    }, [createCursorClick, deleteCursor, disableResize, handleCreateCursorClick]);
+    var handleClickAway = function (e) {
+        clickAway(e);
+    };
+    var handleContainerClick = function (e) {
+        if (canWrite) {
+            clickAway(e);
+            return;
+        }
+        createCursor(e);
+        handleCreateCursorClick(true);
+    };
+    var handleClick = function (e) {
+        e.stopPropagation();
+        if (canWrite)
+            return;
+        if (createCursorClick)
+            handleCreateCursorClick(false);
+        createCursor(e);
+    };
+    var pasteTextFromClipboard = function (e) { return __awaiter(void 0, void 0, void 0, function () {
+        var text, newCharacters, index, string, newCharacter, cursorIndex, cursor_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, ((_a = navigator.clipboard) === null || _a === void 0 ? void 0 : _a.readText())];
+                case 1:
+                    text = _b.sent();
+                    if (text === null || text === void 0 ? void 0 : text.length) {
+                        newCharacters = __spreadArray([], characters);
+                        for (index = 0; (index < text.length); index++) {
+                            string = text[index];
+                            newCharacter = __assign(__assign({}, exports.initialStateCharacter), { string: string });
+                            newCharacters.push(newCharacter);
+                        }
+                        cursorIndex = newCharacters.findIndex(function (_a) {
+                            var string = _a.string;
+                            return (string === 'cursor');
+                        });
+                        if (cursorIndex > -1) {
+                            cursor_1 = newCharacters.splice(cursorIndex, 1)[0];
+                            (cursor_1) && newCharacters.push(cursor_1);
+                        }
+                        (!lodash_1.isEqual(characters, newCharacters)) && setCharacters(newCharacters);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var createCharactersFromInitialValue = react_1.useCallback(function (text) {
+        if (typeof text === 'string') {
+            var newCharacters = [];
+            for (var index = 0; (index < text.length); index++) {
+                var string = text[index];
+                var newCharacter = __assign(__assign({}, exports.initialStateCharacter), { string: string });
+                newCharacters.push(newCharacter);
+            }
+            newCharacters.push(exports.initialStateCursor);
+            setCharacters(newCharacters);
+            focusToWrite();
+        }
+    }, [setCharacters]);
+    var setStyleFromInitialValue = function (cssText) {
+        var element = document.getElementById(exports.TEXT_TO_HTML_ID);
+        (element) && (element.style.cssText = cssText);
+    };
+    var loadInitialValue = react_1.useCallback(function (initialValue) {
+        (initialValue.text) && createCharactersFromInitialValue(initialValue.text);
+        (initialValue.cssText) && setStyleFromInitialValue(initialValue.cssText);
+    }, [createCharactersFromInitialValue]);
+    react_1.useEffect(function () { return loadInitialValue(initialValue); }, [initialValue, loadInitialValue]);
+    var handleKeyDown = function (e) {
+        e.preventDefault();
+        e.stopPropagation();
+        if (!canWrite)
+            return;
+        var key = e.key;
+        var keyCode = e.keyCode;
+        var code = e.code;
+        var shift = e.shiftKey;
+        var ctrlKey = e.ctrlKey;
+        var shiftKey = e.shiftKey;
+        var capsLock = e.getModifierState('CapsLock');
+        var deleted = undefined;
+        var newCharacter = { string: null };
+        var newCharacters = __spreadArray([], characters);
+        var paste = (((key === 'v') || (key === 'V')) && (keyCode === 86) && (code === 'KeyV') && ctrlKey && !shiftKey);
+        var characterBeforeCursorIndex = (cursor - 1);
+        var characterBeforeCursor = newCharacters[characterBeforeCursorIndex];
+        function moveCursor(direction) {
+            var start = (direction === 'start');
+            var end = (direction === 'end');
+            var left = (direction === 'left');
+            var right = (direction === 'right');
+            if (!start && !end && !left && !right)
+                return;
+            var cursorIndex = cursor;
+            if ((left || start) && (cursorIndex === 0))
+                return;
+            var cursorObject = newCharacters.splice(cursorIndex, 1)[0];
+            newCharacters.splice((start) ? 0 : (end) ? (newCharacters.length) : (left) ? (cursorIndex - 1) : (cursorIndex + 1), 0, cursorObject);
+        }
+        function deleteText(direction) {
+            var _a;
+            var left = (direction === 'left');
+            var targetIndex = (left) ? (cursor === 0) ? 0 : (cursor - 1) : (cursor + 1);
+            var nextObjectToDelete = newCharacters[targetIndex];
+            if ((nextObjectToDelete === null || nextObjectToDelete === void 0 ? void 0 : nextObjectToDelete.string) === 'cursor')
+                return;
+            deleted = (_a = newCharacters.splice(targetIndex, 1)) === null || _a === void 0 ? void 0 : _a[0];
+        }
+        if (paste)
+            pasteTextFromClipboard(e);
+        else if (key === 'Home')
+            moveCursor('start');
+        else if (key === 'End')
+            moveCursor('end');
+        else if (key === 'ArrowLeft')
+            moveCursor('left');
+        else if (key === 'ArrowRight')
+            moveCursor('right');
+        else if (key === 'AltGraph')
+            keyboardRef.current.altGraph = true;
+        else if (key === 'Backspace')
+            deleteText('left');
+        else if (key === 'Delete')
+            deleteText('right');
+        else {
+            var _a = utils_1.translateKey({ key: key, keyCode: keyCode, code: code, shift: shift, altGraph: keyboardRef.current.altGraph, capsLock: capsLock, before: characterBeforeCursor }), string = _a.string, before = _a.before;
+            if (string) {
+                newCharacter = __assign(__assign({}, exports.initialStateCharacter), { key: key,
+                    keyCode: keyCode,
+                    code: code,
+                    string: string, dead: before.dead, shift: shift });
+                newCharacters.splice(cursor, 0, newCharacter);
+                if (characterBeforeCursor) {
+                    if (before.delete)
+                        newCharacters.splice(characterBeforeCursorIndex, 1);
+                    else if (characterBeforeCursor.dead) {
+                        characterBeforeCursor.dead = false;
+                        newCharacters.splice(characterBeforeCursorIndex, 1, characterBeforeCursor);
+                    }
+                }
+            }
+        }
+        (!lodash_1.isEqual(newCharacters, characters)) && setCharacters(newCharacters);
+        if (deleted)
+            onDelete && onDelete(e, deleted, newCharacters);
+    };
+    var handleKeyUp = function (e) {
+        var key = e.key;
+        if (key === 'AltGraph')
+            keyboardRef.current.altGraph = false;
+    };
+    var handleDoubleClick = function (e) {
+        toggleResize();
+    };
+    var handleTap = function () {
+        var newTap = tap;
+        newTap += 1;
+        if (newTap > 1)
+            toggleResize();
+        logicSetState({ type: 'tap', value: newTap });
+        setTimeout(function () { return logicSetState({ type: 'tap', value: 0 }); }, 300);
+    };
+    var handleMouseDownTouchStart = function (e) {
+        if (e.type === 'touchstart')
+            handleTap();
+        if (resize)
+            return;
+        var element = document.getElementById(exports.TEXT_TO_HTML_ID);
+        if (!element)
+            return;
+        var clientX = (e.clientX || e.touches[0].clientX);
+        var clientY = (e.clientY || e.touches[0].clientY);
+        logicSetState({
+            type: 'move',
+            value: __assign(__assign({}, move), { isDown: true, offset: [
+                    element.offsetLeft - clientX,
+                    element.offsetTop - clientY
+                ] })
+        });
+    };
+    var handleMouseUpTouchEnd = function (e) {
+        logicSetState({ type: 'move', field: 'isDown', value: false });
+        var element = document.getElementById(exports.TEXT_TO_HTML_ID);
+        if (element) {
+            element.style.cursor = 'pointer';
+        }
+    };
+    var handleMouseTouchMove = function (e) {
+        var isDown = move.isDown, offset = move.offset;
+        var containerElement = document.getElementById(TEXT_TO_HTML_TEXT_CONTAINER_ID);
+        var textElement = document.getElementById(exports.TEXT_TO_HTML_ID);
+        if (containerElement && textElement && isDown) {
+            var containerHeight = containerElement.clientHeight;
+            var containerWidth = containerElement.clientWidth;
+            var clientX = (e.clientX || e.touches[0].clientX);
+            var clientY = (e.clientY || e.touches[0].clientY);
+            var top_1 = (clientY + offset[1]);
+            var left = (clientX + offset[0]);
+            var textTop = ((top_1 / containerHeight) * 100);
+            var textLeft = ((left / containerWidth) * 100);
+            textElement.style.top = textTop + '%';
+            textElement.style.left = textLeft + '%';
+            textElement.style.cursor = 'grabbing';
+        }
+    };
+    var handleFontSizeChange = function (e) {
+        logicSetState({ type: 'clickAway', value: false });
+        var newFontSize = fontSize;
+        if (newFontSize > 2)
+            newFontSize = 1;
+        else
+            newFontSize += 1;
+        logicSetState({ type: 'textStyle', field: 'fontSize', value: newFontSize });
+        focusToWrite();
+        setTimeout(function () { return logicSetState({ type: 'clickAway', value: undefined }); }, 0);
+    };
+    var handleTextAlignChange = function (e) {
+        logicSetState({ type: 'clickAway', value: false });
+        var newTextAlign = textAlign;
+        switch (textAlign) {
+            case 'start':
+                newTextAlign = 'end';
+                break;
+            case 'end':
+                newTextAlign = 'center';
+                break;
+            case 'center':
+                newTextAlign = 'justify';
+                break;
+            case 'justify':
+                newTextAlign = 'start';
+                break;
+            default:
+                return null;
+        }
+        logicSetState({ type: 'textStyle', field: 'textAlign', value: newTextAlign });
+        focusToWrite();
+        setTimeout(function () { return logicSetState({ type: 'clickAway', value: undefined }); }, 0);
+    };
+    var changeStyles = react_1.useCallback(function (_a) {
+        var resize = _a.resize;
+        var element = document.getElementById(exports.TEXT_TO_HTML_ID);
+        if (element) {
+            if (resize) {
+                element.style.resize = resizeStyle.resize;
+                element.style.overflow = resizeStyle.overflow;
+            }
+            else {
+                element.style.resize = '';
+                element.style.overflow = '';
+            }
+        }
+    }, []);
+    react_1.useEffect(function () { return changeStyles({ resize: resize }); }, [resize, changeStyles]);
+    var createHtmlString = react_1.useCallback(function () {
+        var _a;
+        var element = document.getElementById(exports.TEXT_TO_HTML_ID);
+        if (element) {
+            var htmlDataString_1 = '';
+            characters.forEach(function (_a) {
+                var string = _a.string;
+                return (string === 'cursor') ? null : htmlDataString_1 += string;
+            });
+            element.setAttribute('data-string', htmlDataString_1);
+            var newElement = element.cloneNode(true);
+            newElement.id = Math.floor(Math.random() * 1000001) + "-" + element.id;
+            newElement.style.cursor = 'inherit';
+            var htmlString = newElement.outerHTML;
+            ((_a = propsRef.current) === null || _a === void 0 ? void 0 : _a.onChange) && propsRef.current.onChange(htmlString);
+            if (ref.current)
+                ref.current.htmlString = htmlString;
+            return { htmlString: htmlString };
+        }
+    }, [characters, ref]);
+    react_1.useEffect(function () { return createHtmlString(); }, [characters, createHtmlString]);
+    react_1.useEffect(function () { return ref.current = __assign(__assign(__assign({}, ref.current), state), { clickAway: clickAway,
+        focusToWrite: focusToWrite,
+        createCursor: createCursor,
+        setCharacters: setCharacters,
+        createHtmlString: createHtmlString,
+        setExternalValues: setExternalValues }); }, [ref, state, setCharacters, createCursor, createHtmlString, clickAway, setExternalValues]);
+    var updateExternalValues = function (_a) {
+        var state = _a.state, setExternalValues = _a.setExternalValues;
+        setExternalValues && setExternalValues(state);
+    };
+    react_1.useEffect(function () { return updateExternalValues({ state: state, setExternalValues: setExternalValues }); }, [state, setExternalValues]);
+    return react_1.default.createElement("div", { className: 'text-to-html-container' },
+        (canWrite) && (react_1.default.createElement(TextStyles_1.default, __assign({ setColor: function (value) { return logicSetState({ type: 'textStyle', field: 'color', value: value }); } }, { color: color, defaultSpacing: defaultSpacing, toggleClickAway: toggleClickAway, handleFontSizeChange: handleFontSizeChange, textAlign: textAlign, handleTextAlignChange: handleTextAlignChange }))),
+        react_1.default.createElement("div", { id: TEXT_TO_HTML_TEXT_CONTAINER_ID, onClick: handleContainerClick, className: 'text-to-html-text-container' },
+            react_1.default.createElement(core_1.ClickAwayListener, { mouseEvent: state.clickAway, touchEvent: state.clickAway, disableReactTree: true, onClickAway: handleClickAway },
+                react_1.default.createElement("div", { id: exports.TEXT_TO_HTML_ID, tabIndex: 0, onKeyDown: handleKeyDown, onKeyUp: handleKeyUp, onMouseDown: handleMouseDownTouchStart, onMouseUp: handleMouseUpTouchEnd, onMouseMove: handleMouseTouchMove, onTouchStart: handleMouseDownTouchStart, onTouchEnd: handleMouseUpTouchEnd, onTouchMove: handleMouseTouchMove, onClick: handleClick, onDoubleClick: handleDoubleClick, style: {
+                        color: (color) ? "rgba(" + color.r + ", " + color.g + ", " + color.b + ", " + color.a + ")" : 'inherit',
+                        textAlign: (textAlign) ? textAlign : 'inherit',
+                        fontSize: (fontSize) ? fontSize + "rem" : '1rem',
+                        fontFamily: (fontFamily) ? fontFamily : 'inherit',
+                        letterSpacing: (letterSpacing) ? letterSpacing : 'inherit'
+                    }, className: 'text-to-html' },
+                    react_1.default.createElement("p", null, characters.map(function (_a, stringIndex) {
+                        var code = _a.code, string = _a.string, dead = _a.dead, mark = _a.mark;
+                        switch (string) {
+                            case 'cursor':
+                                return react_1.default.createElement(Cursor_1.default, { key: stringIndex + "-" + string, id: TEXT_TO_HTML_CURSOR_ID, className: 'text-to-html-cursor' });
+                            default:
+                                return (string) ? (react_1.default.createElement("span", { key: stringIndex + "-" + string, style: {
+                                        textDecoration: (dead || (mark === null || mark === void 0 ? void 0 : mark.length)) ? 'underline' : ''
+                                    } }, string)) : null;
+                        }
+                    }))))));
+};
+exports.default = react_1.forwardRef(TextToHtml);

package/dist/components/TextToHtml/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './TextToHtml';
+export * from './TextToHtml';

package/dist/components/TextToHtml/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var TextToHtml_1 = require("./TextToHtml");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(TextToHtml_1).default; } });

package/dist/components/TextToHtml/utils.d.ts

@@ -0,0 +1,27 @@
+export const DEAD_KEY: "Dead";
+export const SEARCH_PEOPLE_SYMBOL: "@";
+export function createCharactersWithMark(string: any, mark: any): {
+    markedCharacters: any[];
+};
+export function getCharacterElement({ index }: {
+    index: any;
+}): {
+    nodeElement: undefined;
+    rect: undefined;
+};
+export function translateKey({ key, keyCode, code, shift, altGraph, capsLock, before }: {
+    key: any;
+    keyCode: any;
+    code: any;
+    shift: any;
+    altGraph: any;
+    capsLock: any;
+    before: any;
+}): {
+    string: string;
+    dead: boolean;
+    before: {
+        dead: boolean;
+        delete: boolean;
+    };
+};