diff --git a/.gitignore b/.gitignore
index 10cbb9e..dc80df1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-.obsidian
+# .obsidian
.idea
site
main.ipynb
diff --git a/.obsidian/app.json b/.obsidian/app.json
new file mode 100644
index 0000000..143bc18
--- /dev/null
+++ b/.obsidian/app.json
@@ -0,0 +1,10 @@
+{
+ "strictLineBreaks": false,
+ "showLineNumber": true,
+ "alwaysUpdateLinks": true,
+ "newLinkFormat": "relative",
+ "useMarkdownLinks": true,
+ "showUnsupportedFiles": true,
+ "readableLineLength": false,
+ "attachmentFolderPath": "./imgs"
+}
\ No newline at end of file
diff --git a/.obsidian/appearance.json b/.obsidian/appearance.json
new file mode 100644
index 0000000..d4c9c4b
--- /dev/null
+++ b/.obsidian/appearance.json
@@ -0,0 +1,7 @@
+{
+ "monospaceFontFamily": "JetBrains Mono",
+ "translucency": false,
+ "cssTheme": "Border",
+ "accentColor": "",
+ "theme": "system"
+}
\ No newline at end of file
diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json
new file mode 100644
index 0000000..b3e9114
--- /dev/null
+++ b/.obsidian/community-plugins.json
@@ -0,0 +1,3 @@
+[
+ "easy-typing-obsidian"
+]
\ No newline at end of file
diff --git a/.obsidian/core-plugins-migration.json b/.obsidian/core-plugins-migration.json
new file mode 100644
index 0000000..2ddf6fa
--- /dev/null
+++ b/.obsidian/core-plugins-migration.json
@@ -0,0 +1,30 @@
+{
+ "file-explorer": true,
+ "global-search": false,
+ "switcher": false,
+ "graph": false,
+ "backlink": false,
+ "canvas": false,
+ "outgoing-link": false,
+ "tag-pane": false,
+ "properties": false,
+ "page-preview": true,
+ "daily-notes": false,
+ "templates": false,
+ "note-composer": false,
+ "command-palette": true,
+ "slash-command": true,
+ "editor-status": true,
+ "bookmarks": false,
+ "markdown-importer": false,
+ "zk-prefixer": false,
+ "random-note": false,
+ "outline": true,
+ "word-count": true,
+ "slides": true,
+ "audio-recorder": false,
+ "workspaces": false,
+ "file-recovery": false,
+ "publish": false,
+ "sync": false
+}
\ No newline at end of file
diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json
new file mode 100644
index 0000000..2ddf6fa
--- /dev/null
+++ b/.obsidian/core-plugins.json
@@ -0,0 +1,30 @@
+{
+ "file-explorer": true,
+ "global-search": false,
+ "switcher": false,
+ "graph": false,
+ "backlink": false,
+ "canvas": false,
+ "outgoing-link": false,
+ "tag-pane": false,
+ "properties": false,
+ "page-preview": true,
+ "daily-notes": false,
+ "templates": false,
+ "note-composer": false,
+ "command-palette": true,
+ "slash-command": true,
+ "editor-status": true,
+ "bookmarks": false,
+ "markdown-importer": false,
+ "zk-prefixer": false,
+ "random-note": false,
+ "outline": true,
+ "word-count": true,
+ "slides": true,
+ "audio-recorder": false,
+ "workspaces": false,
+ "file-recovery": false,
+ "publish": false,
+ "sync": false
+}
\ No newline at end of file
diff --git a/.obsidian/plugins/easy-typing-obsidian/data.json b/.obsidian/plugins/easy-typing-obsidian/data.json
new file mode 100644
index 0000000..11c9aec
--- /dev/null
+++ b/.obsidian/plugins/easy-typing-obsidian/data.json
@@ -0,0 +1,59 @@
+{
+ "Tabout": true,
+ "SelectionEnhance": true,
+ "IntrinsicSymbolPairs": true,
+ "BaseObEditEnhance": true,
+ "FW2HWEnhance": true,
+ "BetterCodeEdit": true,
+ "AutoFormat": true,
+ "ExcludeFiles": "",
+ "ChineseEnglishSpace": true,
+ "ChineseNumberSpace": true,
+ "EnglishNumberSpace": true,
+ "ChineseNoSpace": true,
+ "PunctuationSpace": true,
+ "AutoCapital": true,
+ "AutoCapitalMode": "typing",
+ "PunctuationSpaceMode": "typing",
+ "InlineCodeSpaceMode": 1,
+ "InlineFormulaSpaceMode": 1,
+ "InlineLinkSpaceMode": 1,
+ "InlineLinkSmartSpace": true,
+ "UserDefinedRegSwitch": true,
+ "UserDefinedRegExp": "{{.*?}}|++\n<.*?>|--\n\\[\\!.*?\\][-+]{0,1}|-+\n(file:///|https?://|ftp://|obsidian://|zotero://|www.)[^\\s（）《》。,，！？;；：“”‘’\\)\\(\\[\\]\\{\\}']+|--\n\n[a-zA-Z0-9_\\-.]+@[a-zA-Z0-9_\\-.]+|++\n(? function __require() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") {
+ for (let key of __getOwnPropNames(from))
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+ }
+ return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/sprintf-js/src/sprintf.js
+var require_sprintf = __commonJS({
+ "node_modules/sprintf-js/src/sprintf.js"(exports) {
+ !function() {
+ "use strict";
+ var re = {
+ not_string: /[^s]/,
+ not_bool: /[^t]/,
+ not_type: /[^T]/,
+ not_primitive: /[^v]/,
+ number: /[diefg]/,
+ numeric_arg: /[bcdiefguxX]/,
+ json: /[j]/,
+ not_json: /[^j]/,
+ text: /^[^\x25]+/,
+ modulo: /^\x25{2}/,
+ placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
+ key: /^([a-z_][a-z_\d]*)/i,
+ key_access: /^\.([a-z_][a-z_\d]*)/i,
+ index_access: /^\[(\d+)\]/,
+ sign: /^[+-]/
+ };
+ function sprintf2(key) {
+ return sprintf_format(sprintf_parse(key), arguments);
+ }
+ function vsprintf(fmt, argv) {
+ return sprintf2.apply(null, [fmt].concat(argv || []));
+ }
+ function sprintf_format(parse_tree, argv) {
+ var cursor = 1, tree_length = parse_tree.length, arg, output = "", i, k, ph, pad, pad_character, pad_length, is_positive, sign;
+ for (i = 0; i < tree_length; i++) {
+ if (typeof parse_tree[i] === "string") {
+ output += parse_tree[i];
+ } else if (typeof parse_tree[i] === "object") {
+ ph = parse_tree[i];
+ if (ph.keys) {
+ arg = argv[cursor];
+ for (k = 0; k < ph.keys.length; k++) {
+ if (arg == void 0) {
+ throw new Error(sprintf2('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k - 1]));
+ }
+ arg = arg[ph.keys[k]];
+ }
+ } else if (ph.param_no) {
+ arg = argv[ph.param_no];
+ } else {
+ arg = argv[cursor++];
+ }
+ if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {
+ arg = arg();
+ }
+ if (re.numeric_arg.test(ph.type) && (typeof arg !== "number" && isNaN(arg))) {
+ throw new TypeError(sprintf2("[sprintf] expecting number but found %T", arg));
+ }
+ if (re.number.test(ph.type)) {
+ is_positive = arg >= 0;
+ }
+ switch (ph.type) {
+ case "b":
+ arg = parseInt(arg, 10).toString(2);
+ break;
+ case "c":
+ arg = String.fromCharCode(parseInt(arg, 10));
+ break;
+ case "d":
+ case "i":
+ arg = parseInt(arg, 10);
+ break;
+ case "j":
+ arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0);
+ break;
+ case "e":
+ arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential();
+ break;
+ case "f":
+ arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg);
+ break;
+ case "g":
+ arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg);
+ break;
+ case "o":
+ arg = (parseInt(arg, 10) >>> 0).toString(8);
+ break;
+ case "s":
+ arg = String(arg);
+ arg = ph.precision ? arg.substring(0, ph.precision) : arg;
+ break;
+ case "t":
+ arg = String(!!arg);
+ arg = ph.precision ? arg.substring(0, ph.precision) : arg;
+ break;
+ case "T":
+ arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase();
+ arg = ph.precision ? arg.substring(0, ph.precision) : arg;
+ break;
+ case "u":
+ arg = parseInt(arg, 10) >>> 0;
+ break;
+ case "v":
+ arg = arg.valueOf();
+ arg = ph.precision ? arg.substring(0, ph.precision) : arg;
+ break;
+ case "x":
+ arg = (parseInt(arg, 10) >>> 0).toString(16);
+ break;
+ case "X":
+ arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase();
+ break;
+ }
+ if (re.json.test(ph.type)) {
+ output += arg;
+ } else {
+ if (re.number.test(ph.type) && (!is_positive || ph.sign)) {
+ sign = is_positive ? "+" : "-";
+ arg = arg.toString().replace(re.sign, "");
+ } else {
+ sign = "";
+ }
+ pad_character = ph.pad_char ? ph.pad_char === "0" ? "0" : ph.pad_char.charAt(1) : " ";
+ pad_length = ph.width - (sign + arg).length;
+ pad = ph.width ? pad_length > 0 ? pad_character.repeat(pad_length) : "" : "";
+ output += ph.align ? sign + arg + pad : pad_character === "0" ? sign + pad + arg : pad + sign + arg;
+ }
+ }
+ }
+ return output;
+ }
+ var sprintf_cache = /* @__PURE__ */ Object.create(null);
+ function sprintf_parse(fmt) {
+ if (sprintf_cache[fmt]) {
+ return sprintf_cache[fmt];
+ }
+ var _fmt = fmt, match, parse_tree = [], arg_names = 0;
+ while (_fmt) {
+ if ((match = re.text.exec(_fmt)) !== null) {
+ parse_tree.push(match[0]);
+ } else if ((match = re.modulo.exec(_fmt)) !== null) {
+ parse_tree.push("%");
+ } else if ((match = re.placeholder.exec(_fmt)) !== null) {
+ if (match[2]) {
+ arg_names |= 1;
+ var field_list = [], replacement_field = match[2], field_match = [];
+ if ((field_match = re.key.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ while ((replacement_field = replacement_field.substring(field_match[0].length)) !== "") {
+ if ((field_match = re.key_access.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ } else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ } else {
+ throw new SyntaxError("[sprintf] failed to parse named argument key");
+ }
+ }
+ } else {
+ throw new SyntaxError("[sprintf] failed to parse named argument key");
+ }
+ match[2] = field_list;
+ } else {
+ arg_names |= 2;
+ }
+ if (arg_names === 3) {
+ throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");
+ }
+ parse_tree.push({
+ placeholder: match[0],
+ param_no: match[1],
+ keys: match[2],
+ sign: match[3],
+ pad_char: match[4],
+ align: match[5],
+ width: match[6],
+ precision: match[7],
+ type: match[8]
+ });
+ } else {
+ throw new SyntaxError("[sprintf] unexpected placeholder");
+ }
+ _fmt = _fmt.substring(match[0].length);
+ }
+ return sprintf_cache[fmt] = parse_tree;
+ }
+ if (typeof exports !== "undefined") {
+ exports["sprintf"] = sprintf2;
+ exports["vsprintf"] = vsprintf;
+ }
+ if (typeof window !== "undefined") {
+ window["sprintf"] = sprintf2;
+ window["vsprintf"] = vsprintf;
+ if (typeof define === "function" && define["amd"]) {
+ define(function() {
+ return {
+ "sprintf": sprintf2,
+ "vsprintf": vsprintf
+ };
+ });
+ }
+ }
+ }();
+ }
+});
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+ default: () => EasyTypingPlugin
+});
+module.exports = __toCommonJS(main_exports);
+var import_obsidian3 = require("obsidian");
+var import_state3 = require("@codemirror/state");
+
+// src/core.ts
+var import_obsidian = require("obsidian");
+
+// src/utils.ts
+var DEBUG = true;
+var print = (message, ...optionalParams) => {
+ if (DEBUG) {
+ console.log(message, ...optionalParams);
+ }
+};
+function offsetToPos(doc, offset) {
+ let line = doc.lineAt(offset);
+ return { line: line.number - 1, ch: offset - line.from };
+}
+function getTypeStrOfTransac(tr) {
+ let TransacTypeArray = [
+ "EasyTyping.change",
+ "EasyTyping.paste",
+ "input.type.compose",
+ "input.type",
+ "input.paste",
+ "input.drop",
+ "input.complete",
+ "input",
+ "delete.selection",
+ "delete.forward",
+ "delete.backward",
+ "delete.cut",
+ "delete",
+ "move.drop",
+ "undo",
+ "redo",
+ "select.pointer"
+ ];
+ for (let i = 0; i < TransacTypeArray.length; i++) {
+ if (tr.isUserEvent(TransacTypeArray[i]))
+ return TransacTypeArray[i];
+ }
+ return "none";
+}
+function string2pairstring(s) {
+ let cursorIdx = findFirstPipeNotPrecededByBackslash(s);
+ let left = s.substring(0, cursorIdx);
+ let _left = isRegexp(left) ? left : convertEscapeChar(left);
+ let right = s.substring(cursorIdx + 1);
+ let _right = isRegexp(right) ? right : convertEscapeChar(right);
+ return { left: _left, right: _right };
+}
+function replacePlaceholders(str, replacements) {
+ let replace_matches = str.replace(/\[\[(\d+)\]\]/g, function(match, index) {
+ return replacements[parseInt(index, 10)] || match;
+ });
+ return replace_matches;
+}
+function replacePlaceholdersAndTabstops(str, replacements) {
+ let tabstops = [];
+ const regex = /\$(\d+)|\$\{(\d+): *([^ {}]*?)\}|\[\[(\d+)\]\]/g;
+ let match;
+ let replaceStrings = [];
+ while ((match = regex.exec(str)) !== null) {
+ const isSimpleVar = match[1];
+ const isNamedVar = match[2];
+ const content = match[3];
+ const replaceN = match[4];
+ const tabstopN = isSimpleVar || isNamedVar;
+ const startIndex = match.index;
+ const endIndex = startIndex + match[0].length;
+ if (replaceN) {
+ let matchedN = parseInt(replaceN, 10);
+ if (matchedN < replacements.length) {
+ replaceStrings.push({ from: startIndex, to: endIndex, replacement: replacements[matchedN], tabstop: false });
+ }
+ } else {
+ let n = parseInt(tabstopN, 10);
+ let contentStr = replacePlaceholders(content ? content : "", replacements);
+ replaceStrings.push({ from: startIndex, to: endIndex, replacement: contentStr, tabstop: true, tabstopNumber: n });
+ }
+ }
+ let newString = str;
+ let offset = 0;
+ for (let i = 0; i < replaceStrings.length; i++) {
+ let replaceString = replaceStrings[i];
+ newString = newString.substring(0, replaceString.from + offset) + replaceString.replacement + newString.substring(replaceString.to + offset);
+ if (replaceString.tabstop) {
+ let tabstop = {
+ from: replaceString.from + offset,
+ to: replaceString.from + offset + replaceString.replacement.length,
+ number: replaceString.tabstopNumber
+ };
+ tabstops.push(tabstop);
+ }
+ offset += replaceString.replacement.length - (replaceString.to - replaceString.from);
+ }
+ return [newString, tabstops];
+}
+function parseTheAfterPattern(pattern, replacements) {
+ let single_cursor_pos = findFirstPipeNotPrecededByBackslash(pattern);
+ let general_cursor_find = /\$(\d+)|\$\{(\d+): *([^ {}]*?)\}/.test(pattern);
+ let single_cursor_find = single_cursor_pos !== -1;
+ let final_pattern = pattern;
+ if (general_cursor_find) {
+ final_pattern = pattern;
+ } else if (single_cursor_find) {
+ final_pattern = pattern.substring(0, single_cursor_pos) + "$0" + pattern.substring(single_cursor_pos + 1);
+ } else {
+ final_pattern = pattern + "$0";
+ }
+ return replacePlaceholdersAndTabstops(convertEscapeChar(final_pattern), replacements);
+}
+function isRegexp(s) {
+ return s.startsWith("r/") && s.endsWith("/");
+}
+function convertEscapeChar(s) {
+ return s.replace(/\\\|/g, "|").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, " ").replace(/\\\n/g, "\\n").replace(/\\\r/g, "\\r").replace(/\\\t/g, "\\t").replace(/\\\\/g, "\\");
+}
+function ruleStringList2RuleList(list) {
+ let res = [];
+ for (let i in list) {
+ res[i] = { before: string2pairstring(list[i][0]), after: string2pairstring(list[i][1]), after_pattern: list[i][1] };
+ }
+ return res;
+}
+function findFirstPipeNotPrecededByBackslash(s) {
+ let regex = /^r\/[^]*?\/\|/;
+ let regMatch = s.match(regex);
+ if (regMatch)
+ return regMatch[0].length - 1;
+ const match = s.match(/((^|[^\\])(\\\\)*)\|/);
+ return match ? s.indexOf(match[0]) + match[1].length : -1;
+}
+function stringDeleteAt(str, index) {
+ return str.substring(0, index) + str.substring(index + 1);
+}
+function stringInsertAt(str, index, s) {
+ return str.substring(0, index) + s + str.substring(index);
+}
+function isParamDefined(param) {
+ return typeof param !== "undefined";
+}
+function showString(s) {
+ return s.replace(/\n/g, "\\n");
+}
+
+// src/core.ts
+var import_language = require("@codemirror/language");
+var LineFormater = class {
+ constructor() {
+ }
+ syntaxTreeNodeNameType(name) {
+ if (name.contains("code") && !name.contains("link")) {
+ return "code" /* code */;
+ } else if (name.contains("math")) {
+ return "formula" /* formula */;
+ } else {
+ return "text" /* text */;
+ }
+ }
+ parseLineWithSyntaxTree(state, lineNum, regRegExp) {
+ let linePartsOfTxtCodeFormula = [];
+ let line = state.doc.line(lineNum);
+ const tree = (0, import_language.syntaxTree)(state);
+ let pos = line.from;
+ let prevNodeType = "none" /* none */;
+ let prevBeginIdx = 0;
+ while (pos < line.to) {
+ let node = tree.resolve(pos, 1);
+ let curNodeType = this.syntaxTreeNodeNameType(node.name);
+ if (prevNodeType == "none" /* none */) {
+ prevNodeType = curNodeType;
+ prevBeginIdx = 0;
+ } else if (prevNodeType == curNodeType) {
+ } else {
+ linePartsOfTxtCodeFormula.push({
+ content: line.text.substring(prevBeginIdx, pos - line.from),
+ type: prevNodeType,
+ begin: prevBeginIdx,
+ end: pos - line.from,
+ leftSpaceRequire: 0 /* none */,
+ rightSpaceRequire: 0 /* none */
+ });
+ prevNodeType = curNodeType;
+ prevBeginIdx = pos - line.from;
+ }
+ if (curNodeType == "text" /* text */) {
+ pos++;
+ } else {
+ pos = node.to;
+ }
+ if (pos == line.to) {
+ linePartsOfTxtCodeFormula.push({
+ content: line.text.substring(prevBeginIdx, pos - line.from),
+ type: prevNodeType,
+ begin: prevBeginIdx,
+ end: pos - line.from,
+ leftSpaceRequire: 0 /* none */,
+ rightSpaceRequire: 0 /* none */
+ });
+ }
+ }
+ let retArray = [];
+ for (let i = 0; i < linePartsOfTxtCodeFormula.length; i++) {
+ if (linePartsOfTxtCodeFormula[i].type != "text" /* text */) {
+ retArray.push(linePartsOfTxtCodeFormula[i]);
+ } else {
+ let tempArray;
+ if (isParamDefined(regRegExp))
+ tempArray = splitTextWithLinkAndUserDefined(linePartsOfTxtCodeFormula[i].content, regRegExp);
+ else
+ tempArray = splitTextWithLinkAndUserDefined(linePartsOfTxtCodeFormula[i].content);
+ tempArray.forEach((item) => {
+ item.begin += linePartsOfTxtCodeFormula[i].begin;
+ item.end += linePartsOfTxtCodeFormula[i].begin;
+ retArray.push(item);
+ });
+ }
+ }
+ return retArray;
+ }
+ formatLineOfDoc(state, settings, fromB, toB, insertedStr) {
+ let doc = state.doc;
+ let line = doc.lineAt(fromB).text;
+ let res = null;
+ if (insertedStr.contains("\n")) {
+ res = this.formatLine(state, doc.lineAt(fromB).number, settings, offsetToPos(doc, fromB).ch, offsetToPos(doc, fromB).ch);
+ } else {
+ res = this.formatLine(state, doc.lineAt(fromB).number, settings, offsetToPos(doc, toB).ch, offsetToPos(doc, fromB).ch);
+ }
+ if (res === null || res[2].length == 0)
+ return null;
+ let newline = stringInsertAt(res[0], res[1], "|");
+ let changes = [];
+ let offset = doc.lineAt(fromB).from;
+ for (let changeItem of res[2]) {
+ changes.push({
+ changes: { from: offset + changeItem.begin, to: offset + changeItem.end, insert: changeItem.text },
+ userEvent: "EasyTyping.change"
+ });
+ }
+ if (insertedStr.contains("\n")) {
+ console.log("insertStr", insertedStr);
+ res[1] += insertedStr.length;
+ }
+ return [changes, { selection: { anchor: offset + res[1] }, userEvent: "EasyTyping.change" }];
+ }
+ formatLine(state, lineNum, settings, curCh, prevCh) {
+ let line = state.doc.line(lineNum).text;
+ let regNull = /^\s*$/g;
+ if (regNull.test(line))
+ return [line, curCh, []];
+ let lineParts = settings.UserDefinedRegSwitch ? this.parseLineWithSyntaxTree(state, lineNum, settings.UserDefinedRegExp) : this.parseLineWithSyntaxTree(state, lineNum);
+ if (settings.debug)
+ console.log("line parts\n", lineParts);
+ let linePartsOrigin = JSON.parse(JSON.stringify(lineParts));
+ let inlineChangeList = [];
+ let cursorLinePartIndex = -1;
+ let cursorRelativeIndex = -1;
+ let resultCursorCh = 0;
+ for (let i = 0; i < lineParts.length; i++) {
+ if (curCh > lineParts[i].begin && curCh <= lineParts[i].end) {
+ cursorLinePartIndex = i;
+ cursorRelativeIndex = curCh - lineParts[i].begin;
+ if (lineParts[i].type === "text" /* text */) {
+ lineParts[i].content = stringInsertAt(lineParts[i].content, cursorRelativeIndex, "\0");
+ }
+ break;
+ }
+ }
+ let resultLine = "";
+ let offset = 0;
+ let prevPartType = "none" /* none */;
+ let prevTextEndSpaceState = 0 /* none */;
+ for (let i = 0; i < lineParts.length; i++) {
+ if (i === 0 && lineParts[i].type === "text" /* text */ && settings.AutoCapital) {
+ if (isParamDefined(prevCh) && cursorLinePartIndex != 0) {
+ } else {
+ let regFirstSentence = /^\s*(\- (\[[x ]\] )?)?“?[a-z\u0401\u0451\u0410-\u044f]/g;
+ let regHeaderSentence = /^(#+ |>+ ?|“)[a-z\u0401\u0451\u0410-\u044f]/g;
+ let textcopy = lineParts[0].content;
+ let match = regFirstSentence.exec(textcopy);
+ let matchHeader = regHeaderSentence.exec(textcopy);
+ let dstCharIndex = -1;
+ if (match) {
+ dstCharIndex = regFirstSentence.lastIndex - 1;
+ } else if (matchHeader) {
+ dstCharIndex = regHeaderSentence.lastIndex - 1;
+ }
+ if (settings.AutoCapitalMode == "global" /* Globally */ || isParamDefined(prevCh) && dstCharIndex >= prevCh && dstCharIndex < curCh) {
+ } else {
+ dstCharIndex = -1;
+ }
+ if (dstCharIndex != -1) {
+ lineParts[0].content = textcopy.substring(0, dstCharIndex) + textcopy.charAt(dstCharIndex).toUpperCase() + textcopy.substring(dstCharIndex + 1);
+ }
+ }
+ }
+ switch (lineParts[i].type) {
+ case "text" /* text */:
+ let insertSpace = function(content2, reg2, prevCh2, curCh2, offset2) {
+ while (true) {
+ let match = reg2.exec(content2);
+ if (!match)
+ break;
+ let tempIndex = reg2.lastIndex - 1;
+ if (isParamDefined(prevCh2) && tempIndex >= prevCh2 - offset2 && tempIndex < curCh2 - offset2) {
+ content2 = content2.substring(0, tempIndex) + " " + content2.substring(tempIndex);
+ curCh2 += 1;
+ }
+ }
+ return [content2, curCh2];
+ };
+ let content = lineParts[i].content;
+ if (settings.AutoCapital) {
+ var reg = /[\.\?\!。！？]([\s]*)[a-z\u0401\u0451\u0410-\u044f]/g;
+ while (true) {
+ let match = reg.exec(content);
+ if (!match)
+ break;
+ let tempIndex = reg.lastIndex - 1;
+ let isSpaceDot = tempIndex - 2 < 0 || content.substring(tempIndex - 2, tempIndex) == " .";
+ if (settings.AutoCapitalMode == "global" /* Globally */ && !isSpaceDot) {
+ lineParts[i].content = content.substring(0, tempIndex) + content.charAt(tempIndex).toUpperCase() + content.substring(reg.lastIndex);
+ content = lineParts[i].content;
+ } else if (isParamDefined(prevCh) && tempIndex >= prevCh - offset && tempIndex < curCh - offset && !isSpaceDot) {
+ lineParts[i].content = content.substring(0, tempIndex) + content.charAt(tempIndex).toUpperCase() + content.substring(reg.lastIndex);
+ content = lineParts[i].content;
+ }
+ }
+ }
+ if (settings.ChineseEnglishSpace) {
+ let reg1 = /([A-Za-z])([\u4e00-\u9fa5])/gi;
+ let reg2 = /([\u4e00-\u9fa5])([A-Za-z])/gi;
+ [content, curCh] = insertSpace(content, reg1, prevCh, curCh, offset);
+ [content, curCh] = insertSpace(content, reg2, prevCh, curCh, offset);
+ }
+ if (settings.ChineseNumberSpace) {
+ let reg2 = /([0-9])([\u4e00-\u9fa5])/g;
+ let reg1 = /([\u4e00-\u9fa5])([0-9])/g;
+ [content, curCh] = insertSpace(content, reg2, prevCh, curCh, offset);
+ [content, curCh] = insertSpace(content, reg1, prevCh, curCh, offset);
+ }
+ if (settings.EnglishNumberSpace) {
+ let reg2 = /([A-Za-z])(\d)/g;
+ let reg1 = /(\d)([A-Za-z])/g;
+ [content, curCh] = insertSpace(content, reg2, prevCh, curCh, offset);
+ [content, curCh] = insertSpace(content, reg1, prevCh, curCh, offset);
+ }
+ if (settings.ChineseNoSpace) {
+ let reg2 = /([\u4e00-\u9fa5，。、！；‘’《》]+)(\s+)([\u4e00-\u9fa5，。、！；‘’《》]+)/g;
+ while (reg2.exec(content)) {
+ lineParts[i].content = content.replace(reg2, "$1$3");
+ content = lineParts[i].content;
+ }
+ }
+ if (settings.PunctuationSpace) {
+ {
+ let reg2 = /([,\.;\?\!\)])([0-9A-Za-z\u0401\u0451\u0410-\u044f\u4e00-\u9fa5])|([A-Za-z0-9\u4e00-\u9fa5:,\.\?\!'"]+)(\()|[,\.;\?:!][\u4e00-\u9fa5]/gi;
+ while (true) {
+ let match = reg2.exec(content);
+ if (!match)
+ break;
+ let tempIndex = reg2.lastIndex - 1;
+ let isSpaceDot = "!.?;,".contains(content.charAt(tempIndex - 1)) && (tempIndex - 2 < 0 && i == 0 || content.charAt(tempIndex - 2) == " ");
+ let isNumPuncNum = /[,.]\d/.test(content.substring(tempIndex - 1, tempIndex + 1)) && (tempIndex - 2 < 0 || /\d/.test(content.charAt(tempIndex - 2)));
+ if (settings.PunctuationSpaceMode == "global" /* Globally */ && !isSpaceDot && !isNumPuncNum) {
+ content = content.substring(0, tempIndex) + " " + content.substring(tempIndex);
+ } else if (isParamDefined(prevCh) && tempIndex >= prevCh - offset && tempIndex < curCh - offset && !isSpaceDot && !isNumPuncNum) {
+ content = content.substring(0, tempIndex) + " " + content.substring(tempIndex);
+ curCh += 1;
+ }
+ }
+ let reg22 = /(:)([A-Za-z0-9_]+[ ,\.\?\\\/;'"，。？；‘“”’、\[\]\-\{\}])/gi;
+ lineParts[i].content = content.replace(reg22, "$1 $2");
+ content = lineParts[i].content;
+ let reg3 = /(:)(["'])/g;
+ lineParts[i].content = content.replace(reg3, "$1 $2");
+ content = lineParts[i].content;
+ }
+ }
+ let regStrictSpaceStart = /^\0?\s/;
+ let regStrictSpaceEnd = /\s\0?$/;
+ let regStartWithSpace = /^\0?[\s,\.;\?\!，。；》？：:！~\*、（）"”\[\]\)\{\}]/;
+ let regEndWithSpace = /[\s，。、：；？！（）~\*"《“\[\]\(\{\}]\0?$/;
+ let txtStartSpaceSate = 0 /* none */;
+ let txtEndSpaceState = 0 /* none */;
+ if (regStartWithSpace.test(content) || content.startsWith("