ponkotsu-md-editor 0.1.41 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b3bd7d2ceb35ca37646c9f4991d81f239ac69a72cb5c0df9de2d0d33329405c
-  data.tar.gz: 9546f35e09c7e7229fae0087d7e7d817aff6cdae76a76e6ac272fba2fbcb0c2d
+  metadata.gz: 8fe8a5ee54ef7b3d227b1544f1fe0ea4357f2e087035ef2d1325ed26f544e02a
+  data.tar.gz: fe092133a77d8f39136ed3d9bf62e9f180efa1eeb3602c1a37af57f0fb3d95b5
 SHA512:
-  metadata.gz: 9244b36049b0d62ad1e1f8a2da6dbe74bd535176211a734ddf50039ec6525e0375b028474b283650fd74835eb8fff6280ce17d3ed9a2b2148a528078bfbf8df1
-  data.tar.gz: 999ab7744606744c0a9f1cb55d1a04b538e608611f026341f8b3fb487aebf792d79b6fb924e1a286f7f454477f39d554f5cfcbefe3a354ae721f651ec48b6de2
+  metadata.gz: 4276afc6fb1626c265e0f5fc9242eaab7a6fb7fe5a86dca690329d2a825d209c4cd8753886f57011c6f7b396149dc28739016e7b498d11c003ea962339277225
+  data.tar.gz: 64974bbfd25c6c394ba2838608aab7fb192c574528a848c0d9406ed97efa836acadbef688e909cbbf72156d16386611e10e84739821f39f330d60e8e3ea58974

data/app/assets/javascripts/markdown_editor.js

@@ -30,6 +30,30 @@
 
         let isPreviewMode = false;
 
+        const sampleHtml = "aaa bbb ccc ddd eee\n" +
+            "    \n" +
+            "  <div>aaa bbb ccc ddd eee</div><div><br></div><div>###  aaa bbb ccc ddd eee</div><div></div><div>####</div><div><br></div><div>aaa bbb ccc ddd eee</div>";
+
+        const actual = analyzeHtml(sampleHtml);
+
+        function assertEqual(actual, expected, message) {
+            if (actual !== expected) {
+                console.error('Assertion failed:' + message + '\n' +
+                    'Expected:' + expected + '\n' +
+                    'Actual:', actual);
+            } else {
+                console.log('Assertion passed:', message);
+            }
+        }
+
+        assertEqual(actual[0], 'aaa bbb ccc ddd eee\n    \n  ', "Line 1");
+        assertEqual(actual[1], `aaa bbb ccc ddd eee`, "Line 2");
+        assertEqual(actual[2], "⹉", "Line 3 (empty line)");
+        assertEqual(actual[3], "###  aaa bbb ccc ddd eee", "Line 4");
+        assertEqual(actual[4], "####", "Line 5 (header only)");
+        assertEqual(actual[5], "⹉", "Line 6 (empty line)");
+        assertEqual(actual[6], "aaa bbb ccc ddd eee", "Line 7");
+
         // Selection range utilities for contenteditable elements (precision enhanced version)
         function getContentEditableSelection(element) {
             const selection = window.getSelection();
@@ -119,6 +143,15 @@
                 selectedText = rangeText;
             }
 
+            // === 厳密化: selectedTextがfullText.slice(startPos, endPos)と一致しない場合、fullText内でselectedTextの位置を検索 ===
+            if (selectedText && fullText.slice(startPos, endPos) !== selectedText) {
+                const idx = fullText.indexOf(selectedText);
+                if (idx !== -1) {
+                    startPos = idx;
+                    endPos = idx + selectedText.length;
+                }
+            }
+
             // === デバッグ出力 ===
             console.log('[DEBUG] getContentEditableSelection');
             console.log('fullText:', JSON.stringify(fullText));
@@ -263,6 +296,379 @@
             element.innerText = text;
         }
 
+        function getLineAndCharIndex(container, offset) {
+            const walker = document.createTreeWalker(
+                container,
+                NodeFilter.SHOW_TEXT,
+                null,
+                false
+            );
+
+            let currentOffset = 0;
+            let lineNumber = 0;
+            let charInLine = 0;
+            let node;
+
+            while (node = walker.nextNode()) {
+                const nodeText = node.textContent;
+                const nodeLength = nodeText.length;
+
+                if (currentOffset + nodeLength >= offset) {
+                    const offsetInNode = offset - currentOffset;
+                    const textBeforeOffset = nodeText.substring(0, offsetInNode);
+
+                    const allTextBefore = container.textContent.substring(0, currentOffset + offsetInNode);
+                    const linesBeforeOffset = allTextBefore.split('\n');
+
+                    lineNumber = linesBeforeOffset.length - 1;
+                    charInLine = linesBeforeOffset[linesBeforeOffset.length - 1].length;
+
+                    break;
+                }
+
+                currentOffset += nodeLength;
+            }
+
+            return { line: lineNumber, char: charInLine };
+        }
+
+        function getOffsetInContainer(container, node, offset) {
+            // DOM構造をリニアに変換して位置を計算
+            function buildLinearTextMap(container) {
+                let textMap = [];
+                let currentPos = 0;
+
+                function processNode(node) {
+                    if (node.nodeType === Node.TEXT_NODE) {
+                        const text = node.textContent;
+                        textMap.push({
+                            node: node,
+                            type: 'text',
+                            start: currentPos,
+                            end: currentPos + text.length,
+                            text: text
+                        });
+                        currentPos += text.length;
+                    } else if (node.nodeType === Node.ELEMENT_NODE) {
+                        if (node.tagName === 'DIV') {
+                            if (node.children.length === 1 && node.children[0].tagName === 'BR') {
+                                textMap.push({
+                                    node: node,
+                                    type: 'div-br',
+                                    start: currentPos,
+                                    end: currentPos + 1,
+                                    text: '\n'
+                                });
+                                currentPos += 1;
+                                return;
+                            } else if (node.innerHTML === '<br>' || node.innerHTML === '<br/>' || node.innerHTML === '') {
+                                textMap.push({
+                                    node: node,
+                                    type: 'empty-div',
+                                    start: currentPos,
+                                    end: currentPos + 1,
+                                    text: '\n'
+                                });
+                                currentPos += 1;
+                                return;
+                            }
+                        } else if (node.tagName === 'BR') {
+                            textMap.push({
+                                node: node,
+                                type: 'br',
+                                start: currentPos,
+                                end: currentPos + 1,
+                                text: '\n'
+                            });
+                            currentPos += 1;
+                            return;
+                        }
+
+                        // 子ノードを処理
+                        for (let child of node.childNodes) {
+                            processNode(child);
+                        }
+                    }
+                }
+
+                // コンテナの直接の子ノードから開始
+                for (let child of container.childNodes) {
+                    processNode(child);
+                }
+
+                return textMap;
+            }
+
+            const textMap = buildLinearTextMap(container);
+
+            // 対象ノードを見つけて位置を計算
+            for (let item of textMap) {
+                if (item.node === node) {
+                    if (node.nodeType === Node.TEXT_NODE) {
+                        return item.start + offset;
+                    } else {
+                        // 要素ノードの場合は内部オフセットを計算
+                        let internalOffset = 0;
+                        for (let i = 0; i < offset && i < node.childNodes.length; i++) {
+                            const child = node.childNodes[i];
+                            if (child.nodeType === Node.TEXT_NODE) {
+                                internalOffset += child.textContent.length;
+                            } else if (child.nodeType === Node.ELEMENT_NODE && child.tagName === 'BR') {
+                                internalOffset += 1;
+                            }
+                        }
+                        return item.start + internalOffset;
+                    }
+                }
+            }
+
+            return 0;
+        }
+
+        function selectLineNumberAndCharIndex(beginEndLenStrings, beginCharIndex, endCharIndex) {
+            let retBeginLine = 0, retBeginCharIndex = 0;
+            let retEndLine = 0, retEndCharIndex = 0;
+            let emptyLineCount = 0;
+
+            for (let i = 0; i < beginEndLenStrings.length; i++) {
+                const line = beginEndLenStrings[i];
+
+                if (line.str === "⹉") {
+                    emptyLineCount++;
+                }
+
+                if (beginCharIndex >= line.begin && beginCharIndex <= line.end) {
+                    retBeginLine = i;
+                    retBeginCharIndex = beginCharIndex - line.begin + emptyLineCount;
+                    break;
+                }
+            }
+
+            emptyLineCount = 0;
+
+            for (let i = 0; i < beginEndLenStrings.length; i++) {
+                const line = beginEndLenStrings[i];
+
+                if (line.str === "⹉") {
+                    emptyLineCount++;
+                }
+
+                if (endCharIndex >= line.begin && endCharIndex <= line.end) {
+                    retEndLine = i;
+                    retEndCharIndex = endCharIndex - line.begin + emptyLineCount;
+                    break;
+                }
+            }
+
+            return { begin: { line: retBeginLine, char: retBeginCharIndex }, end: { line: retEndLine, char: retEndCharIndex } };
+        }
+
+        function replaceLineNumberAndCharIndex(beginEndLenStrings, targetTextPosition, before, after) {
+            let newLines = [];
+            for (let i = 0; i < beginEndLenStrings.length; i++) {
+                const line = beginEndLenStrings[i];
+
+                // 改行行は変更せずそのまま保持
+                if (line.str === "⹉") {
+                    newLines.push(line.str);
+                    continue;
+                }
+
+                if (i === targetTextPosition.begin.line && i === targetTextPosition.end.line) {
+                    const first = line.str.substring(0, targetTextPosition.begin.char);
+                    const target = line.str.substring(targetTextPosition.begin.char, targetTextPosition.end.char);
+                    const last = line.str.substring(targetTextPosition.end.char);
+                    newLines.push(first + before + target + after + last);
+                }
+                else if (i === targetTextPosition.begin.line) {
+                    const first = line.str.substring(0, targetTextPosition.begin.char);
+                    const target = line.str.substring(targetTextPosition.begin.char);
+                    newLines.push(first + before + target + after);
+                }
+                else if (i === targetTextPosition.end.line) {
+                    const target = line.str.substring(0, targetTextPosition.end.char);
+                    const last = line.str.substring(targetTextPosition.end.char);
+                    newLines.push(before + target + after + last);
+                }
+                else {
+                    newLines.push(line.str);
+                }
+            }
+            return newLines;
+        }
+
+        function replaceLine(beginEndLenStrings, selectedLine, before, after) {
+
+            let newLines = [];
+            for (let i = 0; i < beginEndLenStrings.length; i++) {
+                const line = beginEndLenStrings[i];
+                if (i === selectedLine) {
+                    let addingSpace = "";
+                    if (!line.str.startsWith(" ")) {
+                        addingSpace += " ";
+                    }
+                    newLines.push(before + addingSpace + line.str + after);
+                } else {
+                    newLines.push(line.str);
+                }
+            }
+
+            return newLines;
+        }
+
+        function convertToInnerHtml(newLines) {
+            let html = "";
+            for (let i = 0; i < newLines.length; i++) {
+                if (i === 0) {
+                    html += newLines[i].split("⹉").join("");
+                } else {
+                    let insert = newLines[i];
+                    if (insert === "⹉") {
+                        insert = insert.split("⹉").join("<br>");
+                    } else {
+                        insert = insert.split("⹉").join("");
+                    }
+                    html += "<div>" + insert + "</div>";
+                }
+            }
+            return html;
+        }
+
+        function getCurrentLineIndex(beginEndLenStrings) {
+            const selection = window.getSelection();
+            if (!selection.rangeCount) {
+                return null;
+            }
+
+            const range = selection.getRangeAt(0);
+
+            if (!range.collapsed) {
+                return null;
+            }
+
+            const beforeCursorText = getTextBeforeCursor(range.startContainer, range.startOffset, beginEndLenStrings);
+            const beforeCursorTextLength = beforeCursorText.length;
+            let selectedLine = -1;
+            for (let i = 0; i < beginEndLenStrings.length; i++) {
+                const line = beginEndLenStrings[i];
+                if (line.begin <= beforeCursorTextLength && beforeCursorTextLength <= line.end) {
+                    selectedLine = i;
+                    break;
+                }
+            }
+            return {
+                line: selectedLine
+            };
+        }
+
+        function getTextBeforeCursor(container, offset, beginEndLenStrings) {
+            const selection = window.getSelection();
+            if (!selection.rangeCount) return '';
+
+            const range = selection.getRangeAt(0);
+            const textarea = document.getElementById('editor_content');
+
+            try {
+                // 全テキストとカーソル位置を取得
+                const fullText = textarea.innerText || '';
+                const text = getCursorPositionInInnerText(textarea, range.startContainer, range.startOffset);
+                return text;
+            } catch (error) {
+                console.error('Error in getTextBeforeCursor:', error);
+                return '';
+            }
+        }
+
+        function getCursorPositionInInnerText(container, cursorNode, cursorOffset) {
+            try {
+                const beforeRange = document.createRange();
+                beforeRange.setStart(container, 0);
+                beforeRange.setEnd(cursorNode, cursorOffset);
+
+                // cloneContentsを使用してDOM構造を保持
+                const fragment = beforeRange.cloneContents();
+                const tempDiv = document.createElement('div');
+                tempDiv.appendChild(fragment);
+
+                // innerTextで正確な文字数を取得（空行も含む）
+                const r = analyzeHtml(tempDiv.innerHTML.replace('\n    \n  ', ''), true).join('');
+                return r;
+
+            } catch (error) {
+                console.error('Position calculation failed:', error);
+                return 0;
+            }
+        }
+
+        function analyzeHtml(target, isCountEmptyDiv = false) {
+            let lines = [];
+            let remain = target;
+
+            while (remain.length > 0) {
+                // <div><br></div> パターン（改行）- 常に維持
+                if (remain.startsWith("<div><br></div>")) {
+                    lines.push("⹉");
+                    remain = remain.substring(15);
+                    continue;
+                }
+
+                // <div></div> パターン（空のdiv）- isCountEmptyDivで制御
+                if (remain.startsWith("<div></div>")) {
+                    if (isCountEmptyDiv) {
+                        lines.push("⹉");
+                    }
+                    remain = remain.substring(11);
+                    continue;
+                }
+
+                // <div>内容</div> パターン
+                const divMatch = remain.match(/^<div>([^<]*)<\/div>/);
+                if (divMatch) {
+                    lines.push(divMatch[1]);
+                    remain = remain.substring(divMatch[0].length);
+                    continue;
+                }
+
+                // <br> パターン（単体の改行）
+                if (remain.startsWith("<br>")) {
+                    lines.push("⹉");
+                    remain = remain.substring(4);
+                    continue;
+                }
+
+                // <div> の開始を探す
+                const divIndex = remain.indexOf("<div>");
+                if (divIndex > 0) {
+                    lines.push(remain.substring(0, divIndex));
+                    remain = remain.substring(divIndex);
+                    continue;
+                }
+
+                // その他のタグまたは残りのテキスト
+                const nextTagIndex = remain.indexOf("<");
+                if (nextTagIndex === -1) {
+                    if (remain.trim()) {
+                        lines.push(remain);
+                    }
+                    break;
+                }
+
+                if (nextTagIndex > 0) {
+                    lines.push(remain.substring(0, nextTagIndex));
+                    remain = remain.substring(nextTagIndex);
+                } else {
+                    const tagEnd = remain.indexOf(">");
+                    if (tagEnd !== -1) {
+                        remain = remain.substring(tagEnd + 1);
+                    } else {
+                        break;
+                    }
+                }
+            }
+
+            return lines;
+        }
+
         // Markdown text insertion functionality
         window.insertMarkdown = function(before, after) {
             after = after || '';
@@ -275,62 +681,148 @@
             try {
                 // Check if element is contenteditable
                 const isContentEditable = textarea.contentEditable === 'true' ||
-                                        textarea.getAttribute('contenteditable') === 'true';
+                    textarea.getAttribute('contenteditable') === 'true';
 
-                let start, end, selectedText;
+                let lines = analyzeHtml(textarea.innerHTML.replace('\n    \n  ', ''));
 
-                if (isContentEditable) {
-                    // For contenteditable elements
-                    const selection = getContentEditableSelection(textarea);
-                    start = selection.start;
-                    end = selection.end;
-                    selectedText = selection.selectedText;
-                } else {
-                    // For regular textarea elements
-                    start = textarea.selectionStart || 0;
-                    end = textarea.selectionEnd || 0;
-                    selectedText = textarea.value.substring(start, end);
+                // === 修正部分：DOM構造に基づいたテキスト表現を構築 ===
+                let domBasedText = '';
+                for (let i = 0; i < lines.length; i++) {
+                    if (lines[i] === "⹉") {
+                        domBasedText += '\n'; // 改行として1文字
+                    } else {
+                        domBasedText += lines[i];
+                    }
                 }
 
-                // fullTextの定義をここで行う
-                const fullText = isContentEditable ?
-                    (textarea.innerText || textarea.textContent || '') :
-                    textarea.value;
+                // beginEndLenStringsをDOM構造ベースで構築
+                let offset = 0;
+                let beginEndLenStrings = [];
+                for (let i = 0; i < lines.length; i++) {
+                    let line = lines[i];
+                    let actualLength;
 
-                // Bold（**）の場合のみ、選択範囲の両端に余分な空白・改行・文末記号があれば除外
-                if (before === '**' && after === '**' && selectedText.length > 0) {
-                    // 両端の「改行・空白・文末記号」をすべて除去（複数連続も対応）
-                    while (/^[\s\n.,;:!?]+/.test(selectedText)) {
-                        selectedText = selectedText.replace(/^[\s\n.,;:!?]+/, '');
-                    }
-                    while (/[\s\n.,;:!?]+$/.test(selectedText)) {
-                        selectedText = selectedText.replace(/[\s\n.,;:!?]+$/, '');
+                    if (line === "⹉") {
+                        actualLength = 1; // 改行として1文字
+                    } else {
+                        actualLength = line.length;
                     }
+
+                    beginEndLenStrings.push({
+                        begin: offset,
+                        end: offset + actualLength,
+                        len: actualLength,
+                        str: line,
+                    });
+                    offset += actualLength;
+                }
+                // ===================================================
+
+                // len:0のものを削除（元の処理を保持）
+                beginEndLenStrings = beginEndLenStrings.filter(line => line.len > 0 || line.str === "⹉");
+                if (beginEndLenStrings.length === 0) {
+                    beginEndLenStrings.push({
+                        begin: 0,
+                        end: 1,
+                        len: 1,
+                        str: "⹉",
+                        emptyLineCount: 1
+                    });
                 }
 
-                const beforeText = fullText.substring(0, start);
-                const afterText = fullText.substring(end);
-                const newText = before + selectedText + after;
+                // 選択範囲の取得
+                const selection = window.getSelection();
 
-                const newFullText = beforeText + newText + afterText;
+                let selectLineMode = false;
+                let selectedLinePos;
 
-                if (isContentEditable) {
-                    textarea.innerText = newFullText;
-                } else {
-                    textarea.value = newFullText;
+                if (!selection.rangeCount || selection.isCollapsed) {
+                    // 行選択モード
+                    selectLineMode = true;
+                    selectedLinePos = getCurrentLineIndex(beginEndLenStrings);
                 }
 
-                // Adjust cursor position
-                const newCursorPos = selectedText.length > 0 ?
-                    start + newText.length :
-                    start + before.length;
+                const range = selection.getRangeAt(0);
 
-                textarea.focus();
+                if (!textarea.contains(range.commonAncestorContainer) &&
+                    range.commonAncestorContainer !== textarea) {
+                    return;
+                }
+
+                const startOffset = getOffsetInContainer(textarea, range.startContainer, range.startOffset);
+                const endOffset = getOffsetInContainer(textarea, range.endContainer, range.endOffset);
+
+                // === デバッグ出力（削除可能）===
+                console.log('DOM-based text:', JSON.stringify(domBasedText));
+                console.log('beginEndLenStrings:', beginEndLenStrings);
+                console.log('Selection offsets:', startOffset, endOffset);
+                console.log('Selected text should be:', JSON.stringify(domBasedText.substring(startOffset, endOffset)));
+                // =============================
+
+                const startPos = getLineAndCharIndex(textarea, startOffset);
+                const endPos = getLineAndCharIndex(textarea, endOffset);
+
+                const selectedTextContent = selection.toString();
+
+                const targetTextPosition = selectLineNumberAndCharIndex(beginEndLenStrings, startOffset, endOffset);
+
+                const newLines = !selectLineMode
+                    ? replaceLineNumberAndCharIndex(beginEndLenStrings, targetTextPosition, before, after)
+                    : replaceLine(beginEndLenStrings, selectedLinePos.line, before, after);
+
+                const newFullHTML = convertToInnerHtml(newLines);
 
                 if (isContentEditable) {
-                    setContentEditableSelection(textarea, newCursorPos, newCursorPos);
-                } else if (textarea.setSelectionRange) {
-                    textarea.setSelectionRange(newCursorPos, newCursorPos);
+                    textarea.innerHTML = newFullHTML;
+                    textarea.focus();
+
+                    // 挿入されたテキストノードを直接探してカーソルを設定
+                    const insertedText = selectedTextContent.length > 0 ?
+                        (before + selectedTextContent + after) :
+                        (before + after);
+
+                    // 新しく挿入されたテキストの終端を探す
+                    const walker = document.createTreeWalker(
+                        textarea,
+                        NodeFilter.SHOW_TEXT,
+                        null,
+                        false
+                    );
+
+                    let foundNode = null;
+                    let foundOffset = 0;
+                    let node;
+
+                    while (node = walker.nextNode()) {
+                        if (node.textContent.includes(insertedText)) {
+                            // 挿入されたテキストを含むノードを発見
+                            const textIndex = node.textContent.indexOf(insertedText);
+                            if (textIndex !== -1) {
+                                foundNode = node;
+                                foundOffset = textIndex + insertedText.length;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (foundNode) {
+                        // 見つかったテキストノード内にカーソルを設定
+                        const range = document.createRange();
+                        range.setStart(foundNode, Math.min(foundOffset, foundNode.textContent.length));
+                        range.collapse(true);
+
+                        const selection = window.getSelection();
+                        selection.removeAllRanges();
+                        selection.addRange(range);
+                    } else {
+                        // フォールバック: 従来の方法
+                        const newDomText = buildDomBasedText(textarea);
+                        const targetPosition = Math.min(
+                            startOffset + insertedText.length,
+                            newDomText.length
+                        );
+                        setContentEditableSelection(textarea, targetPosition, targetPosition);
+                    }
                 }
 
                 // Fire input event
@@ -341,12 +833,25 @@
             }
         };
 
+        function buildDomBasedText(element) {
+            const lines = analyzeHtml(element.innerHTML);
+            let domText = '';
+            for (let line of lines) {
+                if (line === "⹉") {
+                    domText += '\n';
+                } else {
+                    domText += line;
+                }
+            }
+            return domText;
+        }
+
         window.insertCode = function() {
             const textarea = document.getElementById('editor_content');
 
             // Check if element is contenteditable
             const isContentEditable = textarea.contentEditable === 'true' ||
-                                    textarea.getAttribute('contenteditable') === 'true';
+                textarea.getAttribute('contenteditable') === 'true';
 
             let selectedText;
             if (isContentEditable) {
@@ -379,7 +884,7 @@
                     // Switch to preview mode
                     // Check if element is contenteditable and get text
                     const isContentEditable = textarea.contentEditable === 'true' ||
-                                            textarea.getAttribute('contenteditable') === 'true';
+                        textarea.getAttribute('contenteditable') === 'true';
 
                     const markdownText = isContentEditable ?
                         (textarea.innerText || textarea.textContent || '') :
@@ -722,6 +1227,11 @@
             });
         }
 
+        function applyTable() {
+            const tableMarkdown = '| 列1 | 列2 | 列3 |<br>|-----|-----|-----|<br>| セル1 | セル2 | セル3 |<br>| セル4 | セル5 | セル6 |<br><br>';
+            insertMarkdown(tableMarkdown, '');
+        }
+
         // Enhanced code function with block detection
         function applyCodeSmart() {
             const activeElement = document.activeElement;
@@ -758,6 +1268,7 @@
         window.applyList = applyList;
         window.applyOrderedList = applyOrderedList;
         window.applyBlockquote = applyBlockquote;
+        window.applyTable = applyTable;
 
         // Allowed script tag sources (whitelist)
         const ALLOWED_SCRIPT_SOURCES = [
@@ -1320,7 +1831,7 @@
 
             // Check if element is contenteditable
             const isContentEditable = textarea.contentEditable === 'true' ||
-                                    textarea.getAttribute('contenteditable') === 'true';
+                textarea.getAttribute('contenteditable') === 'true';
 
             if (isContentEditable) {
                 // For contenteditable elements

data/lib/ponkotsu/md/editor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PonkotsuMdEditor
-  VERSION = "0.1.41"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ponkotsu-md-editor
 version: !ruby/object:Gem::Version
-  version: 0.1.41
+  version: 0.2.0
 platform: ruby
 authors:
 - dhq_boiler