Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "processValue", "(", "schema", ",", "value", ")", "{", "// \"enum\" is a reserved word, so only \"type\" and \"items\" can be destructured", "const", "{", "type", ",", "items", "}", "=", "schema", ";", "if", "(", "value", "===", "\"\"", ")", "{", "return", "undefined", ";", "}", "else", "if", "(", "type", "===", "\"array\"", "&&", "items", "&&", "nums", ".", "has", "(", "items", ".", "type", ")", ")", "{", "return", "value", ".", "map", "(", "asNumber", ")", ";", "}", "else", "if", "(", "type", "===", "\"boolean\"", ")", "{", "return", "value", "===", "\"true\"", ";", "}", "else", "if", "(", "type", "===", "\"number\"", ")", "{", "return", "asNumber", "(", "value", ")", ";", "}", "// If type is undefined, but an enum is present, try and infer the type from", "// the enum values", "if", "(", "schema", ".", "enum", ")", "{", "if", "(", "schema", ".", "enum", ".", "every", "(", "x", "=>", "guessType", "(", "x", ")", "===", "\"number\"", ")", ")", "{", "return", "asNumber", "(", "value", ")", ";", "}", "else", "if", "(", "schema", ".", "enum", ".", "every", "(", "x", "=>", "guessType", "(", "x", ")", "===", "\"boolean\"", ")", ")", "{", "return", "value", "===", "\"true\"", ";", "}", "}", "return", "value", ";", "}" ]

[ "This", "is", "a", "silly", "limitation", "in", "the", "DOM", "where", "option", "change", "event", "values", "are", "always", "retrieved", "as", "strings", "." ]

[ "function", "(", "element", ",", "opts", ")", "{", "var", "owner", "=", "this", ";", "var", "hasMultipleElements", "=", "false", ";", "if", "(", "typeof", "element", "===", "'string'", ")", "{", "owner", ".", "element", "=", "document", ".", "querySelector", "(", "element", ")", ";", "hasMultipleElements", "=", "document", ".", "querySelectorAll", "(", "element", ")", ".", "length", ">", "1", ";", "}", "else", "{", "if", "(", "typeof", "element", ".", "length", "!==", "'undefined'", "&&", "element", ".", "length", ">", "0", ")", "{", "owner", ".", "element", "=", "element", "[", "0", "]", ";", "hasMultipleElements", "=", "element", ".", "length", ">", "1", ";", "}", "else", "{", "owner", ".", "element", "=", "element", ";", "}", "}", "if", "(", "!", "owner", ".", "element", ")", "{", "throw", "new", "Error", "(", "'[cleave.js] Please check the element'", ")", ";", "}", "if", "(", "hasMultipleElements", ")", "{", "try", "{", "// eslint-disable-next-line", "console", ".", "warn", "(", "'[cleave.js] Multiple input fields matched, cleave.js will only take the first one.'", ")", ";", "}", "catch", "(", "e", ")", "{", "// Old IE", "}", "}", "opts", ".", "initValue", "=", "owner", ".", "element", ".", "value", ";", "owner", ".", "properties", "=", "Cleave", ".", "DefaultProperties", ".", "assign", "(", "{", "}", ",", "opts", ")", ";", "owner", ".", "init", "(", ")", ";", "}" ]

[ "Construct", "a", "new", "Cleave", "instance", "by", "passing", "the", "configuration", "object" ]

[ "function", "_findFocusTd", "(", "$newTable", ",", "rowIndex", ",", "colIndex", ")", "{", "const", "tableData", "=", "dataHandler", ".", "createTableData", "(", "$newTable", ")", ";", "const", "newRowIndex", "=", "dataHandler", ".", "findRowMergedLastIndex", "(", "tableData", ",", "rowIndex", ",", "colIndex", ")", "+", "1", ";", "const", "cellElementIndex", "=", "dataHandler", ".", "findElementIndex", "(", "tableData", ",", "newRowIndex", ",", "colIndex", ")", ";", "return", "$newTable", ".", "find", "(", "'tr'", ")", ".", "eq", "(", "cellElementIndex", ".", "rowIndex", ")", ".", "find", "(", "'td'", ")", "[", "cellElementIndex", ".", "colIndex", "]", ";", "}" ]

[ "Find", "focus", "td", "element", "." ]

[ "function", "_parseCell", "(", "cell", ",", "rowIndex", ",", "colIndex", ")", "{", "const", "$cell", "=", "$", "(", "cell", ")", ";", "const", "colspan", "=", "$cell", ".", "attr", "(", "'colspan'", ")", ";", "const", "rowspan", "=", "$cell", ".", "attr", "(", "'rowspan'", ")", ";", "const", "{", "nodeName", "}", "=", "cell", ";", "if", "(", "nodeName", "!==", "'TH'", "&&", "nodeName", "!==", "'TD'", ")", "{", "return", "null", ";", "}", "const", "cellData", "=", "{", "nodeName", ":", "cell", ".", "nodeName", ",", "colspan", ":", "colspan", "?", "parseInt", "(", "colspan", ",", "10", ")", ":", "1", ",", "rowspan", ":", "rowspan", "?", "parseInt", "(", "rowspan", ",", "10", ")", ":", "1", ",", "content", ":", "$cell", ".", "html", "(", ")", ",", "elementIndex", ":", "{", "rowIndex", ",", "colIndex", "}", "}", ";", "if", "(", "cell", ".", "nodeName", "===", "'TH'", "&&", "cell", ".", "align", ")", "{", "cellData", ".", "align", "=", "cell", ".", "align", ";", "}", "return", "cellData", ";", "}" ]

[ "Parse", "cell", "like", "td", "or", "th", "." ]

[ "function", "_addMergedCell", "(", "base", ",", "cellData", ",", "startRowIndex", ",", "startCellIndex", ")", "{", "const", "{", "colspan", ",", "rowspan", ",", "nodeName", "}", "=", "cellData", ";", "const", "colMerged", "=", "colspan", ">", "1", ";", "const", "rowMerged", "=", "rowspan", ">", "1", ";", "if", "(", "!", "colMerged", "&&", "!", "rowMerged", ")", "{", "return", ";", "}", "const", "limitRowIndex", "=", "startRowIndex", "+", "rowspan", ";", "const", "limitCellIndex", "=", "startCellIndex", "+", "colspan", ";", "util", ".", "range", "(", "startRowIndex", ",", "limitRowIndex", ")", ".", "forEach", "(", "rowIndex", "=>", "{", "base", "[", "rowIndex", "]", "=", "base", "[", "rowIndex", "]", "||", "[", "]", ";", "util", ".", "range", "(", "startCellIndex", ",", "limitCellIndex", ")", ".", "forEach", "(", "cellIndex", "=>", "{", "const", "mergedData", "=", "{", "nodeName", "}", ";", "if", "(", "rowIndex", "===", "startRowIndex", "&&", "cellIndex", "===", "startCellIndex", ")", "{", "return", ";", "}", "if", "(", "colMerged", ")", "{", "mergedData", ".", "colMergeWith", "=", "startCellIndex", ";", "}", "if", "(", "rowMerged", ")", "{", "mergedData", ".", "rowMergeWith", "=", "startRowIndex", ";", "}", "base", "[", "rowIndex", "]", "[", "cellIndex", "]", "=", "mergedData", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Add", "merged", "cell", "." ]

[ "function", "_getHeaderAligns", "(", "tableData", ")", "{", "const", "[", "headRowData", "]", "=", "tableData", ";", "return", "headRowData", ".", "map", "(", "cellData", "=>", "{", "let", "align", ";", "if", "(", "util", ".", "isExisty", "(", "cellData", ".", "colMergeWith", ")", ")", "{", "(", "{", "align", "}", "=", "headRowData", "[", "cellData", ".", "colMergeWith", "]", ")", ";", "}", "else", "{", "(", "{", "align", "}", "=", "cellData", ")", ";", "}", "return", "align", ";", "}", ")", ";", "}" ]

[ "Get", "header", "aligns", "." ]

[ "function", "createRenderData", "(", "tableData", ",", "cellIndexData", ")", "{", "const", "headerAligns", "=", "_getHeaderAligns", "(", "tableData", ")", ";", "const", "renderData", "=", "cellIndexData", ".", "map", "(", "row", "=>", "row", ".", "map", "(", "(", "{", "rowIndex", ",", "colIndex", "}", ")", "=>", "(", "util", ".", "extend", "(", "{", "align", ":", "headerAligns", "[", "colIndex", "]", "}", ",", "tableData", "[", "rowIndex", "]", "[", "colIndex", "]", ")", ")", ")", ")", ";", "if", "(", "tableData", ".", "className", ")", "{", "renderData", ".", "className", "=", "tableData", ".", "className", ";", "}", "return", "renderData", ";", "}" ]

[ "Create", "render", "data", "." ]

[ "function", "createBasicCell", "(", "rowIndex", ",", "colIndex", ",", "nodeName", ")", "{", "return", "{", "nodeName", ":", "nodeName", "||", "'TD'", ",", "colspan", ":", "1", ",", "rowspan", ":", "1", ",", "content", ":", "BASIC_CELL_CONTENT", ",", "elementIndex", ":", "{", "rowIndex", ",", "colIndex", "}", "}", ";", "}" ]

[ "Create", "basic", "cell", "data", "." ]

[ "function", "findElementIndex", "(", "tableData", ",", "rowIndex", ",", "colIndex", ")", "{", "const", "cellData", "=", "tableData", "[", "rowIndex", "]", "[", "colIndex", "]", ";", "rowIndex", "=", "util", ".", "isExisty", "(", "cellData", ".", "rowMergeWith", ")", "?", "cellData", ".", "rowMergeWith", ":", "rowIndex", ";", "colIndex", "=", "util", ".", "isExisty", "(", "cellData", ".", "colMergeWith", ")", "?", "cellData", ".", "colMergeWith", ":", "colIndex", ";", "return", "tableData", "[", "rowIndex", "]", "[", "colIndex", "]", ".", "elementIndex", ";", "}" ]

[ "Find", "cell", "element", "index", "." ]

[ "function", "stuffCellsIntoIncompleteRow", "(", "tableData", ",", "limitIndex", ")", "{", "tableData", ".", "forEach", "(", "(", "rowData", ",", "rowIndex", ")", "=>", "{", "const", "startIndex", "=", "rowData", ".", "length", ";", "if", "(", "startIndex", ")", "{", "const", "[", "{", "nodeName", "}", "]", "=", "rowData", ";", "util", ".", "range", "(", "startIndex", ",", "limitIndex", ")", ".", "forEach", "(", "colIndex", "=>", "{", "rowData", ".", "push", "(", "createBasicCell", "(", "rowIndex", ",", "colIndex", ",", "nodeName", ")", ")", ";", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Stuff", "cells", "into", "incomplete", "row", "." ]

[ "function", "addTbodyOrTheadIfNeed", "(", "tableData", ")", "{", "const", "[", "header", "]", "=", "tableData", ";", "const", "cellCount", "=", "header", ".", "length", ";", "let", "added", "=", "true", ";", "if", "(", "!", "cellCount", "&&", "tableData", "[", "1", "]", ")", "{", "util", ".", "range", "(", "0", ",", "tableData", "[", "1", "]", ".", "length", ")", ".", "forEach", "(", "colIndex", "=>", "{", "header", ".", "push", "(", "createBasicCell", "(", "0", ",", "colIndex", ",", "'TH'", ")", ")", ";", "}", ")", ";", "}", "else", "if", "(", "tableData", "[", "0", "]", "[", "0", "]", ".", "nodeName", "!==", "'TH'", ")", "{", "const", "newHeader", "=", "util", ".", "range", "(", "0", ",", "cellCount", ")", ".", "map", "(", "colIndex", "=>", "createBasicCell", "(", "0", ",", "colIndex", ",", "'TH'", ")", ")", ";", "[", "]", ".", "concat", "(", "...", "tableData", ")", ".", "forEach", "(", "cellData", "=>", "{", "if", "(", "cellData", ".", "elementIndex", ")", "{", "cellData", ".", "elementIndex", ".", "rowIndex", "+=", "1", ";", "}", "}", ")", ";", "tableData", ".", "unshift", "(", "newHeader", ")", ";", "}", "else", "if", "(", "tableData", ".", "length", "===", "1", ")", "{", "const", "newRow", "=", "util", ".", "range", "(", "0", ",", "cellCount", ")", ".", "map", "(", "colIndex", "=>", "(", "createBasicCell", "(", "1", ",", "colIndex", ",", "'TD'", ")", ")", ")", ";", "tableData", ".", "push", "(", "newRow", ")", ";", "}", "else", "{", "added", "=", "false", ";", "}", "return", "added", ";", "}" ]

[ "Add", "tbody", "or", "thead", "of", "table", "data", "if", "need", "." ]

[ "function", "styleItalic", "(", "sq", ")", "{", "if", "(", "sq", ".", "hasFormat", "(", "'i'", ")", "||", "sq", ".", "hasFormat", "(", "'em'", ")", ")", "{", "sq", ".", "changeFormat", "(", "null", ",", "{", "tag", ":", "'i'", "}", ")", ";", "}", "else", "if", "(", "!", "sq", ".", "hasFormat", "(", "'a'", ")", "&&", "!", "sq", ".", "hasFormat", "(", "'PRE'", ")", ")", "{", "if", "(", "sq", ".", "hasFormat", "(", "'code'", ")", ")", "{", "sq", ".", "changeFormat", "(", "null", ",", "{", "tag", ":", "'code'", "}", ")", ";", "}", "sq", ".", "italic", "(", ")", ";", "}", "}" ]

[ "Style", "italic", "." ]

[ "function", "_pickContent", "(", "targetRows", ",", "startColIndex", ",", "endColIndex", ")", "{", "const", "limitColIndex", "=", "endColIndex", "+", "1", ";", "const", "cells", "=", "[", "]", ".", "concat", "(", "...", "targetRows", ".", "map", "(", "rowData", "=>", "rowData", ".", "slice", "(", "startColIndex", ",", "limitColIndex", ")", ")", ")", ";", "const", "foundCellData", "=", "cells", ".", "filter", "(", "(", "{", "content", "}", ")", "=>", "content", "&&", "content", "!==", "BASIC_CELL_CONTENT", ")", ";", "return", "foundCellData", ".", "length", "?", "foundCellData", "[", "0", "]", ".", "content", ":", "BASIC_CELL_CONTENT", ";", "}" ]

[ "Pick", "merger", "content", "from", "selected", "cells", "." ]

[ "function", "_initCellData", "(", "targetRows", ",", "startColIndex", ",", "endColIndex", ")", "{", "const", "limitColIndex", "=", "endColIndex", "+", "1", ";", "const", "targetCells", "=", "targetRows", ".", "map", "(", "rowData", "=>", "rowData", ".", "slice", "(", "startColIndex", ",", "limitColIndex", ")", ")", ";", "[", "]", ".", "concat", "(", "...", "targetCells", ")", ".", "slice", "(", "1", ")", ".", "forEach", "(", "cellData", "=>", "{", "const", "{", "nodeName", "}", "=", "cellData", ";", "util", ".", "forEach", "(", "cellData", ",", "(", "value", ",", "name", ")", "=>", "(", "delete", "cellData", "[", "name", "]", ")", ")", ";", "cellData", ".", "nodeName", "=", "nodeName", ";", "}", ")", ";", "}" ]

[ "Initialize", "cell", "data", "of", "target", "rows", "." ]

[ "function", "_updateRowMergeWith", "(", "targetRows", ",", "startColIndex", ",", "endColIndex", ",", "rowMergeWith", ")", "{", "const", "limitColIndex", "=", "endColIndex", "+", "1", ";", "targetRows", ".", "forEach", "(", "rowData", "=>", "{", "rowData", ".", "slice", "(", "startColIndex", ",", "limitColIndex", ")", ".", "forEach", "(", "cellData", "=>", "{", "cellData", ".", "rowMergeWith", "=", "rowMergeWith", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Update", "rowMergeWith", "property", "of", "target", "rows", "for", "row", "merge", "." ]

[ "function", "_updateColMergeWith", "(", "targetRows", ",", "startColIndex", ",", "endColIndex", ",", "colMergeWith", ")", "{", "const", "limitColIndex", "=", "endColIndex", "+", "1", ";", "targetRows", ".", "forEach", "(", "rowData", "=>", "{", "rowData", ".", "slice", "(", "startColIndex", ",", "limitColIndex", ")", ".", "forEach", "(", "cellData", "=>", "{", "cellData", ".", "colMergeWith", "=", "colMergeWith", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Update", "colMergeWith", "property", "of", "target", "rows", "for", "column", "merge", "." ]

[ "function", "focusToFirstTd", "(", "sq", ",", "range", ",", "$tr", ",", "tableMgr", ")", "{", "const", "nextFocusCell", "=", "$tr", ".", "find", "(", "'td'", ")", ".", "get", "(", "0", ")", ";", "range", ".", "setStart", "(", "nextFocusCell", ",", "0", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "tableMgr", ".", "setLastCellNode", "(", "nextFocusCell", ")", ";", "sq", ".", "setSelection", "(", "range", ")", ";", "}" ]

[ "Focus", "to", "first", "TD", "in", "given", "TR" ]

[ "function", "getSelectedRows", "(", "firstSelectedCell", ",", "rangeInformation", ",", "$table", ")", "{", "const", "tbodyRowLength", "=", "$table", ".", "find", "(", "'tbody tr'", ")", ".", "length", ";", "const", "isStartContainerInThead", "=", "$", "(", "firstSelectedCell", ")", ".", "parents", "(", "'thead'", ")", ".", "length", ";", "let", "startRowIndex", "=", "rangeInformation", ".", "from", ".", "row", ";", "let", "endRowIndex", "=", "rangeInformation", ".", "to", ".", "row", ";", "if", "(", "isStartContainerInThead", ")", "{", "startRowIndex", "+=", "1", ";", "}", "const", "isWholeTbodySelected", "=", "(", "startRowIndex", "===", "1", "||", "isStartContainerInThead", ")", "&&", "endRowIndex", "===", "tbodyRowLength", ";", "if", "(", "isWholeTbodySelected", ")", "{", "endRowIndex", "-=", "1", ";", "}", "return", "$table", ".", "find", "(", "'tr'", ")", ".", "slice", "(", "startRowIndex", ",", "endRowIndex", "+", "1", ")", ";", "}" ]

[ "Get", "start", "end", "row", "index", "from", "current", "range" ]

[ "function", "_changeWysiwygManagers", "(", "wwComponentManager", ")", "{", "wwComponentManager", ".", "removeManager", "(", "'table'", ")", ";", "wwComponentManager", ".", "removeManager", "(", "'tableSelection'", ")", ";", "wwComponentManager", ".", "addManager", "(", "WwMergedTableManager", ")", ";", "wwComponentManager", ".", "addManager", "(", "WwMergedTableSelectionManager", ")", ";", "}" ]

[ "Change", "wysiwyg", "component", "managers", "." ]

[ "function", "_changeHtml", "(", "html", ",", "onChangeTable", ")", "{", "const", "$tempDiv", "=", "$", "(", "`", "${", "html", "}", "`", ")", ";", "const", "$tables", "=", "$tempDiv", ".", "find", "(", "'table'", ")", ";", "if", "(", "$tables", ".", "length", ")", "{", "$tables", ".", "get", "(", ")", ".", "forEach", "(", "tableElement", "=>", "{", "const", "changedTableElement", "=", "onChangeTable", "(", "tableElement", ")", ";", "$", "(", "tableElement", ")", ".", "replaceWith", "(", "changedTableElement", ")", ";", "}", ")", ";", "html", "=", "$tempDiv", ".", "html", "(", ")", ";", "}", "return", "html", ";", "}" ]

[ "Change", "html", "by", "onChangeTable", "function", "." ]

[ "function", "_snatchWysiwygCommand", "(", "commandWrapper", ")", "{", "const", "{", "command", "}", "=", "commandWrapper", ";", "if", "(", "!", "command", ".", "isWWType", "(", ")", ")", "{", "return", ";", "}", "switch", "(", "command", ".", "getName", "(", ")", ")", "{", "case", "'AddRow'", ":", "commandWrapper", ".", "command", "=", "wwAddRow", ";", "break", ";", "case", "'AddCol'", ":", "commandWrapper", ".", "command", "=", "wwAddCol", ";", "break", ";", "case", "'RemoveRow'", ":", "commandWrapper", ".", "command", "=", "wwRemoveRow", ";", "break", ";", "case", "'RemoveCol'", ":", "commandWrapper", ".", "command", "=", "wwRemoveCol", ";", "break", ";", "case", "'AlignCol'", ":", "commandWrapper", ".", "command", "=", "wwAlignCol", ";", "break", ";", "default", ":", "}", "}" ]

[ "Snatch", "wysiwyg", "command", "." ]

[ "function", "_bindEvents", "(", "eventManager", ")", "{", "eventManager", ".", "listen", "(", "'convertorAfterMarkdownToHtmlConverted'", ",", "html", "=>", "_changeHtml", "(", "html", ",", "createMergedTable", ")", ")", ";", "eventManager", ".", "listen", "(", "'convertorBeforeHtmlToMarkdownConverted'", ",", "html", "=>", "_changeHtml", "(", "html", ",", "prepareTableUnmerge", ")", ")", ";", "eventManager", ".", "listen", "(", "'addCommandBefore'", ",", "_snatchWysiwygCommand", ")", ";", "}" ]

[ "Bind", "events", "." ]

[ "function", "incrementRemainingMarkdownListNumbers", "(", "cm", ",", "pos", ")", "{", "var", "startLine", "=", "pos", ".", "line", ",", "lookAhead", "=", "0", ",", "skipCount", "=", "0", ";", "var", "startItem", "=", "listRE", ".", "exec", "(", "cm", ".", "getLine", "(", "startLine", ")", ")", ",", "startIndent", "=", "startItem", "[", "1", "]", ";", "do", "{", "lookAhead", "+=", "1", ";", "var", "nextLineNumber", "=", "startLine", "+", "lookAhead", ";", "var", "nextLine", "=", "cm", ".", "getLine", "(", "nextLineNumber", ")", ",", "nextItem", "=", "listRE", ".", "exec", "(", "nextLine", ")", ";", "if", "(", "nextItem", ")", "{", "var", "nextIndent", "=", "nextItem", "[", "1", "]", ";", "var", "newNumber", "=", "(", "parseInt", "(", "startItem", "[", "3", "]", ",", "10", ")", "+", "lookAhead", "-", "skipCount", ")", ";", "var", "nextNumber", "=", "(", "parseInt", "(", "nextItem", "[", "3", "]", ",", "10", ")", ")", ",", "itemNumber", "=", "nextNumber", ";", "if", "(", "startIndent", "===", "nextIndent", "&&", "!", "isNaN", "(", "nextNumber", ")", ")", "{", "if", "(", "newNumber", "===", "nextNumber", ")", "itemNumber", "=", "nextNumber", "+", "1", ";", "if", "(", "newNumber", ">", "nextNumber", ")", "itemNumber", "=", "newNumber", "+", "1", ";", "cm", ".", "replaceRange", "(", "nextLine", ".", "replace", "(", "listRE", ",", "nextIndent", "+", "itemNumber", "+", "nextItem", "[", "4", "]", "+", "nextItem", "[", "5", "]", ")", ",", "{", "line", ":", "nextLineNumber", ",", "ch", ":", "0", "}", ",", "{", "line", ":", "nextLineNumber", ",", "ch", ":", "nextLine", ".", "length", "}", ")", ";", "}", "else", "{", "if", "(", "startIndent", ".", "length", ">", "nextIndent", ".", "length", ")", "return", ";", "// This doesn't run if the next line immediatley indents, as it is", "// not clear of the users intention (new indented item or same level)", "if", "(", "(", "startIndent", ".", "length", "<", "nextIndent", ".", "length", ")", "&&", "(", "lookAhead", "===", "1", ")", ")", "return", ";", "skipCount", "+=", "1", ";", "}", "}", "}", "while", "(", "nextItem", ")", ";", "}" ]

[ "Auto", "-", "updating", "Markdown", "list", "numbers", "when", "a", "new", "item", "is", "added", "to", "the", "middle", "of", "a", "list" ]

[ "function", "fixNumber", "(", "lineNumber", ",", "prevIndentLength", ",", "startIndex", ",", "cm", ")", "{", "let", "indent", ",", "delimiter", ",", "text", ",", "indentLength", ";", "let", "index", "=", "startIndex", ";", "let", "lineText", "=", "cm", ".", "getLine", "(", "lineNumber", ")", ";", "do", "{", "[", ",", "indent", ",", ",", ",", "delimiter", ",", "text", "]", "=", "listRE", ".", "exec", "(", "lineText", ")", ";", "indentLength", "=", "indent", ".", "length", ";", "if", "(", "indentLength", "===", "prevIndentLength", ")", "{", "// fix number", "cm", ".", "replaceRange", "(", "`", "${", "indent", "}", "${", "index", "}", "${", "delimiter", "}", "${", "text", "}", "`", ",", "{", "line", ":", "lineNumber", ",", "ch", ":", "0", "}", ",", "{", "line", ":", "lineNumber", ",", "ch", ":", "lineText", ".", "length", "}", ")", ";", "index", "+=", "1", ";", "lineNumber", "+=", "1", ";", "}", "else", "if", "(", "indentLength", ">", "prevIndentLength", ")", "{", "// nested list start", "lineNumber", "=", "fixNumber", "(", "lineNumber", ",", "indentLength", ",", "1", ",", "cm", ")", ";", "}", "else", "{", "// nested list end", "return", "lineNumber", ";", "}", "lineText", "=", "cm", ".", "getLine", "(", "lineNumber", ")", ";", "}", "while", "(", "listRE", ".", "test", "(", "lineText", ")", ")", ";", "return", "lineNumber", ";", "}" ]

[ "fix", "list", "numbers" ]

[ "function", "findFirstListItem", "(", "lineNumber", ",", "cm", ")", "{", "let", "nextLineNumber", "=", "lineNumber", ";", "let", "lineText", "=", "cm", ".", "getLine", "(", "lineNumber", ")", ";", "while", "(", "listRE", ".", "test", "(", "lineText", ")", ")", "{", "nextLineNumber", "-=", "1", ";", "lineText", "=", "cm", ".", "getLine", "(", "nextLineNumber", ")", ";", "}", "if", "(", "lineNumber", "===", "nextLineNumber", ")", "{", "nextLineNumber", "=", "-", "1", ";", "}", "else", "{", "nextLineNumber", "+=", "1", ";", "}", "return", "nextLineNumber", ";", "}" ]

[ "find", "line", "number", "of", "list", "item", "which", "contains", "given", "lineNumber" ]

[ "function", "styleStrike", "(", "sq", ")", "{", "if", "(", "sq", ".", "hasFormat", "(", "'S'", ")", ")", "{", "sq", ".", "changeFormat", "(", "null", ",", "{", "tag", ":", "'S'", "}", ")", ";", "}", "else", "if", "(", "!", "sq", ".", "hasFormat", "(", "'a'", ")", "&&", "!", "sq", ".", "hasFormat", "(", "'PRE'", ")", ")", "{", "if", "(", "sq", ".", "hasFormat", "(", "'code'", ")", ")", "{", "sq", ".", "changeFormat", "(", "null", ",", "{", "tag", ":", "'code'", "}", ")", ";", "}", "sq", ".", "strikethrough", "(", ")", ";", "}", "}" ]

[ "Style", "strike", "." ]

[ "function", "_createNewCell", "(", "rowData", ",", "rowIndex", ",", "colIndex", ",", "prevCell", ")", "{", "const", "cellData", "=", "rowData", "[", "colIndex", "]", ";", "let", "newCell", ";", "if", "(", "util", ".", "isExisty", "(", "cellData", ".", "colMergeWith", ")", ")", "{", "const", "{", "colMergeWith", "}", "=", "cellData", ";", "const", "merger", "=", "rowData", "[", "colMergeWith", "]", ";", "const", "lastMergedCellIndex", "=", "colMergeWith", "+", "merger", ".", "colspan", "-", "1", ";", "if", "(", "util", ".", "isExisty", "(", "merger", ".", "rowMergeWith", ")", "&&", "prevCell", ")", "{", "newCell", "=", "util", ".", "extend", "(", "{", "}", ",", "prevCell", ")", ";", "}", "else", "if", "(", "lastMergedCellIndex", ">", "colIndex", ")", "{", "merger", ".", "colspan", "+=", "1", ";", "newCell", "=", "util", ".", "extend", "(", "{", "}", ",", "cellData", ")", ";", "}", "}", "else", "if", "(", "cellData", ".", "colspan", ">", "1", ")", "{", "cellData", ".", "colspan", "+=", "1", ";", "newCell", "=", "_createColMergedCell", "(", "colIndex", ",", "cellData", ".", "nodeName", ")", ";", "}", "if", "(", "!", "newCell", ")", "{", "newCell", "=", "dataHandler", ".", "createBasicCell", "(", "rowIndex", ",", "colIndex", "+", "1", ",", "cellData", ".", "nodeName", ")", ";", "}", "return", "newCell", ";", "}" ]

[ "Create", "new", "cell", "data", "." ]

[ "function", "_updateRowspan", "(", "tableData", ",", "startRowIndex", ",", "endRowIndex", ")", "{", "util", ".", "range", "(", "startRowIndex", ",", "endRowIndex", "+", "1", ")", ".", "forEach", "(", "rowIndex", "=>", "{", "tableData", "[", "rowIndex", "]", ".", "forEach", "(", "(", "cell", ",", "cellIndex", ")", "=>", "{", "if", "(", "util", ".", "isExisty", "(", "cell", ".", "rowMergeWith", ")", ")", "{", "const", "merger", "=", "tableData", "[", "cell", ".", "rowMergeWith", "]", "[", "cellIndex", "]", ";", "if", "(", "merger", ".", "rowspan", ")", "{", "merger", ".", "rowspan", "-=", "1", ";", "}", "}", "else", "if", "(", "cell", ".", "rowspan", ">", "1", ")", "{", "const", "lastMergedRowIndex", "=", "rowIndex", "+", "cell", ".", "rowspan", "-", "1", ";", "cell", ".", "rowspan", "-=", "(", "endRowIndex", "-", "rowIndex", "+", "1", ")", ";", "if", "(", "lastMergedRowIndex", ">", "endRowIndex", ")", "{", "tableData", "[", "endRowIndex", "+", "1", "]", "[", "cellIndex", "]", "=", "util", ".", "extend", "(", "{", "}", ",", "cell", ")", ";", "}", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Update", "rowspan", "to", "row", "merger", "." ]

[ "function", "wrapTextAndGetRange", "(", "pre", ",", "text", ",", "post", ")", "{", "return", "{", "result", ":", "`", "${", "pre", "}", "${", "text", "}", "${", "post", "}", "`", ",", "from", ":", "pre", ".", "length", ",", "to", ":", "pre", ".", "length", "+", "text", ".", "length", "}", ";", "}" ]

[ "wrap", "text", "with", "pre", "&", "post", "and", "return", "with", "text", "range" ]

[ "function", "changeDecColorsToHex", "(", "color", ")", "{", "return", "color", ".", "replace", "(", "decimalColorRx", ",", "(", "colorValue", ",", "r", ",", "g", ",", "b", ")", "=>", "{", "const", "hr", "=", "changeDecColorToHex", "(", "r", ")", ";", "const", "hg", "=", "changeDecColorToHex", "(", "g", ")", ";", "const", "hb", "=", "changeDecColorToHex", "(", "b", ")", ";", "return", "`", "${", "hr", "}", "${", "hg", "}", "${", "hb", "}", "`", ";", "}", ")", ";", "}" ]

[ "Change", "decimal", "color", "values", "to", "hexadecimal", "color", "value" ]

[ "function", "changeDecColorToHex", "(", "color", ")", "{", "let", "hexColor", "=", "parseInt", "(", "color", ",", "10", ")", ";", "hexColor", "=", "hexColor", ".", "toString", "(", "16", ")", ";", "hexColor", "=", "doubleZeroPad", "(", "hexColor", ")", ";", "return", "hexColor", ";", "}" ]

[ "change", "individual", "dec", "color", "value", "to", "hex", "color" ]

[ "function", "removeUnnecessaryCodeInNextToRange", "(", "range", ")", "{", "if", "(", "domUtils", ".", "getNodeName", "(", "range", ".", "startContainer", ".", "nextSibling", ")", "===", "'CODE'", "&&", "domUtils", ".", "getTextLength", "(", "range", ".", "startContainer", ".", "nextSibling", ")", "===", "0", ")", "{", "$", "(", "range", ".", "startContainer", ".", "nextSibling", ")", ".", "remove", "(", ")", ";", "}", "}" ]

[ "removeUnnecessaryCodeInNextToRange", "Remove", "unnecessary", "code", "tag", "next", "to", "range", "code", "tag", "made", "by", "squire" ]

[ "function", "styleCode", "(", "editor", ",", "sq", ")", "{", "if", "(", "!", "sq", ".", "hasFormat", "(", "'PRE'", ")", "&&", "sq", ".", "hasFormat", "(", "'code'", ")", ")", "{", "sq", ".", "changeFormat", "(", "null", ",", "{", "tag", ":", "'code'", "}", ")", ";", "removeUnnecessaryCodeInNextToRange", "(", "editor", ".", "getSelection", "(", ")", ".", "cloneRange", "(", ")", ")", ";", "}", "else", "if", "(", "!", "sq", ".", "hasFormat", "(", "'a'", ")", "&&", "!", "sq", ".", "hasFormat", "(", "'PRE'", ")", ")", "{", "if", "(", "sq", ".", "hasFormat", "(", "'b'", ")", ")", "{", "sq", ".", "removeBold", "(", ")", ";", "}", "else", "if", "(", "sq", ".", "hasFormat", "(", "'i'", ")", ")", "{", "sq", ".", "removeItalic", "(", ")", ";", "}", "sq", ".", "changeFormat", "(", "{", "tag", ":", "'code'", "}", ")", ";", "const", "range", "=", "sq", ".", "getSelection", "(", ")", ".", "cloneRange", "(", ")", ";", "range", ".", "setStart", "(", "range", ".", "endContainer", ",", "range", ".", "endOffset", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "sq", ".", "setSelection", "(", "range", ")", ";", "}", "}" ]

[ "Style", "code", "." ]

[ "function", "sanitizeHtmlCode", "(", "code", ")", "{", "return", "code", "?", "code", ".", "replace", "(", "/", "[<>&]", "/", "g", ",", "tag", "=>", "tagEntities", "[", "tag", "]", "||", "tag", ")", ":", "''", ";", "}" ]

[ "Sanitize", "HTML", "code" ]

[ "function", "_createCellHtml", "(", "cell", ")", "{", "let", "attrs", "=", "cell", ".", "colspan", ">", "1", "?", "`", "${", "cell", ".", "colspan", "}", "`", ":", "''", ";", "attrs", "+=", "cell", ".", "rowspan", ">", "1", "?", "`", "${", "cell", ".", "rowspan", "}", "`", ":", "''", ";", "attrs", "+=", "cell", ".", "align", "?", "`", "${", "cell", ".", "align", "}", "`", ":", "''", ";", "return", "`", "${", "cell", ".", "nodeName", "}", "${", "attrs", "}", "${", "cell", ".", "content", "}", "${", "cell", ".", "nodeName", "}", "`", ";", "}" ]

[ "Create", "cell", "html", "." ]

[ "function", "_createTheadOrTbodyHtml", "(", "trs", ",", "wrapperNodeName", ")", "{", "let", "html", "=", "''", ";", "if", "(", "trs", ".", "length", ")", "{", "html", "=", "trs", ".", "map", "(", "tr", "=>", "{", "const", "tdHtml", "=", "tr", ".", "map", "(", "_createCellHtml", ")", ".", "join", "(", "''", ")", ";", "return", "`", "${", "tdHtml", "}", "`", ";", "}", ")", ".", "join", "(", "''", ")", ";", "html", "=", "`", "${", "wrapperNodeName", "}", "${", "html", "}", "${", "wrapperNodeName", "}", "`", ";", "}", "return", "html", ";", "}" ]

[ "Create", "html", "for", "thead", "or", "tbody", "." ]

[ "function", "createTableHtml", "(", "renderData", ")", "{", "const", "thead", "=", "[", "renderData", "[", "0", "]", "]", ";", "const", "tbody", "=", "renderData", ".", "slice", "(", "1", ")", ";", "const", "theadHtml", "=", "_createTheadOrTbodyHtml", "(", "thead", ",", "'THEAD'", ")", ";", "const", "tbodyHtml", "=", "_createTheadOrTbodyHtml", "(", "tbody", ",", "'TBODY'", ")", ";", "const", "className", "=", "renderData", ".", "className", "?", "`", "${", "renderData", ".", "className", "}", "`", ":", "''", ";", "return", "`", "${", "className", "}", "${", "theadHtml", "+", "tbodyHtml", "}", "`", ";", "}" ]

[ "Create", "table", "html", "." ]

[ "function", "replaceTable", "(", "$table", ",", "tableData", ")", "{", "const", "cellIndexData", "=", "tableDataHandler", ".", "createCellIndexData", "(", "tableData", ")", ";", "const", "renderData", "=", "tableDataHandler", ".", "createRenderData", "(", "tableData", ",", "cellIndexData", ")", ";", "const", "$newTable", "=", "$", "(", "createTableHtml", "(", "renderData", ")", ")", ";", "$table", ".", "replaceWith", "(", "$newTable", ")", ";", "return", "$newTable", ";", "}" ]

[ "Replace", "table", "." ]

[ "function", "focusToCell", "(", "sq", ",", "range", ",", "targetCell", ")", "{", "range", ".", "selectNodeContents", "(", "targetCell", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "sq", ".", "setSelection", "(", "range", ")", ";", "}" ]

[ "Focus", "to", "cell", "." ]

[ "function", "_updateMergedCells", "(", "tableData", ",", "startRowIndex", ",", "startColIndex", ",", "rowspan", ",", "colspan", ")", "{", "const", "limitRowIndex", "=", "startRowIndex", "+", "rowspan", ";", "const", "limitColIndex", "=", "startColIndex", "+", "colspan", ";", "const", "colRange", "=", "util", ".", "range", "(", "startColIndex", ",", "limitColIndex", ")", ";", "util", ".", "range", "(", "startRowIndex", ",", "limitRowIndex", ")", ".", "forEach", "(", "rowIndex", "=>", "{", "const", "rowData", "=", "tableData", "[", "rowIndex", "]", ";", "const", "startIndex", "=", "(", "rowIndex", "===", "startRowIndex", ")", "?", "1", ":", "0", ";", "colRange", ".", "slice", "(", "startIndex", ")", ".", "forEach", "(", "colIndex", "=>", "{", "rowData", "[", "colIndex", "]", "=", "dataHandler", ".", "createBasicCell", "(", "rowIndex", ",", "colIndex", ",", "rowData", "[", "colIndex", "]", ".", "nodeName", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Update", "merged", "cell", "data", "to", "basic", "cell", "data", "." ]

[ "function", "_updateColspan", "(", "tableData", ",", "startColIndex", ",", "endColIndex", ")", "{", "tableData", ".", "forEach", "(", "rowData", "=>", "{", "util", ".", "range", "(", "startColIndex", ",", "endColIndex", "+", "1", ")", ".", "forEach", "(", "colIndex", "=>", "{", "const", "cellData", "=", "rowData", "[", "colIndex", "]", ";", "if", "(", "util", ".", "isExisty", "(", "cellData", ".", "colMergeWith", ")", ")", "{", "const", "merger", "=", "rowData", "[", "cellData", ".", "colMergeWith", "]", ";", "if", "(", "merger", ".", "colspan", ")", "{", "merger", ".", "colspan", "-=", "1", ";", "}", "}", "else", "if", "(", "cellData", ".", "colspan", ">", "1", ")", "{", "const", "lastMergedCellIndex", "=", "colIndex", "+", "cellData", ".", "colspan", "-", "1", ";", "cellData", ".", "colspan", "-=", "(", "endColIndex", "-", "colIndex", "+", "1", ")", ";", "if", "(", "lastMergedCellIndex", ">", "endColIndex", ")", "{", "rowData", "[", "endColIndex", "+", "1", "]", "=", "util", ".", "extend", "(", "{", "}", ",", "cellData", ")", ";", "}", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Update", "colspan", "to", "col", "merger", "." ]

[ "function", "getRange", "(", ")", "{", "const", "selection", "=", "window", ".", "getSelection", "(", ")", ";", "let", "range", ";", "if", "(", "selection", "&&", "selection", ".", "rangeCount", ")", "{", "range", "=", "selection", ".", "getRangeAt", "(", "0", ")", ".", "cloneRange", "(", ")", ";", "}", "else", "{", "range", "=", "document", ".", "createRange", "(", ")", ";", "range", ".", "selectNodeContents", "(", "this", ".", "preview", ".", "$el", "[", "0", "]", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "}", "return", "range", ";", "}" ]

[ "getRange", "get", "current", "range" ]

[ "function", "removeMarkdownTaskFormatText", "(", "token", ")", "{", "// '[X] ' length is 4", "// FIXED: we don't need first space", "token", ".", "content", "=", "token", ".", "content", ".", "slice", "(", "4", ")", ";", "token", ".", "children", "[", "0", "]", ".", "content", "=", "token", ".", "children", "[", "0", "]", ".", "content", ".", "slice", "(", "4", ")", ";", "}" ]

[ "Remove", "task", "format", "text", "for", "rendering" ]

[ "function", "isChecked", "(", "token", ")", "{", "var", "checked", "=", "false", ";", "if", "(", "token", ".", "content", ".", "indexOf", "(", "'[x]'", ")", "===", "0", "||", "token", ".", "content", ".", "indexOf", "(", "'[X]'", ")", "===", "0", ")", "{", "checked", "=", "true", ";", "}", "return", "checked", ";", "}" ]

[ "Return", "boolean", "value", "whether", "task", "checked", "or", "not" ]

[ "function", "setTokenAttribute", "(", "token", ",", "attributeName", ",", "attributeValue", ")", "{", "var", "index", "=", "token", ".", "attrIndex", "(", "attributeName", ")", ";", "var", "attr", "=", "[", "attributeName", ",", "attributeValue", "]", ";", "if", "(", "index", "<", "0", ")", "{", "token", ".", "attrPush", "(", "attr", ")", ";", "}", "else", "{", "token", ".", "attrs", "[", "index", "]", "=", "attr", ";", "}", "}" ]

[ "Set", "attribute", "of", "passed", "token" ]

[ "function", "isTaskListItemToken", "(", "tokens", ",", "index", ")", "{", "return", "tokens", "[", "index", "]", ".", "type", "===", "'inline'", "&&", "tokens", "[", "index", "-", "1", "]", ".", "type", "===", "'paragraph_open'", "&&", "tokens", "[", "index", "-", "2", "]", ".", "type", "===", "'list_item_open'", "&&", "(", "tokens", "[", "index", "]", ".", "content", ".", "indexOf", "(", "'[ ]'", ")", "===", "0", "||", "tokens", "[", "index", "]", ".", "content", ".", "indexOf", "(", "'[x]'", ")", "===", "0", "||", "tokens", "[", "index", "]", ".", "content", ".", "indexOf", "(", "'[X]'", ")", "===", "0", ")", ";", "}" ]

[ "Return", "boolean", "value", "whether", "task", "list", "item", "or", "not" ]

[ "function", "getCellByRange", "(", "range", ")", "{", "let", "cell", "=", "range", ".", "startContainer", ";", "if", "(", "domUtils", ".", "getNodeName", "(", "cell", ")", "===", "'TD'", "||", "domUtils", ".", "getNodeName", "(", "cell", ")", "===", "'TH'", ")", "{", "cell", "=", "$", "(", "cell", ")", ";", "}", "else", "{", "cell", "=", "$", "(", "cell", ")", ".", "parentsUntil", "(", "'tr'", ")", ";", "}", "return", "cell", ";", "}" ]

[ "Get", "cell", "by", "range", "object" ]

[ "function", "removeMultipleColsByCells", "(", "$cells", ")", "{", "const", "numberOfCells", "=", "$cells", ".", "length", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "numberOfCells", ";", "i", "+=", "1", ")", "{", "const", "$cellToDelete", "=", "$cells", ".", "eq", "(", "i", ")", ";", "if", "(", "$cellToDelete", ".", "length", ">", "0", ")", "{", "removeColByCell", "(", "$cells", ".", "eq", "(", "i", ")", ")", ";", "}", "}", "}" ]

[ "Remove", "columns", "by", "given", "cells" ]

[ "function", "removeColByCell", "(", "$cell", ")", "{", "const", "index", "=", "$cell", ".", "index", "(", ")", ";", "$cell", ".", "parents", "(", "'table'", ")", ".", "find", "(", "'tr'", ")", ".", "each", "(", "(", "n", ",", "tr", ")", "=>", "{", "$", "(", "tr", ")", ".", "children", "(", ")", ".", "eq", "(", "index", ")", ".", "remove", "(", ")", ";", "}", ")", ";", "}" ]

[ "Remove", "column", "by", "given", "cell" ]

[ "function", "focusToCell", "(", "sq", ",", "$cell", ",", "tableMgr", ")", "{", "const", "nextFocusCell", "=", "$cell", ".", "get", "(", "0", ")", ";", "if", "(", "$cell", ".", "length", "&&", "$", ".", "contains", "(", "document", ",", "$cell", ")", ")", "{", "const", "range", "=", "sq", ".", "getSelection", "(", ")", ";", "range", ".", "selectNodeContents", "(", "$cell", "[", "0", "]", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "sq", ".", "setSelection", "(", "range", ")", ";", "tableMgr", ".", "setLastCellNode", "(", "nextFocusCell", ")", ";", "}", "}" ]

[ "Focus", "to", "given", "cell" ]

[ "function", "styleBold", "(", "sq", ")", "{", "if", "(", "sq", ".", "hasFormat", "(", "'b'", ")", "||", "sq", ".", "hasFormat", "(", "'strong'", ")", ")", "{", "sq", ".", "changeFormat", "(", "null", ",", "{", "tag", ":", "'b'", "}", ")", ";", "}", "else", "if", "(", "!", "sq", ".", "hasFormat", "(", "'a'", ")", "&&", "!", "sq", ".", "hasFormat", "(", "'PRE'", ")", ")", "{", "if", "(", "sq", ".", "hasFormat", "(", "'code'", ")", ")", "{", "sq", ".", "changeFormat", "(", "null", ",", "{", "tag", ":", "'code'", "}", ")", ";", "}", "sq", ".", "bold", "(", ")", ";", "}", "}" ]

[ "Style", "bold", "." ]

[ "function", "any", "(", "arr", ",", "contition", ")", "{", "let", "result", "=", "false", ";", "util", ".", "forEach", "(", "arr", ",", "item", "=>", "{", "result", "=", "contition", "(", "item", ")", ";", "return", "!", "result", ";", "}", ")", ";", "return", "result", ";", "}" ]

[ "Whether", "one", "of", "them", "is", "true", "or", "not", "." ]

[ "function", "getNumberOfCols", "(", "wwe", ")", "{", "const", "selectionMgr", "=", "wwe", ".", "componentManager", ".", "getManager", "(", "'tableSelection'", ")", ";", "const", "$selectedCells", "=", "selectionMgr", ".", "getSelectedCells", "(", ")", ";", "let", "length", "=", "1", ";", "if", "(", "$selectedCells", ".", "length", ">", "0", ")", "{", "const", "maxLength", "=", "$selectedCells", ".", "get", "(", "0", ")", ".", "parentNode", ".", "querySelectorAll", "(", "'td, th'", ")", ".", "length", ";", "length", "=", "Math", ".", "min", "(", "maxLength", ",", "$selectedCells", ".", "length", ")", ";", "}", "return", "length", ";", "}" ]

[ "get", "number", "of", "selected", "cols" ]

[ "function", "addColToCellAfter", "(", "$cell", ",", "numberOfCols", "=", "1", ")", "{", "const", "index", "=", "$cell", ".", "index", "(", ")", ";", "let", "cellToAdd", ";", "$cell", ".", "parents", "(", "'table'", ")", ".", "find", "(", "'tr'", ")", ".", "each", "(", "(", "n", ",", "tr", ")", "=>", "{", "const", "isTBody", "=", "domUtils", ".", "getNodeName", "(", "tr", ".", "parentNode", ")", "===", "'TBODY'", ";", "const", "isMSIE", "=", "util", ".", "browser", ".", "msie", ";", "const", "cell", "=", "tr", ".", "children", "[", "index", "]", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "numberOfCols", ";", "i", "+=", "1", ")", "{", "if", "(", "isTBody", ")", "{", "cellToAdd", "=", "document", ".", "createElement", "(", "'td'", ")", ";", "}", "else", "{", "cellToAdd", "=", "document", ".", "createElement", "(", "'th'", ")", ";", "}", "if", "(", "!", "isMSIE", ")", "{", "cellToAdd", ".", "appendChild", "(", "document", ".", "createElement", "(", "'br'", ")", ")", ";", "}", "$", "(", "cellToAdd", ")", ".", "insertAfter", "(", "cell", ")", ";", "}", "}", ")", ";", "}" ]

[ "Add", "column", "to", "after", "the", "current", "cell" ]

[ "function", "focusToNextCell", "(", "sq", ",", "$cell", ")", "{", "const", "range", "=", "sq", ".", "getSelection", "(", ")", ";", "range", ".", "selectNodeContents", "(", "$cell", ".", "next", "(", ")", "[", "0", "]", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "sq", ".", "setSelection", "(", "range", ")", ";", "}" ]

[ "Focus", "to", "next", "cell" ]

[ "function", "umlExtension", "(", "editor", ",", "options", "=", "{", "}", ")", "{", "const", "{", "rendererURL", "=", "DEFAULT_RENDERER_URL", "}", "=", "options", ";", "/**\n * render html from uml\n * @param {string} umlCode - plant uml code text\n * @returns {string} - rendered html\n */", "function", "plantUMLReplacer", "(", "umlCode", ")", "{", "let", "renderedHTML", ";", "try", "{", "if", "(", "!", "plantumlEncoder", ")", "{", "throw", "new", "Error", "(", "'plantuml-encoder dependency required'", ")", ";", "}", "renderedHTML", "=", "`", "${", "rendererURL", "}", "${", "plantumlEncoder", ".", "encode", "(", "umlCode", ")", "}", "`", ";", "}", "catch", "(", "err", ")", "{", "renderedHTML", "=", "`", "${", "err", ".", "message", "}", "`", ";", "}", "return", "renderedHTML", ";", "}", "const", "{", "codeBlockLanguages", "}", "=", "editor", ".", "options", ";", "UML_LANGUAGES", ".", "forEach", "(", "umlLanguage", "=>", "{", "if", "(", "codeBlockLanguages", ".", "indexOf", "(", "umlLanguage", ")", "<", "0", ")", "{", "codeBlockLanguages", ".", "push", "(", "umlLanguage", ")", ";", "}", "codeBlockManager", ".", "setReplacer", "(", "umlLanguage", ",", "plantUMLReplacer", ")", ";", "}", ")", ";", "}" ]

[ "plant", "uml", "plugin" ]

[ "function", "plantUMLReplacer", "(", "umlCode", ")", "{", "let", "renderedHTML", ";", "try", "{", "if", "(", "!", "plantumlEncoder", ")", "{", "throw", "new", "Error", "(", "'plantuml-encoder dependency required'", ")", ";", "}", "renderedHTML", "=", "`", "${", "rendererURL", "}", "${", "plantumlEncoder", ".", "encode", "(", "umlCode", ")", "}", "`", ";", "}", "catch", "(", "err", ")", "{", "renderedHTML", "=", "`", "${", "err", ".", "message", "}", "`", ";", "}", "return", "renderedHTML", ";", "}" ]

[ "render", "html", "from", "uml" ]

[ "function", "_changeContent", "(", "popupTableUtils", ")", "{", "const", "POPUP_CONTENT", "=", "[", "`", "${", "i18n", ".", "get", "(", "'Add row'", ")", "}", "`", ",", "`", "${", "i18n", ".", "get", "(", "'Add col'", ")", "}", "`", ",", "`", "${", "i18n", ".", "get", "(", "'Remove row'", ")", "}", "`", ",", "`", "${", "i18n", ".", "get", "(", "'Remove col'", ")", "}", "`", ",", "'<hr/>'", ",", "`", "${", "i18n", ".", "get", "(", "'Merge cells'", ")", "}", "`", ",", "`", "${", "i18n", ".", "get", "(", "'Unmerge cells'", ")", "}", "`", ",", "'<hr/>'", ",", "`", "${", "i18n", ".", "get", "(", "'Align left'", ")", "}", "`", ",", "`", "${", "i18n", ".", "get", "(", "'Align center'", ")", "}", "`", ",", "`", "${", "i18n", ".", "get", "(", "'Align right'", ")", "}", "`", ",", "'<hr/>'", ",", "`", "${", "i18n", ".", "get", "(", "'Remove table'", ")", "}", "`", "]", ".", "join", "(", "''", ")", ";", "const", "$popupContent", "=", "$", "(", "POPUP_CONTENT", ")", ";", "popupTableUtils", ".", "setContent", "(", "$popupContent", ")", ";", "}" ]

[ "Change", "contextmenu", "content", "." ]

[ "function", "_bindEvents", "(", "popupTableUtils", ",", "eventManager", ",", "selectionManager", ")", "{", "const", "$popupContent", "=", "popupTableUtils", ".", "$content", ";", "const", "$mergeBtn", "=", "$", "(", "$popupContent", "[", "5", "]", ")", ";", "const", "$unmergeBtn", "=", "$", "(", "$popupContent", "[", "6", "]", ")", ";", "const", "$separator", "=", "$", "(", "$popupContent", "[", "7", "]", ")", ";", "popupTableUtils", ".", "on", "(", "'click .te-table-merge'", ",", "(", ")", "=>", "{", "eventManager", ".", "emit", "(", "'command'", ",", "'MergeCells'", ")", ";", "}", ")", ";", "popupTableUtils", ".", "on", "(", "'click .te-table-unmerge'", ",", "(", ")", "=>", "{", "eventManager", ".", "emit", "(", "'command'", ",", "'UnmergeCells'", ")", ";", "}", ")", ";", "eventManager", ".", "listen", "(", "'openPopupTableUtils'", ",", "(", ")", "=>", "{", "const", "$selectedCells", "=", "selectionManager", ".", "getSelectedCells", "(", ")", ";", "const", "selectedCellCount", "=", "$selectedCells", ".", "length", ";", "if", "(", "selectedCellCount", ")", "{", "if", "(", "selectedCellCount", "<", "2", "||", "selectionManager", ".", "hasSelectedBothThAndTd", "(", "$selectedCells", ")", ")", "{", "$mergeBtn", ".", "hide", "(", ")", ";", "}", "else", "{", "$mergeBtn", ".", "show", "(", ")", ";", "}", "if", "(", "$selectedCells", ".", "is", "(", "'[rowspan], [colspan]'", ")", ")", "{", "$unmergeBtn", ".", "show", "(", ")", ";", "}", "else", "{", "$unmergeBtn", ".", "hide", "(", ")", ";", "}", "$separator", ".", "show", "(", ")", ";", "}", "else", "{", "$mergeBtn", ".", "hide", "(", ")", ";", "$unmergeBtn", ".", "hide", "(", ")", ";", "$separator", ".", "hide", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Bind", "events", "for", "merge", "feature", "of", "contextmenu", "." ]

[ "function", "updateContextMenu", "(", "popupTableUtils", ",", "eventManager", ",", "selectionManager", ")", "{", "_changeContent", "(", "popupTableUtils", ")", ";", "_bindEvents", "(", "popupTableUtils", ",", "eventManager", ",", "selectionManager", ")", ";", "}" ]

[ "Update", "contextmenu", "UI", "." ]

[ "function", "_align", "(", "headRowData", ",", "startColIndex", ",", "endColIndex", ",", "alignDirection", ")", "{", "util", ".", "range", "(", "startColIndex", ",", "endColIndex", "+", "1", ")", ".", "forEach", "(", "colIndex", "=>", "{", "const", "headCellData", "=", "headRowData", "[", "colIndex", "]", ";", "if", "(", "util", ".", "isExisty", "(", "headCellData", ".", "colMergeWith", ")", ")", "{", "headRowData", "[", "headCellData", ".", "colMergeWith", "]", ".", "align", "=", "alignDirection", ";", "}", "else", "{", "headCellData", ".", "align", "=", "alignDirection", ";", "}", "}", ")", ";", "}" ]

[ "Align", "to", "table", "header", "." ]

[ "function", "focusToFirstCode", "(", "$pre", ",", "wwe", ")", "{", "const", "range", "=", "wwe", ".", "getEditor", "(", ")", ".", "getSelection", "(", ")", ".", "cloneRange", "(", ")", ";", "$pre", ".", "removeClass", "(", "CODEBLOCK_CLASS_TEMP", ")", ";", "range", ".", "setStartBefore", "(", "$pre", ".", "get", "(", "0", ")", ".", "firstChild", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "wwe", ".", "getEditor", "(", ")", ".", "setSelection", "(", "range", ")", ";", "}" ]

[ "focusToFirstCode", "Focus", "to", "first", "code", "tag", "content", "of", "pre", "tag" ]

[ "function", "getCodeBlockBody", "(", "range", ",", "wwe", ")", "{", "const", "mgr", "=", "wwe", ".", "componentManager", ".", "getManager", "(", "'codeblock'", ")", ";", "let", "codeBlock", ";", "if", "(", "range", ".", "collapsed", ")", "{", "codeBlock", "=", "'<br>'", ";", "}", "else", "{", "const", "contents", "=", "range", ".", "extractContents", "(", ")", ";", "const", "nodes", "=", "util", ".", "toArray", "(", "contents", ".", "childNodes", ")", ";", "const", "tempDiv", "=", "$", "(", "'<div>'", ")", ".", "append", "(", "mgr", ".", "prepareToPasteOnCodeblock", "(", "nodes", ")", ")", ";", "codeBlock", "=", "tempDiv", ".", "html", "(", ")", ";", "}", "return", "codeBlock", ";", "}" ]

[ "getCodeBlockBody", "get", "text", "wrapped", "by", "code" ]

[ "function", "tableCellGenerator", "(", "amount", ",", "tagName", ")", "{", "const", "brHTMLString", "=", "'<br />'", ";", "const", "cellString", "=", "`", "${", "tagName", "}", "${", "brHTMLString", "}", "${", "tagName", "}", "`", ";", "let", "tdString", "=", "''", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "amount", ";", "i", "+=", "1", ")", "{", "tdString", "=", "tdString", "+", "cellString", ";", "}", "return", "tdString", ";", "}" ]

[ "Generate", "table", "cell", "HTML", "text" ]

[ "function", "_findIndex", "(", "arr", ",", "onFind", ")", "{", "let", "foundIndex", "=", "-", "1", ";", "util", ".", "forEach", "(", "arr", ",", "(", "item", ",", "index", ")", "=>", "{", "let", "nextFind", "=", "true", ";", "if", "(", "onFind", "(", "item", ",", "index", ")", ")", "{", "foundIndex", "=", "index", ";", "nextFind", "=", "false", ";", "}", "return", "nextFind", ";", "}", ")", ";", "return", "foundIndex", ";", "}" ]

[ "Find", "index", "by", "onFind", "function", "." ]

[ "function", "focusToFirstTh", "(", "sq", ",", "$table", ")", "{", "const", "range", "=", "sq", ".", "getSelection", "(", ")", ";", "range", ".", "selectNodeContents", "(", "$table", ".", "find", "(", "'th'", ")", "[", "0", "]", ")", ";", "range", ".", "collapse", "(", "true", ")", ";", "sq", ".", "setSelection", "(", "range", ")", ";", "}" ]

[ "Focus", "to", "first", "th" ]

[ "function", "makeHeader", "(", "col", ",", "data", ")", "{", "let", "header", "=", "'<thead><tr>'", ";", "let", "index", "=", "0", ";", "while", "(", "col", ")", "{", "header", "+=", "'<th>'", ";", "if", "(", "data", ")", "{", "header", "+=", "data", "[", "index", "]", ";", "index", "+=", "1", ";", "}", "header", "+=", "'</th>'", ";", "col", "-=", "1", ";", "}", "header", "+=", "'</tr></thead>'", ";", "return", "header", ";", "}" ]

[ "makeHeader", "make", "table", "header", "html", "string" ]

[ "function", "makeBody", "(", "col", ",", "row", ",", "data", ")", "{", "let", "body", "=", "'<tbody>'", ";", "let", "index", "=", "col", ";", "for", "(", "let", "irow", "=", "0", ";", "irow", "<", "row", ";", "irow", "+=", "1", ")", "{", "body", "+=", "'<tr>'", ";", "for", "(", "let", "icol", "=", "0", ";", "icol", "<", "col", ";", "icol", "+=", "1", ")", "{", "body", "+=", "'<td>'", ";", "if", "(", "data", ")", "{", "body", "+=", "data", "[", "index", "]", ";", "index", "+=", "1", ";", "}", "body", "+=", "'</td>'", ";", "}", "body", "+=", "'</tr>'", ";", "}", "body", "+=", "'</tbody>'", ";", "return", "body", ";", "}" ]

[ "makeBody", "make", "table", "body", "html", "string" ]

[ "function", "getHeadingMarkdown", "(", "text", ",", "size", ")", "{", "const", "foundedHeading", "=", "text", ".", "match", "(", "FIND_HEADING_RX", ")", ";", "let", "heading", "=", "''", ";", "do", "{", "heading", "+=", "'#'", ";", "size", "-=", "1", ";", "}", "while", "(", "size", ">", "0", ")", ";", "if", "(", "foundedHeading", ")", "{", "[", ",", "text", "]", "=", "text", ".", "split", "(", "foundedHeading", "[", "0", "]", ")", ";", "}", "return", "`", "${", "heading", "}", "${", "text", "}", "`", ";", "}" ]

[ "Get", "heading", "markdown" ]

[ "function", "parseCode2DataAndOptions", "(", "code", ",", "callback", ")", "{", "code", "=", "trimKeepingTabs", "(", "code", ")", ";", "const", "[", "firstCode", ",", "secondCode", "]", "=", "code", ".", "split", "(", "/", "\\n{2,}", "/", ")", ";", "// try to parse first code block as `options`", "let", "options", "=", "parseCode2ChartOption", "(", "firstCode", ")", ";", "const", "url", "=", "options", "&&", "options", ".", "editorChart", "&&", "options", ".", "editorChart", ".", "url", ";", "// if first code block is `options` and has `url` option, fetch data from url", "let", "dataAndOptions", ";", "if", "(", "util", ".", "isString", "(", "url", ")", ")", "{", "// url option provided", "// fetch data from url", "const", "success", "=", "dataCode", "=>", "{", "dataAndOptions", "=", "_parseCode2DataAndOptions", "(", "dataCode", ",", "firstCode", ")", ";", "callback", "(", "dataAndOptions", ")", ";", "}", ";", "const", "fail", "=", "(", ")", "=>", "callback", "(", "null", ")", ";", "$", ".", "get", "(", "url", ")", ".", "done", "(", "success", ")", ".", "fail", "(", "fail", ")", ";", "}", "else", "{", "// else first block is `data`", "dataAndOptions", "=", "_parseCode2DataAndOptions", "(", "firstCode", ",", "secondCode", ")", ";", "callback", "(", "dataAndOptions", ")", ";", "}", "}" ]

[ "parse", "data", "and", "options", "for", "tui", ".", "chart", "data", "format", "can", "be", "csv", "tsv", "options", "format", "is", "colon", "separated", "keys", "&", "values" ]

[ "function", "_parseCode2DataAndOptions", "(", "dataCode", ",", "optionCode", ")", "{", "const", "data", "=", "parseDSV2ChartData", "(", "dataCode", ")", ";", "const", "options", "=", "parseCode2ChartOption", "(", "optionCode", ")", ";", "return", "{", "data", ",", "options", "}", ";", "}" ]

[ "parse", "codes", "to", "chart", "data", "&", "options", "Object" ]

[ "function", "detectDelimiter", "(", "code", ")", "{", "code", "=", "trimKeepingTabs", "(", "code", ")", ";", "// chunk first max 10 lines to detect", "const", "chunk", "=", "code", ".", "split", "(", "REGEX_LINE_ENDING", ")", ".", "slice", "(", "0", ",", "10", ")", ".", "join", "(", "'\\n'", ")", ";", "// calc delta for each delimiters", "// then pick a delimiter having the minimum value delta", "return", "DSV_DELIMITERS", ".", "map", "(", "delimiter", "=>", "(", "{", "delimiter", ",", "delta", ":", "calcDSVDelta", "(", "chunk", ",", "delimiter", ")", "}", ")", ")", ".", "sort", "(", "(", "a", ",", "b", ")", "=>", "(", "a", ".", "delta", "-", "b", ".", "delta", ")", ")", "[", "0", "]", ".", "delimiter", ";", "}" ]

[ "detect", "delimiter", "the", "comma", "tab", "regex" ]

[ "function", "parseDSV2ChartData", "(", "code", ",", "delimiter", ")", "{", "// trim all heading/trailing blank lines", "code", "=", "trimKeepingTabs", "(", "code", ")", ";", "csv", ".", "COLUMN_SEPARATOR", "=", "delimiter", "||", "detectDelimiter", "(", "code", ")", ";", "let", "dsv", "=", "csv", ".", "parse", "(", "code", ")", ";", "// trim all values in 2D array", "dsv", "=", "dsv", ".", "map", "(", "arr", "=>", "arr", ".", "map", "(", "val", "=>", "val", ".", "trim", "(", ")", ")", ")", ";", "// test a first row for legends. ['anything', '1', '2', '3'] === false, ['anything', 't1', '2', 't3'] === true", "const", "hasLegends", "=", "dsv", "[", "0", "]", ".", "filter", "(", "(", "v", ",", "i", ")", "=>", "i", ">", "0", ")", ".", "reduce", "(", "(", "hasNaN", ",", "item", ")", "=>", "hasNaN", "||", "!", "isNumeric", "(", "item", ")", ",", "false", ")", ";", "const", "legends", "=", "hasLegends", "?", "dsv", ".", "shift", "(", ")", ":", "[", "]", ";", "// test a first column for categories", "const", "hasCategories", "=", "dsv", ".", "slice", "(", "1", ")", ".", "reduce", "(", "(", "hasNaN", ",", "row", ")", "=>", "hasNaN", "||", "!", "isNumeric", "(", "row", "[", "0", "]", ")", ",", "false", ")", ";", "const", "categories", "=", "hasCategories", "?", "dsv", ".", "map", "(", "arr", "=>", "arr", ".", "shift", "(", ")", ")", ":", "[", "]", ";", "if", "(", "hasCategories", ")", "{", "legends", ".", "shift", "(", ")", ";", "}", "// transpose dsv, parse number", "// [['1','2','3'] [[1,4,7]", "// ['4','5','6'] => [2,5,8]", "// ['7','8','9']] [3,6,9]]", "dsv", "=", "dsv", "[", "0", "]", ".", "map", "(", "(", "t", ",", "i", ")", "=>", "dsv", ".", "map", "(", "x", "=>", "parseFloat", "(", "x", "[", "i", "]", ")", ")", ")", ";", "// make series", "const", "series", "=", "dsv", ".", "map", "(", "(", "data", ",", "i", ")", "=>", "hasLegends", "?", "{", "name", ":", "legends", "[", "i", "]", ",", "data", "}", ":", "{", "data", "}", ")", ";", "return", "{", "categories", ",", "series", "}", ";", "}" ]

[ "parse", "csv", "tsv", "to", "chart", "data" ]

[ "function", "parseURL2ChartData", "(", "url", ",", "callback", ")", "{", "const", "success", "=", "code", "=>", "{", "const", "chartData", "=", "parseDSV2ChartData", "(", "code", ")", ";", "callback", "(", "chartData", ")", ";", "}", ";", "const", "fail", "=", "(", ")", "=>", "callback", "(", "null", ")", ";", "$", ".", "get", "(", "url", ")", ".", "done", "(", "success", ")", ".", "fail", "(", "fail", ")", ";", "}" ]

[ "parse", "code", "from", "url" ]

[ "function", "parseCode2ChartOption", "(", "optionCode", ")", "{", "const", "reservedKeys", "=", "[", "'type'", ",", "'url'", "]", ";", "let", "options", "=", "{", "}", ";", "if", "(", "util", ".", "isUndefined", "(", "optionCode", ")", ")", "{", "return", "options", ";", "}", "const", "optionLines", "=", "optionCode", ".", "split", "(", "REGEX_LINE_ENDING", ")", ";", "optionLines", ".", "forEach", "(", "line", "=>", "{", "let", "[", "keyString", ",", "...", "values", "]", "=", "line", ".", "split", "(", "OPTION_DELIMITER", ")", ";", "let", "value", "=", "values", ".", "join", "(", "OPTION_DELIMITER", ")", ";", "keyString", "=", "keyString", ".", "trim", "(", ")", ";", "if", "(", "value", ".", "length", "===", "0", ")", "{", "return", ";", "}", "try", "{", "value", "=", "JSON", ".", "parse", "(", "value", ".", "trim", "(", ")", ")", ";", "}", "catch", "(", "e", ")", "{", "value", "=", "value", ".", "trim", "(", ")", ";", "}", "// parse keys", "let", "[", "...", "keys", "]", "=", "keyString", ".", "split", "(", "'.'", ")", ";", "let", "topKey", "=", "keys", "[", "0", "]", ";", "if", "(", "util", ".", "inArray", "(", "topKey", ",", "reservedKeys", ")", ">=", "0", ")", "{", "// reserved keys for chart plugin option", "keys", ".", "unshift", "(", "'editorChart'", ")", ";", "}", "else", "if", "(", "keys", ".", "length", "===", "1", ")", "{", "// short names for `chart`", "keys", ".", "unshift", "(", "'chart'", ")", ";", "}", "else", "if", "(", "topKey", "===", "'x'", "||", "topKey", "===", "'y'", ")", "{", "// short-handed keys", "keys", "[", "0", "]", "=", "`", "${", "topKey", "}", "`", ";", "}", "let", "option", "=", "options", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "keys", ".", "length", ";", "i", "+=", "1", ")", "{", "let", "key", "=", "keys", "[", "i", "]", ";", "option", "[", "key", "]", "=", "option", "[", "key", "]", "||", "(", "keys", ".", "length", "-", "1", "===", "i", "?", "value", ":", "{", "}", ")", ";", "option", "=", "option", "[", "key", "]", ";", "}", "}", ")", ";", "return", "options", ";", "}" ]

[ "parse", "option", "code" ]

[ "function", "setDefaultOptions", "(", "chartOptions", ",", "extensionOptions", ",", "chartContainer", ")", "{", "// chart options scaffolding", "chartOptions", "=", "util", ".", "extend", "(", "{", "editorChart", ":", "{", "}", ",", "chart", ":", "{", "}", ",", "chartExportMenu", ":", "{", "}", ",", "usageStatistics", ":", "extensionOptions", ".", "usageStatistics", "}", ",", "chartOptions", ")", ";", "// set default extension options", "extensionOptions", "=", "util", ".", "extend", "(", "DEFAULT_CHART_OPTIONS", ",", "extensionOptions", ")", ";", "// determine width, height", "let", "{", "width", ",", "height", "}", "=", "chartOptions", ".", "chart", ";", "const", "isWidthUndefined", "=", "util", ".", "isUndefined", "(", "width", ")", ";", "const", "isHeightUndefined", "=", "util", ".", "isUndefined", "(", "height", ")", ";", "if", "(", "isWidthUndefined", "||", "isHeightUndefined", ")", "{", "// if no width or height specified, set width and height to container width", "const", "{", "width", ":", "containerWidth", "}", "=", "chartContainer", ".", "getBoundingClientRect", "(", ")", ";", "width", "=", "isWidthUndefined", "?", "extensionOptions", ".", "width", ":", "width", ";", "height", "=", "isHeightUndefined", "?", "extensionOptions", ".", "height", ":", "height", ";", "width", "=", "width", "===", "'auto'", "?", "containerWidth", ":", "width", ";", "height", "=", "height", "===", "'auto'", "?", "containerWidth", ":", "height", ";", "}", "width", "=", "Math", ".", "min", "(", "extensionOptions", ".", "maxWidth", ",", "width", ")", ";", "height", "=", "Math", ".", "min", "(", "extensionOptions", ".", "maxHeight", ",", "height", ")", ";", "chartOptions", ".", "chart", ".", "width", "=", "Math", ".", "max", "(", "extensionOptions", ".", "minWidth", ",", "width", ")", ";", "chartOptions", ".", "chart", ".", "height", "=", "Math", ".", "max", "(", "extensionOptions", ".", "minHeight", ",", "height", ")", ";", "// default chart type", "chartOptions", ".", "editorChart", ".", "type", "=", "chartOptions", ".", "editorChart", ".", "type", "?", "`", "${", "chartOptions", ".", "editorChart", ".", "type", "}", "`", ":", "'columnChart'", ";", "// default visibility of export menu", "chartOptions", ".", "chartExportMenu", ".", "visible", "=", "chartOptions", ".", "chartExportMenu", ".", "visible", "||", "false", ";", "return", "chartOptions", ";", "}" ]

[ "set", "default", "options" ]

[ "function", "chartReplacer", "(", "codeBlockChartDataAndOptions", ",", "extensionOptions", ")", "{", "const", "randomId", "=", "`", "${", "Math", ".", "random", "(", ")", ".", "toString", "(", "36", ")", ".", "substr", "(", "2", ",", "10", ")", "}", "`", ";", "let", "renderedHTML", "=", "`", "${", "randomId", "}", "`", ";", "setTimeout", "(", "(", ")", "=>", "{", "const", "chartContainer", "=", "document", ".", "querySelector", "(", "`", "${", "randomId", "}", "`", ")", ";", "try", "{", "parseCode2DataAndOptions", "(", "codeBlockChartDataAndOptions", ",", "(", "{", "data", ",", "options", ":", "chartOptions", "}", ")", "=>", "{", "chartOptions", "=", "setDefaultOptions", "(", "chartOptions", ",", "extensionOptions", ",", "chartContainer", ")", ";", "const", "chartType", "=", "chartOptions", ".", "editorChart", ".", "type", ";", "if", "(", "SUPPORTED_CHART_TYPES", ".", "indexOf", "(", "chartType", ")", "<", "0", ")", "{", "chartContainer", ".", "innerHTML", "=", "`", "`", ";", "}", "else", "if", "(", "CATEGORY_CHART_TYPES", ".", "indexOf", "(", "chartType", ")", ">", "-", "1", "&&", "data", ".", "categories", ".", "length", "!==", "data", ".", "series", "[", "0", "]", ".", "data", ".", "length", ")", "{", "chartContainer", ".", "innerHTML", "=", "'invalid chart data'", ";", "}", "else", "{", "chart", "[", "chartType", "]", "(", "chartContainer", ",", "data", ",", "chartOptions", ")", ";", "}", "}", ")", ";", "}", "catch", "(", "e", ")", "{", "chartContainer", ".", "innerHTML", "=", "'invalid chart data'", ";", "}", "}", ",", "0", ")", ";", "return", "renderedHTML", ";", "}" ]

[ "replace", "html", "from", "chart", "data" ]

[ "function", "_reduceToTSV", "(", "arr", ")", "{", "// 2D array => quoted TSV row array", "// [['a', 'b b'], [1, 2]] => ['a\\t\"b b\"', '1\\t2']", "return", "arr", ".", "reduce", "(", "(", "acc", ",", "row", ")", "=>", "{", "// ['a', 'b b', 'c c'] => ['a', '\"b b\"', '\"c c\"']", "const", "quoted", "=", "row", ".", "map", "(", "text", "=>", "{", "if", "(", "!", "isNumeric", "(", "text", ")", "&&", "text", ".", "indexOf", "(", "' '", ")", ">=", "0", ")", "{", "text", "=", "`", "${", "text", "}", "`", ";", "}", "return", "text", ";", "}", ")", ";", "// ['a', '\"b b\"', '\"c c\"'] => 'a\\t\"b b\"\\t\"c c\"'", "acc", ".", "push", "(", "quoted", ".", "join", "(", "'\\t'", ")", ")", ";", "return", "acc", ";", "}", ",", "[", "]", ")", ";", "}" ]

[ "reduce", "2D", "array", "to", "TSV", "rows" ]

[ "function", "_setWwCodeBlockManagerForChart", "(", "editor", ")", "{", "const", "componentManager", "=", "editor", ".", "wwEditor", ".", "componentManager", ";", "componentManager", ".", "removeManager", "(", "'codeblock'", ")", ";", "componentManager", ".", "addManager", "(", "class", "extends", "WwCodeBlockManager", "{", "/**\n * Convert table nodes into code block as TSV\n * @memberof WwCodeBlockManager\n * @param {Array.<Node>} nodes Node array\n * @returns {HTMLElement} Code block element\n */", "convertNodesToText", "(", "nodes", ")", "{", "if", "(", "nodes", ".", "length", "!==", "1", "||", "nodes", "[", "0", "]", ".", "tagName", "!==", "'TABLE'", ")", "{", "return", "super", ".", "convertNodesToText", "(", "nodes", ")", ";", "}", "const", "node", "=", "nodes", ".", "shift", "(", ")", ";", "let", "str", "=", "''", ";", "// convert table to 2-dim array", "const", "cells", "=", "[", "]", ".", "slice", ".", "call", "(", "node", ".", "rows", ")", ".", "map", "(", "row", "=>", "[", "]", ".", "slice", ".", "call", "(", "row", ".", "cells", ")", ".", "map", "(", "cell", "=>", "cell", ".", "innerText", ".", "trim", "(", ")", ")", ")", ";", "const", "tsvRows", "=", "_reduceToTSV", "(", "cells", ")", ";", "str", "+=", "tsvRows", ".", "reduce", "(", "(", "acc", ",", "row", ")", "=>", "acc", "+", "`", "${", "row", "}", "\\n", "`", ",", "[", "]", ")", ";", "return", "str", ";", "}", "}", ")", ";", "}" ]

[ "override", "WwCodeBlockManager", "to", "enclose", "pasting", "data", "strings", "from", "wysiwyg", "in", "quotes" ]

[ "function", "_onMDPasteBefore", "(", "cm", ",", "{", "source", ",", "data", ":", "eventData", "}", ")", "{", "if", "(", "!", "_isFromCodeBlockInCodeMirror", "(", "cm", ",", "source", ",", "eventData", ")", ")", "{", "return", ";", "}", "const", "code", "=", "eventData", ".", "text", ".", "join", "(", "'\\n'", ")", ";", "const", "delta", "=", "calcDSVDelta", "(", "code", ",", "'\\t'", ")", ";", "if", "(", "delta", "===", "0", ")", "{", "csv", ".", "COLUMN_SEPARATOR", "=", "'\\t'", ";", "const", "parsed", "=", "_reduceToTSV", "(", "csv", ".", "parse", "(", "code", ")", ")", ";", "eventData", ".", "update", "(", "eventData", ".", "from", ",", "eventData", ".", "to", ",", "parsed", ")", ";", "}", "}" ]

[ "enclose", "pasting", "data", "strings", "from", "markdown", "in", "quotes", "wysiwyg", "event", "should", "be", "treated", "separately", ".", "because", "pasteBefore", "event", "from", "wysiwyg", "has", "been", "already", "processed", "table", "data", "to", "string", "on", "the", "other", "hand", "we", "need", "a", "table", "element" ]

[ "function", "getSelectedRowsLength", "(", "wwe", ")", "{", "const", "selectionMgr", "=", "wwe", ".", "componentManager", ".", "getManager", "(", "'tableSelection'", ")", ";", "const", "$selectedCells", "=", "selectionMgr", ".", "getSelectedCells", "(", ")", ";", "let", "length", "=", "1", ";", "if", "(", "$selectedCells", ".", "length", ">", "1", ")", "{", "const", "first", "=", "$selectedCells", ".", "first", "(", ")", ".", "get", "(", "0", ")", ";", "const", "last", "=", "$selectedCells", ".", "last", "(", ")", ".", "get", "(", "0", ")", ";", "const", "range", "=", "selectionMgr", ".", "getSelectionRangeFromTable", "(", "first", ",", "last", ")", ";", "length", "=", "range", ".", "to", ".", "row", "-", "range", ".", "from", ".", "row", "+", "1", ";", "}", "return", "length", ";", "}" ]

[ "get", "number", "of", "selected", "rows" ]

[ "function", "getNewRow", "(", "$tr", ")", "{", "const", "cloned", "=", "$tr", ".", "clone", "(", ")", ";", "const", "htmlString", "=", "util", ".", "browser", ".", "msie", "?", "''", ":", "'<br />'", ";", "cloned", ".", "find", "(", "'td'", ")", ".", "html", "(", "htmlString", ")", ";", "return", "cloned", ";", "}" ]

[ "Get", "new", "row", "of", "given", "row" ]

[ "function", "leaveOnlyWhitelistAttribute", "(", "$html", ")", "{", "$html", ".", "find", "(", "'*'", ")", ".", "each", "(", "(", "index", ",", "node", ")", "=>", "{", "const", "attrs", "=", "node", ".", "attributes", ";", "const", "blacklist", "=", "util", ".", "toArray", "(", "attrs", ")", ".", "filter", "(", "attr", "=>", "{", "const", "isHTMLAttr", "=", "attr", ".", "name", ".", "match", "(", "HTML_ATTR_LIST_RX", ")", ";", "const", "isSVGAttr", "=", "attr", ".", "name", ".", "match", "(", "SVG_ATTR_LIST_RX", ")", ";", "return", "!", "isHTMLAttr", "&&", "!", "isSVGAttr", ";", "}", ")", ";", "util", ".", "forEachArray", "(", "blacklist", ",", "attr", "=>", "{", "// Edge svg attribute name returns uppercase bug. error guard.", "// https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/5579311/", "if", "(", "attrs", ".", "getNamedItem", "(", "attr", ".", "name", ")", ")", "{", "attrs", ".", "removeNamedItem", "(", "attr", ".", "name", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Leave", "only", "white", "list", "attributes" ]

[ "function", "finalizeHtml", "(", "$html", ",", "needHtmlText", ")", "{", "let", "returnValue", ";", "if", "(", "needHtmlText", ")", "{", "returnValue", "=", "$html", "[", "0", "]", ".", "innerHTML", ";", "}", "else", "{", "const", "frag", "=", "document", ".", "createDocumentFragment", "(", ")", ";", "const", "childNodes", "=", "util", ".", "toArray", "(", "$html", "[", "0", "]", ".", "childNodes", ")", ";", "const", "{", "length", "}", "=", "childNodes", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "length", ";", "i", "+=", "1", ")", "{", "frag", ".", "appendChild", "(", "childNodes", "[", "i", "]", ")", ";", "}", "returnValue", "=", "frag", ";", "}", "return", "returnValue", ";", "}" ]

[ "Finalize", "html", "result" ]

[ "function", "_findUnmergedRange", "(", "tableData", ",", "$start", ",", "$end", ")", "{", "const", "cellIndexData", "=", "tableDataHandler", ".", "createCellIndexData", "(", "tableData", ")", ";", "const", "startCellIndex", "=", "tableDataHandler", ".", "findCellIndex", "(", "cellIndexData", ",", "$start", ")", ";", "const", "endCellIndex", "=", "tableDataHandler", ".", "findCellIndex", "(", "cellIndexData", ",", "$end", ")", ";", "let", "startRowIndex", ",", "endRowIndex", ",", "startColIndex", ",", "endColIndex", ";", "if", "(", "startCellIndex", ".", "rowIndex", ">", "endCellIndex", ".", "rowIndex", ")", "{", "startRowIndex", "=", "endCellIndex", ".", "rowIndex", ";", "endRowIndex", "=", "startCellIndex", ".", "rowIndex", ";", "}", "else", "{", "startRowIndex", "=", "startCellIndex", ".", "rowIndex", ";", "endRowIndex", "=", "endCellIndex", ".", "rowIndex", ";", "}", "if", "(", "startCellIndex", ".", "colIndex", ">", "endCellIndex", ".", "colIndex", ")", "{", "startColIndex", "=", "endCellIndex", ".", "colIndex", ";", "endColIndex", "=", "startCellIndex", ".", "colIndex", ";", "}", "else", "{", "startColIndex", "=", "startCellIndex", ".", "colIndex", ";", "endColIndex", "=", "endCellIndex", ".", "colIndex", ";", "}", "return", "{", "start", ":", "{", "rowIndex", ":", "startRowIndex", ",", "colIndex", ":", "startColIndex", "}", ",", "end", ":", "{", "rowIndex", ":", "endRowIndex", ",", "colIndex", ":", "endColIndex", "}", "}", ";", "}" ]

[ "Find", "unmerged", "table", "range", "." ]

[ "function", "_expandRowMergedRange", "(", "tableData", ",", "tableRange", ",", "rangeType", ")", "{", "const", "{", "rowIndex", "}", "=", "tableRange", "[", "rangeType", "]", ";", "const", "rowData", "=", "tableData", "[", "rowIndex", "]", ";", "util", ".", "range", "(", "tableRange", ".", "start", ".", "colIndex", ",", "tableRange", ".", "end", ".", "colIndex", "+", "1", ")", ".", "forEach", "(", "colIndex", "=>", "{", "const", "cellData", "=", "rowData", "[", "colIndex", "]", ";", "const", "{", "rowMergeWith", "}", "=", "cellData", ";", "let", "lastRowMergedIndex", "=", "-", "1", ";", "if", "(", "util", ".", "isExisty", "(", "rowMergeWith", ")", ")", "{", "if", "(", "rowMergeWith", "<", "tableRange", ".", "start", ".", "rowIndex", ")", "{", "tableRange", ".", "start", ".", "rowIndex", "=", "rowMergeWith", ";", "}", "lastRowMergedIndex", "=", "rowMergeWith", "+", "tableData", "[", "rowMergeWith", "]", "[", "colIndex", "]", ".", "rowspan", "-", "1", ";", "}", "else", "if", "(", "cellData", ".", "rowspan", ">", "1", ")", "{", "lastRowMergedIndex", "=", "rowIndex", "+", "cellData", ".", "rowspan", "-", "1", ";", "}", "if", "(", "lastRowMergedIndex", ">", "tableRange", ".", "end", ".", "rowIndex", ")", "{", "tableRange", ".", "end", ".", "rowIndex", "=", "lastRowMergedIndex", ";", "}", "}", ")", ";", "}" ]

[ "Expand", "table", "range", "by", "row", "merge", "properties", "like", "rowspan", "rowMergeWith", "." ]

[ "function", "_expandColMergedRange", "(", "tableData", ",", "tableRange", ",", "rowIndex", ",", "colIndex", ")", "{", "const", "rowData", "=", "tableData", "[", "rowIndex", "]", ";", "const", "cellData", "=", "rowData", "[", "colIndex", "]", ";", "const", "{", "colMergeWith", "}", "=", "cellData", ";", "let", "lastColMergedIndex", "=", "-", "1", ";", "if", "(", "util", ".", "isExisty", "(", "colMergeWith", ")", ")", "{", "if", "(", "colMergeWith", "<", "tableRange", ".", "start", ".", "colIndex", ")", "{", "tableRange", ".", "start", ".", "colIndex", "=", "colMergeWith", ";", "}", "lastColMergedIndex", "=", "colMergeWith", "+", "rowData", "[", "colMergeWith", "]", ".", "colspan", "-", "1", ";", "}", "else", "if", "(", "cellData", ".", "colspan", ">", "1", ")", "{", "lastColMergedIndex", "=", "colIndex", "+", "cellData", ".", "colspan", "-", "1", ";", "}", "if", "(", "lastColMergedIndex", ">", "tableRange", ".", "end", ".", "colIndex", ")", "{", "tableRange", ".", "end", ".", "colIndex", "=", "lastColMergedIndex", ";", "}", "}" ]

[ "Expand", "table", "range", "by", "column", "merge", "properties", "like", "colspan", "colMergeWith", "." ]

[ "function", "_expandMergedRange", "(", "tableData", ",", "tableRange", ")", "{", "let", "rangeStr", "=", "''", ";", "while", "(", "rangeStr", "!==", "JSON", ".", "stringify", "(", "tableRange", ")", ")", "{", "rangeStr", "=", "JSON", ".", "stringify", "(", "tableRange", ")", ";", "_expandRowMergedRange", "(", "tableData", ",", "tableRange", ",", "'start'", ")", ";", "_expandRowMergedRange", "(", "tableData", ",", "tableRange", ",", "'end'", ")", ";", "util", ".", "range", "(", "tableRange", ".", "start", ".", "rowIndex", ",", "tableRange", ".", "end", ".", "rowIndex", "+", "1", ")", ".", "forEach", "(", "rowIndex", "=>", "{", "_expandColMergedRange", "(", "tableData", ",", "tableRange", ",", "rowIndex", ",", "tableRange", ".", "start", ".", "colIndex", ")", ";", "_expandColMergedRange", "(", "tableData", ",", "tableRange", ",", "rowIndex", ",", "tableRange", ".", "end", ".", "colIndex", ")", ";", "}", ")", ";", "}", "return", "tableRange", ";", "}" ]

[ "Expand", "table", "range", "by", "merge", "properties", "like", "colspan", "rowspan", "." ]

[ "function", "getTableSelectionRange", "(", "tableData", ",", "$selectedCells", ",", "$startContainer", ")", "{", "const", "cellIndexData", "=", "tableDataHandler", ".", "createCellIndexData", "(", "tableData", ")", ";", "const", "tableRange", "=", "{", "}", ";", "if", "(", "$selectedCells", ".", "length", ")", "{", "const", "startRange", "=", "tableDataHandler", ".", "findCellIndex", "(", "cellIndexData", ",", "$selectedCells", ".", "first", "(", ")", ")", ";", "const", "endRange", "=", "util", ".", "extend", "(", "{", "}", ",", "startRange", ")", ";", "$selectedCells", ".", "each", "(", "(", "index", ",", "cell", ")", "=>", "{", "const", "cellIndex", "=", "tableDataHandler", ".", "findCellIndex", "(", "cellIndexData", ",", "$", "(", "cell", ")", ")", ";", "const", "cellData", "=", "tableData", "[", "cellIndex", ".", "rowIndex", "]", "[", "cellIndex", ".", "colIndex", "]", ";", "const", "lastRowMergedIndex", "=", "cellIndex", ".", "rowIndex", "+", "cellData", ".", "rowspan", "-", "1", ";", "const", "lastColMergedIndex", "=", "cellIndex", ".", "colIndex", "+", "cellData", ".", "colspan", "-", "1", ";", "endRange", ".", "rowIndex", "=", "Math", ".", "max", "(", "endRange", ".", "rowIndex", ",", "lastRowMergedIndex", ")", ";", "endRange", ".", "colIndex", "=", "Math", ".", "max", "(", "endRange", ".", "colIndex", ",", "lastColMergedIndex", ")", ";", "}", ")", ";", "tableRange", ".", "start", "=", "startRange", ";", "tableRange", ".", "end", "=", "endRange", ";", "}", "else", "{", "const", "cellIndex", "=", "tableDataHandler", ".", "findCellIndex", "(", "cellIndexData", ",", "$startContainer", ")", ";", "tableRange", ".", "start", "=", "cellIndex", ";", "tableRange", ".", "end", "=", "util", ".", "extend", "(", "{", "}", ",", "cellIndex", ")", ";", "}", "return", "tableRange", ";", "}" ]

[ "Get", "table", "selection", "range", "." ]

[ "function", "setAlignAttributeToTableCells", "(", "$table", ",", "alignDirection", ",", "selectionInformation", ")", "{", "const", "isDivided", "=", "selectionInformation", ".", "isDivided", "||", "false", ";", "const", "start", "=", "selectionInformation", ".", "startColumnIndex", ";", "const", "end", "=", "selectionInformation", ".", "endColumnIndex", ";", "const", "columnLength", "=", "$table", ".", "find", "(", "'tr'", ")", ".", "eq", "(", "0", ")", ".", "find", "(", "'td,th'", ")", ".", "length", ";", "$table", ".", "find", "(", "'tr'", ")", ".", "each", "(", "(", "n", ",", "tr", ")", "=>", "{", "$", "(", "tr", ")", ".", "children", "(", "'td,th'", ")", ".", "each", "(", "(", "index", ",", "cell", ")", "=>", "{", "if", "(", "isDivided", "&&", "(", "(", "start", "<=", "index", "&&", "index", "<=", "columnLength", ")", "||", "(", "index", "<=", "end", ")", ")", ")", "{", "$", "(", "cell", ")", ".", "attr", "(", "'align'", ",", "alignDirection", ")", ";", "}", "else", "if", "(", "(", "start", "<=", "index", "&&", "index", "<=", "end", ")", ")", "{", "$", "(", "cell", ")", ".", "attr", "(", "'align'", ",", "alignDirection", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Set", "Column", "align" ]

[ "function", "getSelectionInformation", "(", "$table", ",", "rangeInformation", ")", "{", "const", "columnLength", "=", "$table", ".", "find", "(", "'tr'", ")", ".", "eq", "(", "0", ")", ".", "find", "(", "'td,th'", ")", ".", "length", ";", "const", "{", "from", ",", "to", "}", "=", "rangeInformation", ";", "let", "startColumnIndex", ",", "endColumnIndex", ",", "isDivided", ";", "if", "(", "from", ".", "row", "===", "to", ".", "row", ")", "{", "startColumnIndex", "=", "from", ".", "cell", ";", "endColumnIndex", "=", "to", ".", "cell", ";", "}", "else", "if", "(", "from", ".", "row", "<", "to", ".", "row", ")", "{", "if", "(", "from", ".", "cell", "<=", "to", ".", "cell", ")", "{", "startColumnIndex", "=", "0", ";", "endColumnIndex", "=", "columnLength", "-", "1", ";", "}", "else", "{", "startColumnIndex", "=", "from", ".", "cell", ";", "endColumnIndex", "=", "to", ".", "cell", ";", "isDivided", "=", "true", ";", "}", "}", "return", "{", "startColumnIndex", ",", "endColumnIndex", ",", "isDivided", "}", ";", "}" ]

[ "Return", "start", "end", "column", "index", "and", "boolean", "value", "for", "whether", "range", "divided", "or", "not" ]

[ "function", "getRangeInformation", "(", "range", ",", "selectionMgr", ")", "{", "const", "$selectedCells", "=", "selectionMgr", ".", "getSelectedCells", "(", ")", ";", "let", "rangeInformation", ",", "startCell", ";", "if", "(", "$selectedCells", ".", "length", ")", "{", "rangeInformation", "=", "selectionMgr", ".", "getSelectionRangeFromTable", "(", "$selectedCells", ".", "first", "(", ")", ".", "get", "(", "0", ")", ",", "$selectedCells", ".", "last", "(", ")", ".", "get", "(", "0", ")", ")", ";", "}", "else", "{", "const", "{", "startContainer", "}", "=", "range", ";", "startCell", "=", "domUtil", ".", "isTextNode", "(", "startContainer", ")", "?", "$", "(", "startContainer", ")", ".", "parent", "(", "'td,th'", ")", "[", "0", "]", ":", "startContainer", ";", "rangeInformation", "=", "selectionMgr", ".", "getSelectionRangeFromTable", "(", "startCell", ",", "startCell", ")", ";", "}", "return", "rangeInformation", ";", "}" ]

[ "Get", "range", "information" ]

[ "function", "taskCounterExtension", "(", "editor", ")", "{", "editor", ".", "getTaskCount", "=", "(", ")", "=>", "{", "let", "found", ",", "count", ";", "if", "(", "editor", ".", "isViewer", "(", ")", ")", "{", "count", "=", "editor", ".", "preview", ".", "$el", ".", "find", "(", "'.task-list-item'", ")", ".", "length", ";", "}", "else", "if", "(", "editor", ".", "isMarkdownMode", "(", ")", ")", "{", "found", "=", "editor", ".", "mdEditor", ".", "getValue", "(", ")", ".", "match", "(", "FIND_TASK_RX", ")", ";", "count", "=", "found", "?", "found", ".", "length", ":", "0", ";", "}", "else", "{", "count", "=", "editor", ".", "wwEditor", ".", "get$Body", "(", ")", ".", "find", "(", "'.task-list-item'", ")", ".", "length", ";", "}", "return", "count", ";", "}", ";", "editor", ".", "getCheckedTaskCount", "=", "(", ")", "=>", "{", "let", "found", ",", "count", ";", "if", "(", "editor", ".", "isViewer", "(", ")", ")", "{", "count", "=", "editor", ".", "preview", ".", "$el", ".", "find", "(", "'.task-list-item.checked'", ")", ".", "length", ";", "}", "else", "if", "(", "editor", ".", "isMarkdownMode", "(", ")", ")", "{", "found", "=", "editor", ".", "mdEditor", ".", "getValue", "(", ")", ".", "match", "(", "FIND_CHECKED_TASK_RX", ")", ";", "count", "=", "found", "?", "found", ".", "length", ":", "0", ";", "}", "else", "{", "count", "=", "editor", ".", "wwEditor", ".", "get$Body", "(", ")", ".", "find", "(", "'.task-list-item.checked'", ")", ".", "length", ";", "}", "return", "count", ";", "}", ";", "}" ]

[ "task", "counter", "extension" ]

[ "function", "changeButtonVisiblityStateIfNeed", "(", ")", "{", "if", "(", "editor", ".", "mdPreviewStyle", "===", "'vertical'", "&&", "editor", ".", "currentMode", "===", "'markdown'", ")", "{", "button", ".", "$el", ".", "show", "(", ")", ";", "$divider", ".", "show", "(", ")", ";", "}", "else", "{", "button", ".", "$el", ".", "hide", "(", ")", ";", "$divider", ".", "hide", "(", ")", ";", "}", "}" ]

[ "change", "button", "visiblity", "state" ]

[ "function", "getHelper", "(", ")", "{", "let", "helper", ";", "if", "(", "editor", ".", "isViewer", "(", ")", ")", "{", "helper", "=", "vmh", ";", "}", "else", "if", "(", "editor", ".", "isWysiwygMode", "(", ")", ")", "{", "helper", "=", "wmh", ";", "}", "else", "{", "helper", "=", "mmh", ";", "}", "return", "helper", ";", "}" ]

[ "getHelper", "Get", "helper", "for", "current", "situation" ]

[ "function", "updateMarkWhenResizing", "(", ")", "{", "const", "helper", "=", "getHelper", "(", ")", ";", "ml", ".", "getAll", "(", ")", ".", "forEach", "(", "marker", "=>", "{", "helper", ".", "updateMarkerWithExtraInfo", "(", "marker", ")", ";", "}", ")", ";", "editor", ".", "eventManager", ".", "emit", "(", "'markerUpdated'", ",", "ml", ".", "getAll", "(", ")", ")", ";", "}" ]

[ "Update", "mark", "when", "resizing" ]

[ "async", "function", "getTagHead", "(", "tagName", ",", "execaOpts", ")", "{", "try", "{", "return", "await", "execa", ".", "stdout", "(", "'git'", ",", "[", "'rev-list'", ",", "'-1'", ",", "tagName", "]", ",", "execaOpts", ")", ";", "}", "catch", "(", "error", ")", "{", "debug", "(", "error", ")", ";", "}", "}" ]

[ "Get", "the", "commit", "sha", "for", "a", "given", "tag", "." ]

[ "async", "function", "getTags", "(", "execaOpts", ")", "{", "return", "(", "await", "execa", ".", "stdout", "(", "'git'", ",", "[", "'tag'", "]", ",", "execaOpts", ")", ")", ".", "split", "(", "'\\n'", ")", ".", "map", "(", "tag", "=>", "tag", ".", "trim", "(", ")", ")", ".", "filter", "(", "Boolean", ")", ";", "}" ]

[ "Get", "all", "the", "repository", "tags", "." ]

[ "async", "function", "isRefInHistory", "(", "ref", ",", "execaOpts", ")", "{", "try", "{", "await", "execa", "(", "'git'", ",", "[", "'merge-base'", ",", "'--is-ancestor'", ",", "ref", ",", "'HEAD'", "]", ",", "execaOpts", ")", ";", "return", "true", ";", "}", "catch", "(", "error", ")", "{", "if", "(", "error", ".", "code", "===", "1", ")", "{", "return", "false", ";", "}", "debug", "(", "error", ")", ";", "throw", "error", ";", "}", "}" ]

[ "Verify", "if", "the", "ref", "is", "in", "the", "direct", "history", "of", "the", "current", "branch", "." ]

[ "async", "function", "fetch", "(", "repositoryUrl", ",", "execaOpts", ")", "{", "try", "{", "await", "execa", "(", "'git'", ",", "[", "'fetch'", ",", "'--unshallow'", ",", "'--tags'", ",", "repositoryUrl", "]", ",", "execaOpts", ")", ";", "}", "catch", "(", "error", ")", "{", "await", "execa", "(", "'git'", ",", "[", "'fetch'", ",", "'--tags'", ",", "repositoryUrl", "]", ",", "execaOpts", ")", ";", "}", "}" ]

[ "Unshallow", "the", "git", "repository", "if", "necessary", "and", "fetch", "all", "the", "tags", "." ]