virtual-excel-table 2.2.0

package/src/main/webapp/resources/js/virtual-excel-table.js

@@ -0,0 +1,3391 @@
+/*
+ * VirtualExcelTable 2.2.0
+ * Dependency-free spreadsheet-like paste/delete/undo behavior for HTML tables.
+ * ES5 syntax is used so the file can be included in legacy JSP applications.
+ */
+(function (root, factory) {
+    var api = factory(root, root && root.document);
+
+    if (typeof module === 'object' && module.exports) {
+        module.exports = api;
+    }
+
+    if (root) {
+        root.VirtualExcelTable = api;
+    }
+}(typeof window !== 'undefined' ? window :
+        (typeof global !== 'undefined' ? global : this), function (root, document) {
+    'use strict';
+
+    var VERSION = '2.2.0';
+    var INSTANCE_KEY = '__virtualExcelTableInstance__';
+    var STYLE_ID = 'virtual-excel-table-style';
+    var TABLE_CLASS = 'vet-table';
+    var DRAGGING_CLASS = 'vet-dragging';
+    var CELL_CLASS = 'vet-cell';
+    var SELECTED_CLASS = 'vet-selected';
+    var ACTIVE_CLASS = 'vet-active';
+    var READONLY_CLASS = 'vet-readonly';
+    var HEADER_CLASS = 'vet-selection-header';
+    var HEADER_SELECTED_CLASS = 'vet-header-selected';
+
+    var DEFAULTS = {
+        cellSelector: 'tbody td',
+        rowSelector: 'tbody tr',
+        rowHeaderSelector: 'tbody th',
+        columnHeaderSelector: 'thead th',
+        minRows: 1,
+        historyLimit: 50,
+        overflow: 'clip',
+        autoAddRowsOnPaste: true,
+        pasteMode: 'grid',
+        interactionMode: 'spreadsheet',
+        pasteSingleToSelection: true,
+        pasteRepeatToSelection: true,
+        dispatchEvents: true,
+        injectStyles: true,
+        readOnly: null,
+        rowReadOnly: null,
+        getValue: null,
+        setValue: null,
+        beforeChange: null,
+        afterChange: null,
+        beforeRowsDelete: null,
+        beforeRowAdd: null,
+        rowFactory: null,
+        reindexRows: null,
+        afterRowsChange: null,
+        onSelectionChange: null,
+        onError: null
+    };
+
+    function own(object, key) {
+        return Object.prototype.hasOwnProperty.call(object, key);
+    }
+
+    function mergeOptions(options) {
+        var result = {};
+        var key;
+
+        for (key in DEFAULTS) {
+            if (own(DEFAULTS, key)) {
+                result[key] = DEFAULTS[key];
+            }
+        }
+
+        options = options || {};
+        for (key in options) {
+            if (own(options, key)) {
+                result[key] = options[key];
+            }
+        }
+
+        return result;
+    }
+
+    function addClass(element, name) {
+        if (!element || hasClass(element, name)) {
+            return;
+        }
+        element.className = element.className ? element.className + ' ' + name : name;
+    }
+
+    function removeClass(element, name) {
+        var value;
+
+        if (!element || !element.className) {
+            return;
+        }
+
+        value = (' ' + element.className + ' ').replace(/\s+/g, ' ');
+        while (value.indexOf(' ' + name + ' ') !== -1) {
+            value = value.replace(' ' + name + ' ', ' ');
+        }
+        element.className = value.replace(/^\s+|\s+$/g, '');
+    }
+
+    function hasClass(element, name) {
+        if (!element || !element.className) {
+            return false;
+        }
+        return (' ' + element.className + ' ').replace(/\s+/g, ' ')
+            .indexOf(' ' + name + ' ') !== -1;
+    }
+
+    function indexOf(array, value) {
+        var i;
+        for (i = 0; i < array.length; i += 1) {
+            if (array[i] === value) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    function matchesSelector(element, selector) {
+        var matcher = element.matches || element.matchesSelector ||
+            element.msMatchesSelector || element.webkitMatchesSelector ||
+            element.mozMatchesSelector;
+
+        if (!matcher) {
+            throw new Error('VirtualExcelTable: 이 브라우저는 CSS selector 검사를 지원하지 않습니다.');
+        }
+
+        return matcher.call(element, selector);
+    }
+
+    function owningTable(element) {
+        var current = element;
+
+        while (current && current.nodeType === 1) {
+            if (String(current.tagName).toUpperCase() === 'TABLE') {
+                return current;
+            }
+            current = current.parentNode;
+        }
+
+        return null;
+    }
+
+    function contains(parent, child) {
+        if (!parent || !child) {
+            return false;
+        }
+        if (parent === child) {
+            return true;
+        }
+        if (parent.contains) {
+            return parent.contains(child);
+        }
+
+        while (child) {
+            if (child === parent) {
+                return true;
+            }
+            child = child.parentNode;
+        }
+        return false;
+    }
+
+    function setText(element, value) {
+        if (typeof element.textContent !== 'undefined') {
+            element.textContent = value;
+        } else {
+            element.innerText = value;
+        }
+    }
+
+    function getText(element) {
+        if (typeof element.textContent !== 'undefined') {
+            return element.textContent;
+        }
+        return element.innerText;
+    }
+
+    function isContentEditable(element) {
+        var attribute;
+
+        if (!element || element.nodeType !== 1) {
+            return false;
+        }
+
+        attribute = element.getAttribute('contenteditable');
+        return attribute === '' || String(attribute).toLowerCase() === 'true';
+    }
+
+    function isValueControl(element) {
+        var tag;
+        var type;
+
+        if (!element || element.nodeType !== 1) {
+            return false;
+        }
+
+        tag = String(element.tagName).toUpperCase();
+        if (tag === 'TEXTAREA' || tag === 'SELECT') {
+            return true;
+        }
+        if (tag !== 'INPUT') {
+            return false;
+        }
+
+        type = String(element.type || 'text').toLowerCase();
+        return type !== 'hidden' && type !== 'button' && type !== 'submit' &&
+            type !== 'reset' && type !== 'checkbox' && type !== 'radio' &&
+            type !== 'file' && type !== 'image';
+    }
+
+    function isInteractiveElement(element) {
+        var tag;
+
+        if (!element || element.nodeType !== 1) {
+            return false;
+        }
+        tag = String(element.tagName).toUpperCase();
+        return tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' ||
+            tag === 'BUTTON' || tag === 'OPTION' || tag === 'LABEL' ||
+            (tag === 'A' && element.getAttribute('href') !== null) ||
+            isContentEditable(element);
+    }
+
+    function hasUnsafeCellMarkup(cell) {
+        var children = cell.children || cell.childNodes;
+        var i;
+        var tag;
+
+        for (i = 0; i < children.length; i += 1) {
+            if (children[i].nodeType !== 1) {
+                continue;
+            }
+            tag = String(children[i].tagName).toUpperCase();
+            /* A BR-only cell is safe to replace with plain text. */
+            if (tag !== 'BR') {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function prepareClonedRow(row) {
+        var elements = row.getElementsByTagName('*');
+        var element;
+        var tag;
+        var type;
+        var i;
+
+        row.removeAttribute('id');
+        removeClass(row, SELECTED_CLASS);
+        removeClass(row, ACTIVE_CLASS);
+        removeClass(row, HEADER_SELECTED_CLASS);
+        for (i = 0; i < elements.length; i += 1) {
+            element = elements[i];
+            tag = String(element.tagName).toUpperCase();
+            element.removeAttribute('id');
+            removeClass(element, SELECTED_CLASS);
+            removeClass(element, ACTIVE_CLASS);
+            removeClass(element, READONLY_CLASS);
+            removeClass(element, CELL_CLASS);
+            removeClass(element, HEADER_CLASS);
+            removeClass(element, HEADER_SELECTED_CLASS);
+            if (tag === 'LABEL') {
+                element.removeAttribute('for');
+            } else if (tag === 'INPUT') {
+                type = String(element.type || 'text').toLowerCase();
+                if (type === 'checkbox' || type === 'radio') {
+                    element.checked = false;
+                    element.defaultChecked = false;
+                } else if (type !== 'button' && type !== 'submit' && type !== 'reset' &&
+                        type !== 'image') {
+                    try {
+                        element.value = '';
+                        element.defaultValue = '';
+                    } catch (ignoreFileInput) {
+                        /* A cloned file input is already empty in supported browsers. */
+                    }
+                }
+            } else if (tag === 'TEXTAREA') {
+                element.value = '';
+                element.defaultValue = '';
+                setText(element, '');
+            } else if (tag === 'SELECT') {
+                element.selectedIndex = element.options.length ? 0 : -1;
+            } else if (isContentEditable(element)) {
+                setText(element, '');
+            }
+        }
+
+        for (i = 0; i < row.cells.length; i += 1) {
+            if (String(row.cells[i].tagName).toUpperCase() === 'TD' &&
+                    !row.cells[i].children.length) {
+                setText(row.cells[i], '');
+            }
+        }
+        return row;
+    }
+
+    function getCellTarget(cell, table) {
+        var markedElements = cell.querySelectorAll ?
+            cell.querySelectorAll('[data-excel-target]') : [];
+        var elements;
+        var i;
+        var element;
+
+        for (i = 0; i < markedElements.length; i += 1) {
+            if (owningTable(markedElements[i]) === table) {
+                return markedElements[i];
+            }
+        }
+
+        elements = cell.getElementsByTagName('*');
+        for (i = 0; i < elements.length; i += 1) {
+            element = elements[i];
+            if (owningTable(element) === table &&
+                    (isValueControl(element) || isContentEditable(element))) {
+                return element;
+            }
+        }
+
+        return null;
+    }
+
+    function fireEvent(element, type) {
+        var event;
+
+        if (!document || !element || !element.dispatchEvent) {
+            return;
+        }
+
+        event = document.createEvent('HTMLEvents');
+        event.initEvent(type, true, false);
+        element.dispatchEvent(event);
+    }
+
+    function placeCaretAtEnd(element) {
+        var length;
+        var range;
+        var selection;
+
+        if (!element) {
+            return;
+        }
+        if (typeof element.value !== 'undefined' && element.setSelectionRange) {
+            try {
+                length = String(element.value || '').length;
+                element.setSelectionRange(length, length);
+                return;
+            } catch (ignoreInputType) {
+                /* number/date and some legacy input types reject setSelectionRange. */
+            }
+        }
+        if (isContentEditable(element) && document.createRange && root.getSelection) {
+            try {
+                range = document.createRange();
+                range.selectNodeContents(element);
+                range.collapse(false);
+                selection = root.getSelection();
+                selection.removeAllRanges();
+                selection.addRange(range);
+            } catch (ignoreContentEditable) {
+                /* Focus alone is still usable when caret APIs are unavailable. */
+            }
+        }
+    }
+
+    function printableKey(event) {
+        var key = event.key;
+        var code;
+        var character;
+
+        if (event.ctrlKey || event.metaKey || event.altKey) {
+            return null;
+        }
+        if (key && String(key).length === 1) {
+            return String(key);
+        }
+
+        code = event.which || event.keyCode;
+        if (code === 32) {
+            return ' ';
+        }
+        if (code >= 65 && code <= 90) {
+            character = String.fromCharCode(code);
+            return event.shiftKey ? character : character.toLowerCase();
+        }
+        if (code >= 48 && code <= 57 && !event.shiftKey) {
+            return String.fromCharCode(code);
+        }
+        return null;
+    }
+
+    function injectDefaultStyles() {
+        var style;
+        var css;
+        var head;
+
+        if (!document || document.getElementById(STYLE_ID)) {
+            return;
+        }
+
+        css =
+            '.' + TABLE_CLASS + ' .' + CELL_CLASS + '{cursor:cell;}' +
+            '.' + TABLE_CLASS + ' .' + SELECTED_CLASS +
+                '{background-color:#dbeafe!important;}' +
+            '.' + TABLE_CLASS + ' .' + ACTIVE_CLASS +
+                '{box-shadow:inset 0 0 0 2px #2563eb!important;outline:2px solid #2563eb;outline-offset:-2px;}' +
+            '.' + TABLE_CLASS + ' .' + SELECTED_CLASS + ' input,' +
+            '.' + TABLE_CLASS + ' .' + SELECTED_CLASS + ' textarea,' +
+            '.' + TABLE_CLASS + ' .' + SELECTED_CLASS + ' select,' +
+            '.' + TABLE_CLASS + ' .' + SELECTED_CLASS + ' [contenteditable]' +
+                '{background-color:#dbeafe!important;}' +
+            '.' + TABLE_CLASS + ' .' + READONLY_CLASS + '.' + SELECTED_CLASS + ' input,' +
+            '.' + TABLE_CLASS + ' .' + READONLY_CLASS + '.' + SELECTED_CLASS + ' textarea,' +
+            '.' + TABLE_CLASS + ' .' + READONLY_CLASS + '.' + SELECTED_CLASS + ' select,' +
+            '.' + TABLE_CLASS + ' .' + READONLY_CLASS + '.' + SELECTED_CLASS + ' [contenteditable]' +
+                '{background-color:#e5e7eb!important;}' +
+            '.' + TABLE_CLASS + ' .' + READONLY_CLASS + '.' + SELECTED_CLASS +
+                '{background-color:#e5e7eb!important;}' +
+            '.' + TABLE_CLASS + ' .' + HEADER_CLASS + '{cursor:pointer;}' +
+            '.' + TABLE_CLASS + ' .' + HEADER_SELECTED_CLASS +
+                '{background-color:#bfdbfe!important;box-shadow:inset 0 0 0 2px #2563eb!important;}' +
+            '.' + TABLE_CLASS + '.' + DRAGGING_CLASS + ',' +
+            '.' + TABLE_CLASS + '.' + DRAGGING_CLASS + ' *' +
+                '{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}';
+
+        style = document.createElement('style');
+        style.id = STYLE_ID;
+        style.type = 'text/css';
+        if (style.styleSheet) {
+            style.styleSheet.cssText = css;
+        } else {
+            style.appendChild(document.createTextNode(css));
+        }
+
+        head = document.getElementsByTagName('head')[0] || document.documentElement;
+        head.appendChild(style);
+    }
+
+    /*
+     * Parses Excel/LibreOffice/Google Sheets clipboard TSV.
+     * Quoted tabs, quoted line breaks and doubled quotes are preserved.
+     */
+    function parseClipboardText(text) {
+        var rows = [];
+        var row = [];
+        var field = '';
+        var inQuotes = false;
+        var endedWithRowDelimiter = false;
+        var i;
+        var character;
+        var next;
+
+        text = text === null || typeof text === 'undefined' ? '' : String(text);
+        if (text.charCodeAt(0) === 0xFEFF) {
+            text = text.substring(1);
+        }
+
+        for (i = 0; i < text.length; i += 1) {
+            character = text.charAt(i);
+            next = i + 1 < text.length ? text.charAt(i + 1) : '';
+
+            if (inQuotes) {
+                if (character === '"') {
+                    if (next === '"') {
+                        field += '"';
+                        i += 1;
+                    } else {
+                        inQuotes = false;
+                    }
+                } else if (character === '\r') {
+                    field += '\n';
+                    if (next === '\n') {
+                        i += 1;
+                    }
+                } else {
+                    field += character;
+                }
+                endedWithRowDelimiter = false;
+                continue;
+            }
+
+            if (character === '"' && field === '') {
+                inQuotes = true;
+                endedWithRowDelimiter = false;
+            } else if (character === '\t') {
+                row.push(field);
+                field = '';
+                endedWithRowDelimiter = false;
+            } else if (character === '\r' || character === '\n') {
+                row.push(field);
+                rows.push(row);
+                row = [];
+                field = '';
+                if (character === '\r' && next === '\n') {
+                    i += 1;
+                }
+                endedWithRowDelimiter = true;
+            } else {
+                field += character;
+                endedWithRowDelimiter = false;
+            }
+        }
+
+        row.push(field);
+        rows.push(row);
+
+        /* Excel normally appends one CRLF after the copied range. */
+        if (endedWithRowDelimiter && rows.length > 1 &&
+                rows[rows.length - 1].length === 1 && rows[rows.length - 1][0] === '') {
+            rows.pop();
+        }
+
+        return rows;
+    }
+
+    function escapeClipboardField(value) {
+        value = value === null || typeof value === 'undefined' ? '' : String(value);
+        if (/[\t\r\n"]/.test(value)) {
+            return '"' + value.replace(/"/g, '""') + '"';
+        }
+        return value;
+    }
+
+    function resolveTables(target) {
+        var result = [];
+        var nodes;
+        var i;
+
+        if (!document) {
+            throw new Error('VirtualExcelTable: DOM이 있는 브라우저에서만 테이블에 연결할 수 있습니다.');
+        }
+
+        if (typeof target === 'string') {
+            nodes = document.querySelectorAll(target);
+            for (i = 0; i < nodes.length; i += 1) {
+                result.push(nodes[i]);
+            }
+            return result;
+        }
+
+        if (target && target.nodeType === 1) {
+            result.push(target);
+            return result;
+        }
+
+        if (target && typeof target.length === 'number') {
+            for (i = 0; i < target.length; i += 1) {
+                if (target[i] && target[i].nodeType === 1) {
+                    result.push(target[i]);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    function ensureTable(element) {
+        if (!element || String(element.tagName).toUpperCase() !== 'TABLE') {
+            throw new Error('VirtualExcelTable: 대상은 TABLE 요소여야 합니다.');
+        }
+    }
+
+    function bind(instance, method) {
+        return function (event) {
+            return method.call(instance, event || root.event);
+        };
+    }
+
+    function keyName(event) {
+        var code;
+        var key;
+
+        if (event.key) {
+            key = String(event.key).toLowerCase();
+            if (key === 'left' || key === 'up' || key === 'right' || key === 'down') {
+                return 'arrow' + key;
+            }
+            if (key === 'del') {
+                return 'delete';
+            }
+            if (key === 'esc') {
+                return 'escape';
+            }
+            return key;
+        }
+
+        code = event.which || event.keyCode;
+        if (code === 8) { return 'backspace'; }
+        if (code === 9) { return 'tab'; }
+        if (code === 13) { return 'enter'; }
+        if (code === 27) { return 'escape'; }
+        if (code === 37) { return 'arrowleft'; }
+        if (code === 38) { return 'arrowup'; }
+        if (code === 39) { return 'arrowright'; }
+        if (code === 40) { return 'arrowdown'; }
+        if (code === 46) { return 'delete'; }
+        if (code === 89) { return 'y'; }
+        if (code === 90) { return 'z'; }
+        if (code === 109 || code === 189) { return '-'; }
+        if (code === 113) { return 'f2'; }
+        return '';
+    }
+
+    function Grid(table, options) {
+        ensureTable(table);
+
+        this.table = table;
+        this.options = mergeOptions(options);
+        this.selectedCells = [];
+        this.selectedHeaders = [];
+        this.knownHeaders = [];
+        this.selectionType = 'cells';
+        this.anchorCell = null;
+        this.activeCell = null;
+        this.undoStack = [];
+        this.redoStack = [];
+        this.knownCells = [];
+        this.dragging = false;
+        this.dragStartCell = null;
+        this.dragSelectionType = null;
+        this.dragStartIndex = null;
+        this.editingCell = null;
+        this.editingTarget = null;
+        this.editingStartValue = null;
+        this.editingSelectionBefore = null;
+        this.editingMode = null;
+        this.endingEdit = false;
+        this.destroyed = false;
+        this.originalTabIndex = table.getAttribute('tabindex');
+        this.originalDataEnabled = table.getAttribute('data-virtual-excel-table');
+
+        if (this.options.overflow !== 'clip' && this.options.overflow !== 'reject') {
+            throw new Error('VirtualExcelTable: overflow 옵션은 "clip" 또는 "reject"여야 합니다.');
+        }
+        if (this.options.pasteMode !== 'grid' && this.options.pasteMode !== 'auto' &&
+                this.options.pasteMode !== 'native') {
+            throw new Error('VirtualExcelTable: pasteMode 옵션은 "grid", "auto", "native"여야 합니다.');
+        }
+        if (this.options.interactionMode !== 'spreadsheet' &&
+                this.options.interactionMode !== 'form') {
+            throw new Error(
+                'VirtualExcelTable: interactionMode 옵션은 "spreadsheet" 또는 "form"이어야 합니다.'
+            );
+        }
+        if (isNaN(parseInt(this.options.minRows, 10)) ||
+                parseInt(this.options.minRows, 10) < 0) {
+            throw new Error('VirtualExcelTable: minRows 옵션은 0 이상의 숫자여야 합니다.');
+        }
+
+        if (this.options.injectStyles) {
+            injectDefaultStyles();
+        }
+
+        addClass(table, TABLE_CLASS);
+        table.setAttribute('data-virtual-excel-table', 'true');
+        if (this.originalTabIndex === null) {
+            table.setAttribute('tabindex', '0');
+        }
+
+        this.handlers = {
+            mousedown: bind(this, this._onMouseDown),
+            dblclick: bind(this, this._onDoubleClick),
+            mouseover: bind(this, this._onMouseOver),
+            mouseup: bind(this, this._onMouseUp),
+            focusin: bind(this, this._onFocusIn),
+            focusout: bind(this, this._onFocusOut),
+            keydown: bind(this, this._onKeyDown),
+            paste: bind(this, this._onPaste),
+            copy: bind(this, this._onCopy)
+        };
+
+        table.addEventListener('mousedown', this.handlers.mousedown, false);
+        table.addEventListener('dblclick', this.handlers.dblclick, false);
+        table.addEventListener('mouseover', this.handlers.mouseover, false);
+        table.addEventListener('focusin', this.handlers.focusin, false);
+        table.addEventListener('focusout', this.handlers.focusout, false);
+        table.addEventListener('keydown', this.handlers.keydown, false);
+        table.addEventListener('paste', this.handlers.paste, false);
+        table.addEventListener('copy', this.handlers.copy, false);
+        document.addEventListener('mouseup', this.handlers.mouseup, false);
+
+        this.refresh();
+    }
+
+    Grid.prototype._getGrid = function () {
+        var grid = [];
+        var rows = this.table.rows;
+        var currentCells = [];
+        var row;
+        var gridRow;
+        var cell;
+        var i;
+        var j;
+
+        for (i = 0; i < rows.length; i += 1) {
+            row = rows[i];
+            gridRow = [];
+            for (j = 0; j < row.cells.length; j += 1) {
+                cell = row.cells[j];
+                if (owningTable(cell) === this.table &&
+                        matchesSelector(cell, this.options.cellSelector)) {
+                    gridRow.push(cell);
+                    currentCells.push(cell);
+                    addClass(cell, CELL_CLASS);
+                    if (this._isReadOnly(cell)) {
+                        addClass(cell, READONLY_CLASS);
+                    } else {
+                        removeClass(cell, READONLY_CLASS);
+                    }
+                }
+            }
+            if (gridRow.length > 0) {
+                grid.push(gridRow);
+            }
+        }
+
+        for (i = 0; i < this.knownCells.length; i += 1) {
+            if (indexOf(currentCells, this.knownCells[i]) === -1) {
+                removeClass(this.knownCells[i], CELL_CLASS);
+                removeClass(this.knownCells[i], SELECTED_CLASS);
+                removeClass(this.knownCells[i], ACTIVE_CLASS);
+                removeClass(this.knownCells[i], READONLY_CLASS);
+            }
+        }
+        this.knownCells = currentCells;
+        this._refreshSelectionHeaders(grid);
+
+        return grid;
+    };
+
+    Grid.prototype._getHeaderInfo = function (target, grid) {
+        var header = target;
+        var row;
+        var section;
+        var maxColumns = 0;
+        var offset;
+        var index;
+        var i;
+
+        if (header && header.nodeType !== 1) {
+            header = header.parentNode;
+        }
+        while (header && header !== this.table &&
+                String(header.tagName || '').toUpperCase() !== 'TH') {
+            header = header.parentNode;
+        }
+        if (!header || header === this.table || owningTable(header) !== this.table) {
+            return null;
+        }
+
+        row = header.parentNode;
+        section = row && row.parentNode;
+        if (!row || !section) {
+            return null;
+        }
+
+        for (i = 0; i < grid.length; i += 1) {
+            maxColumns = Math.max(maxColumns, grid[i].length);
+        }
+
+        if (String(section.tagName).toUpperCase() === 'TBODY' &&
+                (header.getAttribute('data-excel-row-header') !== null ||
+                matchesSelector(header, this.options.rowHeaderSelector))) {
+            for (i = 0; i < grid.length; i += 1) {
+                if (grid[i].length && grid[i][0].parentNode === row) {
+                    return { type: 'rows', index: i, element: header };
+                }
+            }
+        }
+
+        if (String(section.tagName).toUpperCase() === 'THEAD' && maxColumns > 0 &&
+                header.getAttribute('data-excel-corner') !== null) {
+            return { type: 'all', index: 0, element: header };
+        }
+
+        if (String(section.tagName).toUpperCase() === 'THEAD' && maxColumns > 0 &&
+                (header.getAttribute('data-excel-column') !== null ||
+                matchesSelector(header, this.options.columnHeaderSelector))) {
+            if (header.getAttribute('data-excel-column') !== null) {
+                index = parseInt(header.getAttribute('data-excel-column'), 10);
+                if (!isNaN(index) && index >= 0 && index < maxColumns) {
+                    return { type: 'columns', index: index, element: header };
+                }
+                return null;
+            }
+            offset = Math.max(0, row.cells.length - maxColumns);
+            index = header.cellIndex;
+            if (index < offset) {
+                return { type: 'all', index: 0, element: header };
+            }
+            index = index - offset;
+            if (index >= 0 && index < maxColumns) {
+                return { type: 'columns', index: index, element: header };
+            }
+        }
+        return null;
+    };
+
+    Grid.prototype._refreshSelectionHeaders = function (grid) {
+        var headers = this.table.getElementsByTagName('th');
+        var current = [];
+        var info;
+        var i;
+
+        for (i = 0; i < headers.length; i += 1) {
+            info = this._getHeaderInfo(headers[i], grid);
+            if (info) {
+                current.push(headers[i]);
+                addClass(headers[i], HEADER_CLASS);
+            }
+        }
+        for (i = 0; i < this.knownHeaders.length; i += 1) {
+            if (indexOf(current, this.knownHeaders[i]) === -1) {
+                removeClass(this.knownHeaders[i], HEADER_CLASS);
+                removeClass(this.knownHeaders[i], HEADER_SELECTED_CLASS);
+            }
+        }
+        this.knownHeaders = current;
+    };
+
+    Grid.prototype._clearHeaderSelectionClasses = function () {
+        var i;
+        for (i = 0; i < this.selectedHeaders.length; i += 1) {
+            removeClass(this.selectedHeaders[i], HEADER_SELECTED_CLASS);
+        }
+        this.selectedHeaders = [];
+    };
+
+    Grid.prototype._applyHeaderSelectionClasses = function (type, bounds, grid) {
+        var info;
+        var selected;
+        var i;
+
+        this._clearHeaderSelectionClasses();
+        if (type === 'cells' || !bounds) {
+            return;
+        }
+        for (i = 0; i < this.knownHeaders.length; i += 1) {
+            info = this._getHeaderInfo(this.knownHeaders[i], grid);
+            selected = type === 'all' ||
+                (type === 'rows' && info && info.type === 'rows' &&
+                    info.index >= bounds.startRow && info.index <= bounds.endRow) ||
+                (type === 'columns' && info && info.type === 'columns' &&
+                    info.index >= bounds.startColumn && info.index <= bounds.endColumn);
+            if (selected) {
+                this.selectedHeaders.push(this.knownHeaders[i]);
+                addClass(this.knownHeaders[i], HEADER_SELECTED_CLASS);
+            }
+        }
+    };
+
+    Grid.prototype._selectHeaderRange = function (type, startIndex, endIndex, focusTable) {
+        var grid = this._getGrid();
+        var start;
+        var end;
+        var firstRow;
+        var lastRow;
+        var row;
+
+        if (!grid.length) {
+            return false;
+        }
+        if (type === 'all') {
+            lastRow = grid.length - 1;
+            return this._setSelection(
+                grid[0][0],
+                grid[lastRow][grid[lastRow].length - 1],
+                focusTable,
+                'all'
+            );
+        }
+
+        if (type === 'rows') {
+            start = Math.max(0, Math.min(grid.length - 1, startIndex));
+            end = Math.max(0, Math.min(grid.length - 1, endIndex));
+            return this._setSelection(
+                grid[start][0],
+                grid[end][grid[end].length - 1],
+                focusTable,
+                'rows'
+            );
+        }
+
+        if (type === 'columns') {
+            start = Math.min(startIndex, endIndex);
+            end = Math.max(startIndex, endIndex);
+            firstRow = -1;
+            lastRow = -1;
+            for (row = 0; row < grid.length; row += 1) {
+                if (grid[row][start] && grid[row][end]) {
+                    if (firstRow === -1) {
+                        firstRow = row;
+                    }
+                    lastRow = row;
+                }
+            }
+            if (firstRow === -1) {
+                return false;
+            }
+            return this._setSelection(
+                grid[firstRow][start],
+                grid[lastRow][end],
+                focusTable,
+                'columns'
+            );
+        }
+        return false;
+    };
+
+    Grid.prototype._findCell = function (target) {
+        var nearestTable;
+        var current;
+        var tag;
+
+        if (!target) {
+            return null;
+        }
+        if (target.nodeType !== 1) {
+            target = target.parentNode;
+        }
+
+        nearestTable = owningTable(target);
+        if (nearestTable !== this.table) {
+            return null;
+        }
+
+        current = target;
+        while (current && current !== this.table) {
+            tag = String(current.tagName || '').toUpperCase();
+            if ((tag === 'TD' || tag === 'TH') &&
+                    matchesSelector(current, this.options.cellSelector)) {
+                return current;
+            }
+            current = current.parentNode;
+        }
+
+        return null;
+    };
+
+    Grid.prototype._isEditorTarget = function (target, cell) {
+        var current = target;
+
+        if (current && current.nodeType !== 1) {
+            current = current.parentNode;
+        }
+
+        while (current && current !== cell.parentNode) {
+            if (isInteractiveElement(current)) {
+                return true;
+            }
+            if (current === cell) {
+                break;
+            }
+            current = current.parentNode;
+        }
+        return false;
+    };
+
+    Grid.prototype._isGridEditorTarget = function (target, cell) {
+        var current = target;
+
+        if (current && current.nodeType !== 1) {
+            current = current.parentNode;
+        }
+
+        while (current && current !== cell.parentNode) {
+            if ((isValueControl(current) &&
+                    String(current.tagName).toUpperCase() !== 'SELECT') ||
+                    isContentEditable(current)) {
+                return true;
+            }
+            if (current === cell) {
+                break;
+            }
+            current = current.parentNode;
+        }
+        return false;
+    };
+
+    Grid.prototype._usesNativePointerEditor = function (target, cell) {
+        var current = target;
+
+        if (current && current.nodeType !== 1) {
+            current = current.parentNode;
+        }
+
+        while (current && current !== cell.parentNode) {
+            if (current.getAttribute &&
+                    current.getAttribute('data-excel-native-editor') !== null) {
+                return true;
+            }
+            if (current === cell) {
+                break;
+            }
+            current = current.parentNode;
+        }
+        return false;
+    };
+
+    Grid.prototype._clearEditState = function () {
+        this.editingCell = null;
+        this.editingTarget = null;
+        this.editingStartValue = null;
+        this.editingSelectionBefore = null;
+        this.editingMode = null;
+    };
+
+    Grid.prototype._enterEditMode = function (cell, replacementValue, replaceValue) {
+        var target;
+        var tag;
+        var startValue;
+        var selectionBefore;
+
+        if (!cell || this._isReadOnly(cell)) {
+            return false;
+        }
+        target = this._getTarget(cell);
+        if (!target || (!isValueControl(target) && !isContentEditable(target))) {
+            return false;
+        }
+
+        tag = String(target.tagName).toUpperCase();
+        if (replaceValue === true && tag === 'SELECT') {
+            return false;
+        }
+
+        if (this.editingCell && this.editingCell !== cell) {
+            this._finishEditMode(false, false);
+        }
+        selectionBefore = this._snapshotSelection();
+        startValue = this._readValue(cell);
+        this._setSelection(cell, cell, false);
+        this.editingCell = cell;
+        this.editingTarget = target;
+        this.editingStartValue = startValue;
+        this.editingSelectionBefore = selectionBefore;
+        this.editingMode = replaceValue === true ? 'replace' : 'manual';
+        try {
+            target.focus();
+            if (replaceValue === true) {
+                this._writeEditValue(cell, replacementValue);
+            }
+            placeCaretAtEnd(target);
+        } catch (error) {
+            if (replaceValue === true) {
+                try {
+                    this._writeValue(cell, startValue, false);
+                } catch (ignoreRollback) {
+                    /* Preserve the first error. */
+                }
+            }
+            this._clearEditState();
+            this._reportError(error);
+            return false;
+        }
+        return true;
+    };
+
+    Grid.prototype._writeEditValue = function (cell, value) {
+        var target = this._getTarget(cell) || cell;
+
+        this._writeValue(cell, value, false);
+        if (this.options.dispatchEvents) {
+            fireEvent(target, 'input');
+        }
+    };
+
+    Grid.prototype._finishEditMode = function (cancel, focusTable) {
+        var cell = this.editingCell;
+        var startValue = this.editingStartValue;
+        var selectionBefore = this.editingSelectionBefore;
+        var selectionAfter;
+        var currentValue;
+        var changes;
+        var beforeResult;
+
+        if (!cell || this.endingEdit) {
+            if (focusTable) {
+                this._focusTable();
+            }
+            return false;
+        }
+
+        this.endingEdit = true;
+        selectionAfter = { type: 'cells', anchor: cell, active: cell };
+        currentValue = contains(this.table, cell) ? this._readValue(cell) : startValue;
+
+        if (cancel === true && startValue !== null && contains(this.table, cell)) {
+            try {
+                if (currentValue !== startValue) {
+                    this._writeEditValue(cell, startValue);
+                }
+            } catch (error) {
+                this._reportError(error);
+            }
+        } else if (contains(this.table, cell) && currentValue !== startValue) {
+            changes = [{
+                cell: cell,
+                oldValue: startValue,
+                newValue: currentValue
+            }];
+            if (typeof this.options.beforeChange === 'function') {
+                try {
+                    beforeResult = this.options.beforeChange(
+                        this._copyChanges(changes),
+                        { type: 'edit' }
+                    );
+                } catch (beforeError) {
+                    beforeResult = false;
+                    this._reportError(beforeError);
+                }
+            }
+            if (beforeResult === false) {
+                try {
+                    this._writeEditValue(cell, startValue);
+                } catch (restoreError) {
+                    this._reportError(restoreError);
+                }
+            } else {
+                this._record('edit', changes, selectionBefore, selectionAfter);
+                if (typeof this.options.afterChange === 'function') {
+                    try {
+                        this.options.afterChange(
+                            this._copyChanges(changes),
+                            { type: 'edit' }
+                        );
+                    } catch (afterError) {
+                        this._reportError(afterError);
+                    }
+                }
+            }
+        }
+
+        this._clearEditState();
+        if (cancel === true && selectionBefore) {
+            this._restoreSelection(selectionBefore, focusTable === true);
+        } else if (focusTable) {
+            this._focusTable();
+        }
+        this.endingEdit = false;
+        return true;
+    };
+
+    Grid.prototype._getTarget = function (cell) {
+        return getCellTarget(cell, this.table);
+    };
+
+    Grid.prototype._isReadOnly = function (cell) {
+        var target = this._getTarget(cell);
+        var cellAttribute = cell.getAttribute('data-excel-readonly');
+        var targetAttribute = target && target.getAttribute ?
+            target.getAttribute('data-excel-readonly') : null;
+
+        if (typeof this.options.readOnly === 'function' &&
+                this.options.readOnly(cell, target) === true) {
+            return true;
+        }
+        if ((cellAttribute !== null && String(cellAttribute).toLowerCase() !== 'false') ||
+                cell.getAttribute('aria-readonly') === 'true') {
+            return true;
+        }
+        if (target && ((targetAttribute !== null &&
+                String(targetAttribute).toLowerCase() !== 'false') ||
+                target.getAttribute('aria-readonly') === 'true' ||
+                target.disabled === true || target.readOnly === true)) {
+            return true;
+        }
+        if (target && isInteractiveElement(target) && !isValueControl(target) &&
+                !isContentEditable(target) && typeof this.options.setValue !== 'function') {
+            return true;
+        }
+        /* Do not destroy links, buttons, icons or unsupported controls in a complex cell. */
+        if (!target && typeof this.options.setValue !== 'function' &&
+                hasUnsafeCellMarkup(cell)) {
+            return true;
+        }
+        return false;
+    };
+
+    Grid.prototype._readValue = function (cell) {
+        var target = this._getTarget(cell);
+        var customValue;
+
+        if (typeof this.options.getValue === 'function') {
+            customValue = this.options.getValue(cell, target);
+            return String(customValue === null || typeof customValue === 'undefined' ? '' : customValue);
+        }
+        if (target && (isValueControl(target) || typeof target.value !== 'undefined')) {
+            return String(target.value === null || typeof target.value === 'undefined' ? '' : target.value);
+        }
+        if (target) {
+            return String(getText(target));
+        }
+        return String(getText(cell));
+    };
+
+    Grid.prototype._readDisplayValue = function (cell) {
+        var target = this._getTarget(cell);
+
+        if (target && String(target.tagName).toUpperCase() === 'SELECT') {
+            if (target.selectedIndex >= 0 && target.options[target.selectedIndex]) {
+                return String(target.options[target.selectedIndex].text);
+            }
+            return '';
+        }
+        return this._readValue(cell);
+    };
+
+    Grid.prototype._normalizeIncomingValue = function (cell, value) {
+        var target = this._getTarget(cell);
+        var text = value === null || typeof value === 'undefined' ? '' : String(value);
+        var i;
+
+        if (typeof this.options.setValue === 'function' || !target ||
+                String(target.tagName).toUpperCase() !== 'SELECT') {
+            return text;
+        }
+        for (i = 0; i < target.options.length; i += 1) {
+            if (String(target.options[i].value) === text) {
+                return text;
+            }
+        }
+        for (i = 0; i < target.options.length; i += 1) {
+            if (String(target.options[i].text) === text) {
+                return String(target.options[i].value);
+            }
+        }
+        return text;
+    };
+
+    Grid.prototype._writeValue = function (cell, value, dispatchEvents) {
+        var target = this._getTarget(cell);
+        var eventTarget = target || cell;
+
+        value = value === null || typeof value === 'undefined' ? '' : String(value);
+
+        if (typeof this.options.setValue === 'function') {
+            this.options.setValue(cell, value, target);
+        } else if (target && String(target.tagName).toUpperCase() === 'SELECT') {
+            target.value = this._normalizeIncomingValue(cell, value);
+        } else if (target && (isValueControl(target) || typeof target.value !== 'undefined')) {
+            target.value = value;
+        } else if (target) {
+            setText(target, value);
+        } else {
+            setText(cell, value);
+        }
+
+        if (dispatchEvents && this.options.dispatchEvents) {
+            fireEvent(eventTarget, 'input');
+            fireEvent(eventTarget, 'change');
+        }
+    };
+
+    Grid.prototype._positionOf = function (grid, cell) {
+        var row;
+        var column;
+
+        for (row = 0; row < grid.length; row += 1) {
+            for (column = 0; column < grid[row].length; column += 1) {
+                if (grid[row][column] === cell) {
+                    return { row: row, column: column };
+                }
+            }
+        }
+        return null;
+    };
+
+    Grid.prototype._clearSelectionClasses = function () {
+        var i;
+        for (i = 0; i < this.selectedCells.length; i += 1) {
+            removeClass(this.selectedCells[i], SELECTED_CLASS);
+            removeClass(this.selectedCells[i], ACTIVE_CLASS);
+        }
+    };
+
+    Grid.prototype._setSelection = function (anchorCell, activeCell, focusTable, type) {
+        var grid = this._getGrid();
+        var anchorPosition = this._positionOf(grid, anchorCell);
+        var activePosition = this._positionOf(grid, activeCell);
+        var startRow;
+        var endRow;
+        var startColumn;
+        var endColumn;
+        var row;
+        var column;
+        var cell;
+
+        if (!anchorPosition || !activePosition) {
+            return false;
+        }
+
+        this._clearSelectionClasses();
+        this.selectedCells = [];
+        this.anchorCell = anchorCell;
+        this.activeCell = activeCell;
+        this.selectionType = type || 'cells';
+
+        startRow = Math.min(anchorPosition.row, activePosition.row);
+        endRow = Math.max(anchorPosition.row, activePosition.row);
+        startColumn = Math.min(anchorPosition.column, activePosition.column);
+        endColumn = Math.max(anchorPosition.column, activePosition.column);
+
+        for (row = startRow; row <= endRow; row += 1) {
+            for (column = startColumn; column <= endColumn; column += 1) {
+                cell = grid[row] && grid[row][column];
+                if (cell) {
+                    this.selectedCells.push(cell);
+                    addClass(cell, SELECTED_CLASS);
+                }
+            }
+        }
+        addClass(activeCell, ACTIVE_CLASS);
+        this._applyHeaderSelectionClasses(this.selectionType, {
+            startRow: startRow,
+            endRow: endRow,
+            startColumn: startColumn,
+            endColumn: endColumn
+        }, grid);
+
+        if (focusTable) {
+            this._focusTable();
+        }
+        this._notifySelectionChange();
+        return true;
+    };
+
+    Grid.prototype._focusTable = function () {
+        if (this.table && this.table.focus) {
+            try {
+                this.table.focus();
+            } catch (ignore) {
+                /* Some embedded browsers can reject programmatic focus. */
+            }
+        }
+    };
+
+    Grid.prototype._notifySelectionChange = function () {
+        if (typeof this.options.onSelectionChange === 'function') {
+            try {
+                this.options.onSelectionChange(this.getSelection());
+            } catch (error) {
+                this._reportError(error);
+            }
+        }
+    };
+
+    Grid.prototype._snapshotSelection = function () {
+        return {
+            type: this.selectionType || 'cells',
+            anchor: this.anchorCell,
+            active: this.activeCell
+        };
+    };
+
+    Grid.prototype._restoreSelection = function (snapshot, focusTable) {
+        if (snapshot && snapshot.anchor && snapshot.active &&
+                contains(this.table, snapshot.anchor) && contains(this.table, snapshot.active)) {
+            this._setSelection(
+                snapshot.anchor,
+                snapshot.active,
+                focusTable === true,
+                snapshot.type || 'cells'
+            );
+        }
+    };
+
+    Grid.prototype._selectionBounds = function (grid) {
+        var anchorPosition;
+        var activePosition;
+
+        if (!this.anchorCell || !this.activeCell) {
+            return null;
+        }
+        anchorPosition = this._positionOf(grid, this.anchorCell);
+        activePosition = this._positionOf(grid, this.activeCell);
+        if (!anchorPosition || !activePosition) {
+            return null;
+        }
+
+        return {
+            startRow: Math.min(anchorPosition.row, activePosition.row),
+            endRow: Math.max(anchorPosition.row, activePosition.row),
+            startColumn: Math.min(anchorPosition.column, activePosition.column),
+            endColumn: Math.max(anchorPosition.column, activePosition.column)
+        };
+    };
+
+    Grid.prototype._ensureSelection = function () {
+        var grid;
+        if (this.selectedCells.length > 0 && this.anchorCell && this.activeCell) {
+            return true;
+        }
+        grid = this._getGrid();
+        if (grid.length && grid[0].length) {
+            return this._setSelection(grid[0][0], grid[0][0], false);
+        }
+        return false;
+    };
+
+    Grid.prototype._onMouseDown = function (event) {
+        var cell;
+        var grid;
+        var headerInfo;
+        var anchorPosition;
+        var headerStart;
+        var editorTarget;
+        var gridEditorTarget;
+        var useNativeEditor;
+        var nativePointerEditor;
+
+        if (this.destroyed || (typeof event.button !== 'undefined' && event.button !== 0)) {
+            return;
+        }
+
+        grid = this._getGrid();
+        headerInfo = this._getHeaderInfo(event.target || event.srcElement, grid);
+        if (headerInfo) {
+            if (this.editingCell) {
+                this._finishEditMode(false, false);
+            }
+            headerStart = headerInfo.index;
+            if (event.shiftKey && this.selectionType === headerInfo.type && this.anchorCell) {
+                anchorPosition = this._positionOf(grid, this.anchorCell);
+                if (anchorPosition) {
+                    headerStart = headerInfo.type === 'rows' ?
+                        anchorPosition.row : anchorPosition.column;
+                }
+            }
+            this._selectHeaderRange(
+                headerInfo.type,
+                headerStart,
+                headerInfo.index,
+                true
+            );
+            if (event.preventDefault) {
+                event.preventDefault();
+            }
+            this._focusTable();
+            this.dragStartCell = null;
+            this.dragSelectionType = null;
+            this.dragStartIndex = null;
+            if (headerInfo.type !== 'all') {
+                this.dragging = true;
+                this.dragSelectionType = headerInfo.type;
+                this.dragStartIndex = headerStart;
+                addClass(this.table, DRAGGING_CLASS);
+            } else {
+                this.dragging = false;
+                removeClass(this.table, DRAGGING_CLASS);
+            }
+            return;
+        }
+
+        cell = this._findCell(event.target || event.srcElement);
+        if (!cell) {
+            return;
+        }
+
+        editorTarget = this._isEditorTarget(event.target || event.srcElement, cell);
+        gridEditorTarget = this._isGridEditorTarget(event.target || event.srcElement, cell);
+        nativePointerEditor = this._usesNativePointerEditor(
+            event.target || event.srcElement,
+            cell
+        );
+        useNativeEditor = editorTarget;
+        if (this.options.interactionMode === 'spreadsheet' && gridEditorTarget &&
+                this.editingCell !== cell && !nativePointerEditor) {
+            useNativeEditor = false;
+        }
+
+        if (this.editingCell && (this.editingCell !== cell ||
+                !useNativeEditor || event.shiftKey)) {
+            this._finishEditMode(false, false);
+        }
+
+        if (event.shiftKey && this.anchorCell) {
+            this._setSelection(this.anchorCell, cell, true);
+        } else {
+            this._setSelection(cell, cell, !useNativeEditor);
+        }
+
+        if (useNativeEditor && !event.shiftKey) {
+            this.dragging = false;
+            return;
+        }
+
+        if (event.preventDefault) {
+            event.preventDefault();
+        }
+        this._focusTable();
+        this.dragging = true;
+        this.dragSelectionType = null;
+        this.dragStartIndex = null;
+        this.dragStartCell = event.shiftKey && this.anchorCell ? this.anchorCell : cell;
+        addClass(this.table, DRAGGING_CLASS);
+    };
+
+    Grid.prototype._onDoubleClick = function (event) {
+        var cell;
+
+        if (this.destroyed || this.options.interactionMode !== 'spreadsheet') {
+            return;
+        }
+        cell = this._findCell(event.target || event.srcElement);
+        if (!cell || !this._enterEditMode(cell)) {
+            return;
+        }
+
+        this._setSelection(cell, cell, false);
+        this.dragging = false;
+        this.dragStartCell = null;
+        removeClass(this.table, DRAGGING_CLASS);
+        if (event.preventDefault) {
+            event.preventDefault();
+        }
+    };
+
+    Grid.prototype._onMouseOver = function (event) {
+        var cell;
+        var info;
+        var grid;
+        if (!this.dragging || !this.dragStartCell) {
+            if (!this.dragging || !this.dragSelectionType) {
+                return;
+            }
+            grid = this._getGrid();
+            info = this._getHeaderInfo(event.target || event.srcElement, grid);
+            if (info && info.type === this.dragSelectionType) {
+                this._selectHeaderRange(
+                    this.dragSelectionType,
+                    this.dragStartIndex,
+                    info.index,
+                    false
+                );
+            }
+            return;
+        }
+        cell = this._findCell(event.target || event.srcElement);
+        if (cell && cell !== this.activeCell) {
+            this._setSelection(this.dragStartCell, cell, false);
+        }
+    };
+
+    Grid.prototype._onMouseUp = function () {
+        this.dragging = false;
+        this.dragStartCell = null;
+        this.dragSelectionType = null;
+        this.dragStartIndex = null;
+        removeClass(this.table, DRAGGING_CLASS);
+    };
+
+    Grid.prototype._onFocusIn = function (event) {
+        var cell;
+
+        if (this.destroyed) {
+            return;
+        }
+        cell = this._findCell(event.target || event.srcElement);
+        if (cell && this._isGridEditorTarget(event.target || event.srcElement, cell)) {
+            if (this.editingCell !== cell) {
+                this.editingSelectionBefore = this._snapshotSelection();
+                this.editingCell = cell;
+                this.editingTarget = this._getTarget(cell);
+                this.editingStartValue = this._readValue(cell);
+                this.editingMode = this.options.interactionMode === 'form' ? 'form' : 'manual';
+            }
+            if (this.activeCell !== cell) {
+                this._setSelection(cell, cell, false);
+            }
+        } else if ((event.target || event.srcElement) === this.table) {
+            this._clearEditState();
+        }
+    };
+
+    Grid.prototype._onFocusOut = function (event) {
+        var nextTarget = event.relatedTarget || null;
+
+        if (!this.endingEdit && this.editingCell &&
+                (!nextTarget || !contains(this.editingCell, nextTarget))) {
+            this._finishEditMode(false, false);
+        }
+    };
+
+    Grid.prototype._moveActiveCell = function (rowDelta, columnDelta, extendSelection) {
+        var grid = this._getGrid();
+        var current = this._positionOf(grid, this.activeCell);
+        var nextRow;
+        var nextColumn;
+        var nextCell;
+
+        if (!current) {
+            return;
+        }
+
+        nextRow = Math.max(0, Math.min(grid.length - 1, current.row + rowDelta));
+        nextColumn = Math.max(0, current.column + columnDelta);
+        if (!grid[nextRow] || !grid[nextRow].length) {
+            return;
+        }
+        nextColumn = Math.min(grid[nextRow].length - 1, nextColumn);
+        nextCell = grid[nextRow][nextColumn];
+
+        if (extendSelection && this.anchorCell) {
+            this._setSelection(this.anchorCell, nextCell, true);
+        } else {
+            this._setSelection(nextCell, nextCell, true);
+        }
+    };
+
+    Grid.prototype._moveTab = function (direction) {
+        var grid = this._getGrid();
+        var current = this._positionOf(grid, this.activeCell);
+        var nextRow;
+        var nextColumn;
+        var nextCell;
+
+        if (!current || !grid.length) {
+            return;
+        }
+
+        nextRow = current.row;
+        nextColumn = current.column + direction;
+        if (direction > 0 && nextColumn >= grid[nextRow].length) {
+            nextRow = nextRow + 1;
+            if (nextRow >= grid.length) {
+                nextRow = 0;
+            }
+            nextColumn = 0;
+        } else if (direction < 0 && nextColumn < 0) {
+            nextRow = nextRow - 1;
+            if (nextRow < 0) {
+                nextRow = grid.length - 1;
+            }
+            nextColumn = grid[nextRow].length - 1;
+        }
+
+        if (!grid[nextRow] || !grid[nextRow].length) {
+            return;
+        }
+        nextColumn = Math.max(0, Math.min(grid[nextRow].length - 1, nextColumn));
+        nextCell = grid[nextRow][nextColumn];
+        this._setSelection(nextCell, nextCell, true);
+    };
+
+    Grid.prototype._onKeyDown = function (event) {
+        var key;
+        var command;
+        var cell;
+        var target;
+        var editorTarget;
+        var gridEditorTarget;
+        var nativeEditor;
+        var character;
+        var code;
+
+        if (this.destroyed) {
+            return;
+        }
+
+        target = event.target || event.srcElement;
+        key = keyName(event);
+        command = event.ctrlKey || event.metaKey;
+        code = event.which || event.keyCode;
+        cell = this._findCell(target) || this.activeCell;
+        editorTarget = cell ? this._isEditorTarget(target, cell) : false;
+        gridEditorTarget = cell ?
+            this._isGridEditorTarget(target, cell) : false;
+        nativeEditor = editorTarget && (!gridEditorTarget ||
+            this.options.interactionMode === 'form' || this.editingCell === cell);
+
+        if (event.isComposing || code === 229) {
+            if (this.options.interactionMode === 'spreadsheet' && !nativeEditor &&
+                    this.activeCell) {
+                /* Best effort: hand the active input to the IME without cancelling the key. */
+                this._enterEditMode(this.activeCell, '', true);
+            }
+            return;
+        }
+
+        if (this.options.interactionMode === 'spreadsheet' && command &&
+                key === 'enter' && !event.altKey && !event.shiftKey) {
+            if (event.preventDefault) { event.preventDefault(); }
+            if (!event.repeat) {
+                this.insertRowBelow();
+            }
+            return;
+        }
+
+        if (nativeEditor) {
+            if (this.options.interactionMode === 'spreadsheet' && gridEditorTarget &&
+                    this.editingCell === cell && key === 'escape') {
+                if (event.preventDefault) { event.preventDefault(); }
+                this._finishEditMode(true, true);
+                return;
+            }
+            if (this.options.interactionMode === 'spreadsheet' && gridEditorTarget &&
+                    this.editingCell === cell && key === 'tab') {
+                if (event.preventDefault) { event.preventDefault(); }
+                this._finishEditMode(false, true);
+                this._moveTab(event.shiftKey ? -1 : 1);
+                return;
+            }
+            if (this.options.interactionMode === 'spreadsheet' && gridEditorTarget &&
+                    this.editingCell === cell && key === 'enter' && !event.altKey) {
+                if (event.preventDefault) { event.preventDefault(); }
+                this._finishEditMode(false, true);
+                this._moveActiveCell(event.shiftKey ? -1 : 1, 0, false);
+                return;
+            }
+            if (this.options.interactionMode === 'spreadsheet' && gridEditorTarget &&
+                    this.editingCell === cell && this.editingMode === 'replace' &&
+                    !command && !event.altKey && !event.shiftKey &&
+                    (key === 'arrowleft' || key === 'arrowright' ||
+                    key === 'arrowup' || key === 'arrowdown')) {
+                if (event.preventDefault) { event.preventDefault(); }
+                this._finishEditMode(false, true);
+                this._moveActiveCell(
+                    key === 'arrowup' ? -1 : (key === 'arrowdown' ? 1 : 0),
+                    key === 'arrowleft' ? -1 : (key === 'arrowright' ? 1 : 0),
+                    false
+                );
+                return;
+            }
+            return;
+        }
+
+        if (this.options.interactionMode === 'spreadsheet') {
+            if (key === 'tab') {
+                if (event.preventDefault) { event.preventDefault(); }
+                this._moveTab(event.shiftKey ? -1 : 1);
+                return;
+            }
+            if (!command && key === 'enter') {
+                if (event.preventDefault) { event.preventDefault(); }
+                this._moveActiveCell(event.shiftKey ? -1 : 1, 0, false);
+                return;
+            }
+            if (!command && key === 'f2') {
+                if (this.selectionType === 'cells' &&
+                        this._enterEditMode(this.activeCell) && event.preventDefault) {
+                    event.preventDefault();
+                }
+                return;
+            }
+            character = printableKey(event);
+            if (character !== null) {
+                if (this.selectionType === 'cells' &&
+                        this._enterEditMode(this.activeCell, character, true) &&
+                        event.preventDefault) {
+                    event.preventDefault();
+                }
+                return;
+            }
+        }
+
+        if (command && (key === '-' || key === 'subtract')) {
+            if (event.preventDefault) { event.preventDefault(); }
+            if (this.selectionType === 'rows' || this.selectionType === 'cells') {
+                this.deleteRows();
+            }
+            return;
+        }
+
+        if (command && key === 'z') {
+            if (event.preventDefault) { event.preventDefault(); }
+            if (event.shiftKey) {
+                this.redo();
+            } else {
+                this.undo();
+            }
+            return;
+        }
+        if (command && key === 'y') {
+            if (event.preventDefault) { event.preventDefault(); }
+            this.redo();
+            return;
+        }
+        if (key === 'delete' || key === 'backspace') {
+            if (event.preventDefault) { event.preventDefault(); }
+            if (key === 'delete' && this.selectionType === 'rows') {
+                this.deleteRows();
+            } else {
+                this.clear();
+            }
+            return;
+        }
+        if (key === 'arrowleft' || key === 'arrowright' ||
+                key === 'arrowup' || key === 'arrowdown') {
+            if (event.preventDefault) { event.preventDefault(); }
+            this._moveActiveCell(
+                key === 'arrowup' ? -1 : (key === 'arrowdown' ? 1 : 0),
+                key === 'arrowleft' ? -1 : (key === 'arrowright' ? 1 : 0),
+                event.shiftKey === true
+            );
+        }
+    };
+
+    Grid.prototype._clipboardText = function (event) {
+        var clipboard = event.clipboardData || (root && root.clipboardData);
+        var value = '';
+        var available = false;
+        var legacyClipboard = root && root.clipboardData === clipboard;
+        var firstError = null;
+
+        if (!clipboard || !clipboard.getData) {
+            return { available: false, value: '' };
+        }
+
+        try {
+            value = clipboard.getData(legacyClipboard ? 'Text' : 'text/plain');
+            available = true;
+        } catch (primaryError) {
+            firstError = primaryError;
+        }
+
+        if (!available || value === null || typeof value === 'undefined') {
+            try {
+                value = clipboard.getData(legacyClipboard ? 'text/plain' : 'Text');
+                available = true;
+            } catch (fallbackError) {
+                this._reportError(firstError || fallbackError);
+                return { available: false, value: '' };
+            }
+        }
+        return {
+            available: available,
+            value: value === null || typeof value === 'undefined' ? '' : value
+        };
+    };
+
+    Grid.prototype._onPaste = function (event) {
+        var clipboard;
+        var matrix;
+        var cell;
+        var editorTarget;
+        var shouldUseNative;
+
+        if (this.destroyed || this.options.pasteMode === 'native') {
+            return;
+        }
+
+        clipboard = this._clipboardText(event);
+        if (!clipboard.available) {
+            return;
+        }
+
+        matrix = parseClipboardText(clipboard.value);
+        cell = this._findCell(event.target || event.srcElement);
+        editorTarget = cell ? this._isEditorTarget(event.target || event.srcElement, cell) : false;
+
+        if (this.options.interactionMode === 'spreadsheet' && cell &&
+                this.editingCell === cell &&
+                this._isGridEditorTarget(event.target || event.srcElement, cell)) {
+            return;
+        }
+        if (this.editingCell) {
+            this._finishEditMode(false, false);
+        }
+
+        /*
+         * Keyboard/Tab focus can move without a mouse event; paste into the focused cell.
+         * A legacy browser may, however, leave focus on an old input after a row/column
+         * header drag. Do not let that stale paste target collapse a header selection.
+         */
+        if (this.selectionType === 'cells' && cell && editorTarget &&
+                cell !== this.activeCell) {
+            this._setSelection(cell, cell, false);
+        }
+        shouldUseNative = this.options.pasteMode === 'auto' && editorTarget &&
+            matrix.length === 1 && matrix[0].length === 1 && this.selectedCells.length <= 1;
+
+        if (shouldUseNative) {
+            return;
+        }
+        if (!this._ensureSelection()) {
+            return;
+        }
+
+        if (event.preventDefault) {
+            event.preventDefault();
+        }
+        this._pasteMatrix(matrix);
+        this._focusTable();
+    };
+
+    Grid.prototype._onCopy = function (event) {
+        var target = event.target || event.srcElement;
+        var cell;
+        var editorTarget;
+        var gridEditorTarget;
+        var nativeEditor;
+        var clipboard;
+        var legacyClipboard;
+        var text;
+        var copied = false;
+
+        if (this.destroyed || !this.selectedCells.length) {
+            return;
+        }
+
+        if (target === this.table && document.activeElement &&
+                contains(this.table, document.activeElement)) {
+            target = document.activeElement;
+        }
+        cell = this._findCell(target);
+        editorTarget = cell ? this._isEditorTarget(target, cell) : false;
+        gridEditorTarget = cell ?
+            this._isGridEditorTarget(target, cell) : false;
+        nativeEditor = editorTarget && (!gridEditorTarget ||
+            this.options.interactionMode === 'form' || this.editingCell === cell);
+        if (nativeEditor) {
+            return;
+        }
+
+        clipboard = event.clipboardData || (root && root.clipboardData);
+        if (!clipboard || !clipboard.setData) {
+            return;
+        }
+
+        try {
+            text = this.getCopyText();
+        } catch (readError) {
+            this._reportError(readError);
+            return;
+        }
+
+        legacyClipboard = root && root.clipboardData === clipboard;
+        try {
+            clipboard.setData(legacyClipboard ? 'Text' : 'text/plain', text);
+            copied = true;
+        } catch (primaryError) {
+            try {
+                clipboard.setData(legacyClipboard ? 'text/plain' : 'Text', text);
+                copied = true;
+            } catch (fallbackError) {
+                this._reportError(primaryError || fallbackError);
+            }
+        }
+
+        if (copied && event.preventDefault) {
+            event.preventDefault();
+        }
+        if (copied) {
+            event.returnValue = false;
+        }
+    };
+
+    Grid.prototype._makeChanges = function (cellsAndValues) {
+        var changes = [];
+        var item;
+        var oldValue;
+        var newValue;
+        var i;
+
+        for (i = 0; i < cellsAndValues.length; i += 1) {
+            item = cellsAndValues[i];
+            if (!item.cell || this._isReadOnly(item.cell)) {
+                continue;
+            }
+            oldValue = this._readValue(item.cell);
+            newValue = this._normalizeIncomingValue(item.cell, item.value);
+            if (oldValue !== newValue) {
+                changes.push({
+                    cell: item.cell,
+                    oldValue: oldValue,
+                    newValue: newValue
+                });
+            }
+        }
+
+        return changes;
+    };
+
+    Grid.prototype._copyChanges = function (changes) {
+        var copy = [];
+        var i;
+        for (i = 0; i < changes.length; i += 1) {
+            copy.push({
+                cell: changes[i].cell,
+                oldValue: changes[i].oldValue,
+                newValue: changes[i].newValue
+            });
+        }
+        return copy;
+    };
+
+    Grid.prototype._applyChanges = function (changes, meta) {
+        var applied = [];
+        var i;
+        var beforeResult;
+        var error;
+
+        if (changes.length === 0) {
+            return true;
+        }
+
+        if (typeof this.options.beforeChange === 'function') {
+            try {
+                beforeResult = this.options.beforeChange(this._copyChanges(changes), meta);
+            } catch (beforeError) {
+                this._reportError(beforeError);
+                return false;
+            }
+            if (beforeResult === false) {
+                return false;
+            }
+        }
+
+        try {
+            for (i = 0; i < changes.length; i += 1) {
+                this._writeValue(changes[i].cell, changes[i].newValue, true);
+                applied.push(changes[i]);
+            }
+        } catch (writeError) {
+            error = writeError;
+            for (i = applied.length - 1; i >= 0; i -= 1) {
+                try {
+                    this._writeValue(applied[i].cell, applied[i].oldValue, false);
+                } catch (ignore) {
+                    /* Preserve the first error; best-effort rollback. */
+                }
+            }
+            this._reportError(error);
+            return false;
+        }
+
+        if (typeof this.options.afterChange === 'function') {
+            try {
+                this.options.afterChange(this._copyChanges(changes), meta);
+            } catch (afterError) {
+                this._reportError(afterError);
+            }
+        }
+        return true;
+    };
+
+    Grid.prototype._pushHistory = function (entry) {
+        var limit = parseInt(this.options.historyLimit, 10);
+
+        if (isNaN(limit) || limit <= 0) {
+            this.redoStack = [];
+            return;
+        }
+
+        this.undoStack.push(entry);
+        while (this.undoStack.length > limit) {
+            this.undoStack.shift();
+        }
+        this.redoStack = [];
+    };
+
+    Grid.prototype._record = function (type, changes, selectionBefore, selectionAfter, addedRows) {
+        if (!changes.length && (!addedRows || !addedRows.length)) {
+            return;
+        }
+        this._pushHistory({
+            kind: 'cells',
+            type: type,
+            changes: this._copyChanges(changes),
+            addedRows: addedRows && addedRows.length ? addedRows.slice(0) : null,
+            selectionBefore: selectionBefore,
+            selectionAfter: selectionAfter
+        });
+    };
+
+    Grid.prototype._recordRows = function (records, selectionBefore, selectionAfter) {
+        if (!records.length) {
+            return;
+        }
+        this._pushHistory({
+            kind: 'rows',
+            type: 'deleteRows',
+            rows: records.slice(0),
+            selectionBefore: selectionBefore,
+            selectionAfter: selectionAfter
+        });
+    };
+
+    Grid.prototype._isRowReadOnly = function (row) {
+        var attribute = row.getAttribute('data-excel-row-readonly');
+
+        if (typeof this.options.rowReadOnly === 'function' &&
+                this.options.rowReadOnly(row) === true) {
+            return true;
+        }
+        return (attribute !== null && String(attribute).toLowerCase() !== 'false') ||
+            row.getAttribute('aria-readonly') === 'true';
+    };
+
+    Grid.prototype._collectSelectedRowRecords = function () {
+        var records = [];
+        var rows = this.table.rows;
+        var row;
+        var selected;
+        var i;
+        var j;
+
+        for (i = 0; i < rows.length; i += 1) {
+            row = rows[i];
+            selected = false;
+            for (j = 0; j < this.selectedCells.length; j += 1) {
+                if (this.selectedCells[j].parentNode === row) {
+                    selected = true;
+                    break;
+                }
+            }
+            if (selected && owningTable(row) === this.table &&
+                    matchesSelector(row, this.options.rowSelector) &&
+                    row.parentNode && String(row.parentNode.tagName).toUpperCase() === 'TBODY') {
+                records.push({
+                    row: row,
+                    parent: row.parentNode,
+                    nextSibling: row.nextSibling,
+                    sectionIndex: row.sectionRowIndex
+                });
+            }
+        }
+        return records;
+    };
+
+    Grid.prototype._clearSelectionState = function () {
+        this._clearSelectionClasses();
+        this._clearHeaderSelectionClasses();
+        this.selectedCells = [];
+        this.anchorCell = null;
+        this.activeCell = null;
+        this.selectionType = 'cells';
+        this._clearEditState();
+    };
+
+    Grid.prototype._notifyRowsChange = function (records, meta) {
+        var rows = [];
+        var i;
+
+        for (i = 0; i < records.length; i += 1) {
+            rows.push(records[i].row);
+        }
+
+        if (typeof this.options.reindexRows === 'function') {
+            try {
+                this.options.reindexRows(this.table, meta);
+            } catch (reindexError) {
+                this._reportError(reindexError);
+            }
+        }
+        if (typeof this.options.afterRowsChange === 'function') {
+            try {
+                this.options.afterRowsChange(rows, meta);
+            } catch (afterError) {
+                this._reportError(afterError);
+            }
+        }
+    };
+
+    Grid.prototype._pasteMatrix = function (matrix) {
+        var grid = this._getGrid();
+        var bounds = this._selectionBounds(grid);
+        var selectionBefore = this._snapshotSelection();
+        var selectionAfter;
+        var assignments = [];
+        var changes;
+        var startCell;
+        var lastCell;
+        var targetCell;
+        var row;
+        var column;
+        var overflowed = false;
+        var fillSelection;
+        var repeatSelection;
+        var rectangularSource = true;
+        var rectangularSelection;
+        var sourceColumns;
+        var selectionRows;
+        var selectionColumns;
+        var addedRows = [];
+        var addedRecord;
+        var requiredRows;
+        var maxSourceColumns = 0;
+        var maxGridColumns = 0;
+        var pasteMeta;
+        var addMeta = {
+            type: 'pasteRows',
+            originalType: 'paste',
+            action: 'add'
+        };
+
+        if (!bounds || !matrix || !matrix.length) {
+            return 0;
+        }
+
+        startCell = grid[bounds.startRow][bounds.startColumn];
+        lastCell = startCell;
+        fillSelection = this.options.pasteSingleToSelection && matrix.length === 1 &&
+            matrix[0].length === 1 && this.selectedCells.length > 1;
+        sourceColumns = matrix[0].length;
+        selectionRows = bounds.endRow - bounds.startRow + 1;
+        selectionColumns = bounds.endColumn - bounds.startColumn + 1;
+        rectangularSelection = this.selectedCells.length ===
+            selectionRows * selectionColumns;
+
+        for (row = 0; row < matrix.length; row += 1) {
+            maxSourceColumns = Math.max(maxSourceColumns, matrix[row].length);
+            if (matrix[row].length !== sourceColumns) {
+                rectangularSource = false;
+            }
+        }
+        if (rectangularSelection) {
+            for (row = bounds.startRow; row <= bounds.endRow; row += 1) {
+                for (column = bounds.startColumn;
+                        column <= bounds.endColumn; column += 1) {
+                    if (!grid[row] || !grid[row][column]) {
+                        rectangularSelection = false;
+                        break;
+                    }
+                }
+                if (!rectangularSelection) {
+                    break;
+                }
+            }
+        }
+        repeatSelection = !fillSelection &&
+            this.options.pasteRepeatToSelection !== false &&
+            this.selectedCells.length > 1 && rectangularSource &&
+            rectangularSelection && sourceColumns > 0 &&
+            (matrix.length > 1 || sourceColumns > 1) &&
+            selectionRows >= matrix.length && selectionColumns >= sourceColumns &&
+            (selectionRows > matrix.length || selectionColumns > sourceColumns) &&
+            selectionRows % matrix.length === 0 &&
+            selectionColumns % sourceColumns === 0;
+        for (row = 0; row < grid.length; row += 1) {
+            maxGridColumns = Math.max(maxGridColumns, grid[row].length);
+        }
+        if (!fillSelection && !repeatSelection && this.options.overflow === 'reject' &&
+                bounds.startColumn + maxSourceColumns > maxGridColumns) {
+            this._reportError(new Error('VirtualExcelTable: 붙여넣을 범위가 테이블 열 크기를 초과했습니다.'));
+            return 0;
+        }
+
+        if (!fillSelection && !repeatSelection &&
+                this.options.autoAddRowsOnPaste !== false) {
+            requiredRows = bounds.startRow + matrix.length;
+            while (grid.length < requiredRows) {
+                addedRecord = this._appendRow(null, addMeta, false);
+                if (!addedRecord) {
+                    break;
+                }
+                addedRows.push(addedRecord);
+                grid = this._getGrid();
+            }
+            if (addedRows.length) {
+                this._notifyRowsChange(addedRows, addMeta);
+                grid = this._getGrid();
+                bounds = this._selectionBounds(grid);
+            }
+        }
+
+        if (fillSelection) {
+            for (row = 0; row < this.selectedCells.length; row += 1) {
+                assignments.push({ cell: this.selectedCells[row], value: matrix[0][0] });
+            }
+            selectionAfter = selectionBefore;
+        } else if (repeatSelection) {
+            for (row = bounds.startRow; row <= bounds.endRow; row += 1) {
+                for (column = bounds.startColumn;
+                        column <= bounds.endColumn; column += 1) {
+                    targetCell = grid[row] && grid[row][column];
+                    if (targetCell) {
+                        assignments.push({
+                            cell: targetCell,
+                            value: matrix[(row - bounds.startRow) % matrix.length]
+                                [(column - bounds.startColumn) % sourceColumns]
+                        });
+                    }
+                }
+            }
+            selectionAfter = selectionBefore;
+        } else {
+            for (row = 0; row < matrix.length; row += 1) {
+                for (column = 0; column < matrix[row].length; column += 1) {
+                    targetCell = grid[bounds.startRow + row] &&
+                        grid[bounds.startRow + row][bounds.startColumn + column];
+                    if (!targetCell) {
+                        overflowed = true;
+                    } else {
+                        assignments.push({ cell: targetCell, value: matrix[row][column] });
+                        lastCell = targetCell;
+                    }
+                }
+            }
+            selectionAfter = { type: 'cells', anchor: startCell, active: lastCell };
+        }
+
+        if (overflowed && this.options.overflow === 'reject') {
+            this._reportError(new Error('VirtualExcelTable: 붙여넣을 범위가 테이블 크기를 초과했습니다.'));
+            return 0;
+        }
+
+        pasteMeta = {
+            type: 'paste',
+            matrix: matrix,
+            repeated: fillSelection || repeatSelection,
+            sourceRows: matrix.length,
+            sourceColumns: sourceColumns,
+            targetRows: fillSelection || repeatSelection ? selectionRows : matrix.length,
+            targetColumns: fillSelection || repeatSelection ?
+                selectionColumns : maxSourceColumns
+        };
+        changes = this._makeChanges(assignments);
+        if (!this._applyChanges(changes, pasteMeta)) {
+            return 0;
+        }
+        this._record('paste', changes, selectionBefore, selectionAfter, addedRows);
+        this._restoreSelection(selectionAfter, false);
+        return changes.length;
+    };
+
+    Grid.prototype._reportError = function (error) {
+        if (typeof this.options.onError === 'function') {
+            try {
+                this.options.onError(error);
+                return;
+            } catch (ignore) {
+                /* Fall through to console for an error inside onError itself. */
+            }
+        }
+        if (root && root.console && typeof root.console.error === 'function') {
+            root.console.error(error);
+        }
+    };
+
+    Grid.prototype._assertActive = function () {
+        if (this.destroyed) {
+            throw new Error('VirtualExcelTable: destroy()된 인스턴스는 다시 사용할 수 없습니다.');
+        }
+    };
+
+    Grid.prototype.refresh = function () {
+        var grid;
+        var selected = [];
+        var i;
+
+        this._assertActive();
+        grid = this._getGrid();
+
+        for (i = 0; i < this.selectedCells.length; i += 1) {
+            if (indexOf(this.knownCells, this.selectedCells[i]) !== -1) {
+                selected.push(this.selectedCells[i]);
+            }
+        }
+        this.selectedCells = selected;
+
+        if (this.anchorCell && indexOf(this.knownCells, this.anchorCell) === -1) {
+            this.anchorCell = null;
+        }
+        if (this.activeCell && indexOf(this.knownCells, this.activeCell) === -1) {
+            this.activeCell = null;
+        }
+        if (!this.anchorCell || !this.activeCell) {
+            this._clearSelectionClasses();
+            this._clearHeaderSelectionClasses();
+            this.selectedCells = [];
+            this.selectionType = 'cells';
+        }
+
+        return grid.length;
+    };
+
+    Grid.prototype.select = function (startRow, startColumn, endRow, endColumn) {
+        var grid;
+        var anchor;
+        var active;
+
+        this._assertActive();
+        grid = this._getGrid();
+
+        endRow = typeof endRow === 'number' ? endRow : startRow;
+        endColumn = typeof endColumn === 'number' ? endColumn : startColumn;
+        anchor = grid[startRow] && grid[startRow][startColumn];
+        active = grid[endRow] && grid[endRow][endColumn];
+
+        if (!anchor || !active) {
+            throw new Error('VirtualExcelTable: 선택 좌표가 테이블 범위를 벗어났습니다.');
+        }
+        this._setSelection(anchor, active, true);
+        return this;
+    };
+
+    Grid.prototype.selectAll = function () {
+        var grid;
+        var lastRow;
+
+        this._assertActive();
+        grid = this._getGrid();
+
+        if (!grid.length || !grid[0].length) {
+            return this;
+        }
+        lastRow = grid.length - 1;
+        this._setSelection(
+            grid[0][0],
+            grid[lastRow][grid[lastRow].length - 1],
+            true,
+            'all'
+        );
+        return this;
+    };
+
+    Grid.prototype.getSelection = function () {
+        var grid;
+        var bounds;
+
+        this._assertActive();
+        grid = this._getGrid();
+        bounds = this._selectionBounds(grid);
+
+        if (!bounds) {
+            return null;
+        }
+        return {
+            type: this.selectionType || 'cells',
+            start: { row: bounds.startRow, column: bounds.startColumn },
+            end: { row: bounds.endRow, column: bounds.endColumn },
+            cells: this.selectedCells.slice(0)
+        };
+    };
+
+    Grid.prototype.getCopyText = function () {
+        var grid;
+        var bounds;
+        var lines = [];
+        var fields;
+        var cell;
+        var row;
+        var column;
+
+        this._assertActive();
+        grid = this._getGrid();
+        bounds = this._selectionBounds(grid);
+        if (!bounds) {
+            return '';
+        }
+
+        for (row = bounds.startRow; row <= bounds.endRow; row += 1) {
+            fields = [];
+            for (column = bounds.startColumn; column <= bounds.endColumn; column += 1) {
+                cell = grid[row] && grid[row][column];
+                if (cell && indexOf(this.selectedCells, cell) !== -1) {
+                    fields.push(escapeClipboardField(this._readDisplayValue(cell)));
+                } else {
+                    fields.push('');
+                }
+            }
+            lines.push(fields.join('\t'));
+        }
+        return lines.join('\r\n');
+    };
+
+    Grid.prototype.copy = function () {
+        var result;
+
+        this._assertActive();
+        if (!this.selectedCells.length || !document.execCommand) {
+            return false;
+        }
+        this._focusTable();
+        try {
+            result = document.execCommand('copy');
+            return result !== false;
+        } catch (error) {
+            this._reportError(error);
+            return false;
+        }
+    };
+
+    Grid.prototype._inferJsonKeys = function (grid, providedKeys) {
+        var keys = [];
+        var used = {};
+        var maxColumns = 0;
+        var headerInfo;
+        var target;
+        var name;
+        var match;
+        var key;
+        var base;
+        var suffix;
+        var row;
+        var column;
+        var i;
+
+        for (row = 0; row < grid.length; row += 1) {
+            maxColumns = Math.max(maxColumns, grid[row].length);
+        }
+
+        for (column = 0; column < maxColumns; column += 1) {
+            key = providedKeys && providedKeys[column] !== null &&
+                typeof providedKeys[column] !== 'undefined' ?
+                String(providedKeys[column]) : '';
+
+            if (!key) {
+                for (i = 0; i < this.knownHeaders.length; i += 1) {
+                    headerInfo = this._getHeaderInfo(this.knownHeaders[i], grid);
+                    if (headerInfo && headerInfo.type === 'columns' &&
+                            headerInfo.index === column &&
+                            this.knownHeaders[i].getAttribute('data-excel-key')) {
+                        key = this.knownHeaders[i].getAttribute('data-excel-key');
+                        break;
+                    }
+                }
+            }
+
+            if (!key) {
+                for (row = 0; row < grid.length; row += 1) {
+                    if (!grid[row][column]) {
+                        continue;
+                    }
+                    target = this._getTarget(grid[row][column]);
+                    name = target && target.getAttribute ? target.getAttribute('name') : '';
+                    if (name) {
+                        match = name.match(/(?:^|\.)([^.\[\]]+)$/) ||
+                            name.match(/\[([^\]]+)\]$/);
+                        if (match) {
+                            key = match[1];
+                            break;
+                        }
+                    }
+                }
+            }
+
+            base = key || ('key' + (column + 1));
+            if (base === '__proto__') {
+                base = 'key' + (column + 1);
+            }
+            key = base;
+            suffix = 2;
+            while (used[key]) {
+                key = base + '_' + suffix;
+                suffix += 1;
+            }
+            used[key] = true;
+            keys.push(key);
+        }
+        return keys;
+    };
+
+    Grid.prototype.getJsonData = function (columnKeys, options) {
+        var grid;
+        var keys;
+        var result = [];
+        var item;
+        var value;
+        var empty;
+        var row;
+        var column;
+
+        this._assertActive();
+        if (columnKeys && Object.prototype.toString.call(columnKeys) !== '[object Array]') {
+            throw new Error('VirtualExcelTable: JSON 열 키는 문자열 배열이어야 합니다.');
+        }
+        options = options || {};
+        grid = this._getGrid();
+        keys = this._inferJsonKeys(grid, columnKeys || null);
+
+        for (row = 0; row < grid.length; row += 1) {
+            item = {};
+            empty = true;
+            for (column = 0; column < keys.length; column += 1) {
+                value = grid[row][column] ? this._readValue(grid[row][column]) : '';
+                item[keys[column]] = value;
+                if (value !== '') {
+                    empty = false;
+                }
+            }
+            if (!(options.skipEmptyRows === true && empty)) {
+                result.push(item);
+            }
+        }
+        return result;
+    };
+
+    Grid.prototype.toJSON = function (columnKeys, options) {
+        if (Object.prototype.toString.call(columnKeys) !== '[object Array]') {
+            columnKeys = null;
+        }
+        return this.getJsonData(columnKeys, options);
+    };
+
+    Grid.prototype.paste = function (text) {
+        this._assertActive();
+        if (this.editingCell) {
+            this._finishEditMode(false, false);
+        }
+        if (!this._ensureSelection()) {
+            return 0;
+        }
+        return this._pasteMatrix(parseClipboardText(text));
+    };
+
+    Grid.prototype.clear = function () {
+        var selectionBefore;
+        var assignments = [];
+        var changes;
+        var i;
+
+        this._assertActive();
+        if (this.editingCell) {
+            this._finishEditMode(false, false);
+        }
+
+        if (!this.selectedCells.length) {
+            return 0;
+        }
+
+        selectionBefore = this._snapshotSelection();
+        for (i = 0; i < this.selectedCells.length; i += 1) {
+            assignments.push({ cell: this.selectedCells[i], value: '' });
+        }
+        changes = this._makeChanges(assignments);
+        if (!this._applyChanges(changes, { type: 'delete' })) {
+            return 0;
+        }
+        this._record('delete', changes, selectionBefore, selectionBefore);
+        return changes.length;
+    };
+
+    Grid.prototype.deleteSelection = Grid.prototype.clear;
+
+    Grid.prototype._appendRow = function (values, meta, notifyChange, placement) {
+        var grid = this._getGrid();
+        var referenceRow = placement && placement.referenceRow ?
+            placement.referenceRow : null;
+        var sourceRow = null;
+        var insertIndex = grid.length;
+        var referenceGridIndex = -1;
+        var referenceNode;
+        var parent;
+        var gridIndex;
+        var row;
+        var newGrid;
+        var rowCells = [];
+        var keys;
+        var value;
+        var beforeResult;
+        var record;
+        var i;
+        var j;
+
+        if (referenceRow) {
+            for (gridIndex = 0; gridIndex < grid.length; gridIndex += 1) {
+                if (grid[gridIndex].length &&
+                        grid[gridIndex][0].parentNode === referenceRow) {
+                    referenceGridIndex = gridIndex;
+                    break;
+                }
+            }
+            if (referenceGridIndex === -1 || owningTable(referenceRow) !== this.table ||
+                    !matchesSelector(referenceRow, this.options.rowSelector) ||
+                    !referenceRow.parentNode ||
+                    String(referenceRow.parentNode.tagName).toUpperCase() !== 'TBODY') {
+                this._reportError(new Error(
+                    'VirtualExcelTable: 새 행을 삽입할 기준 행을 찾을 수 없습니다.'
+                ));
+                return null;
+            }
+            sourceRow = referenceRow;
+            insertIndex = referenceGridIndex + 1;
+        } else {
+            sourceRow = grid.length && grid[grid.length - 1].length ?
+                grid[grid.length - 1][0].parentNode : null;
+        }
+        parent = sourceRow ? sourceRow.parentNode :
+            (this.table.tBodies.length ? this.table.tBodies[0] : null);
+
+        try {
+            if (typeof this.options.rowFactory === 'function') {
+                row = this.options.rowFactory(
+                    this.table,
+                    insertIndex,
+                    values,
+                    referenceRow
+                );
+            } else if (sourceRow) {
+                row = prepareClonedRow(sourceRow.cloneNode(true));
+            }
+        } catch (factoryError) {
+            this._reportError(factoryError);
+            return null;
+        }
+
+        if (!row || String(row.tagName).toUpperCase() !== 'TR' || row.parentNode) {
+            this._reportError(new Error(
+                'VirtualExcelTable: 행을 추가하려면 rowFactory가 분리된 TR을 반환하거나 기존 행이 있어야 합니다.'
+            ));
+            return null;
+        }
+        if (!parent) {
+            parent = document.createElement('tbody');
+            this.table.appendChild(parent);
+        }
+
+        if (typeof this.options.beforeRowAdd === 'function') {
+            try {
+                beforeResult = this.options.beforeRowAdd(row, meta);
+            } catch (beforeError) {
+                this._reportError(beforeError);
+                return null;
+            }
+            if (beforeResult === false) {
+                return null;
+            }
+        }
+
+        if (referenceRow && (referenceRow.parentNode !== parent ||
+                !contains(this.table, referenceRow))) {
+            this._reportError(new Error(
+                'VirtualExcelTable: 행 추가 준비 중 기준 행의 위치가 변경되었습니다.'
+            ));
+            return null;
+        }
+
+        try {
+            referenceNode = referenceRow ? referenceRow.nextSibling : null;
+            parent.insertBefore(row, referenceNode);
+        } catch (appendError) {
+            this._reportError(appendError);
+            return null;
+        }
+
+        this.refresh();
+        newGrid = this._getGrid();
+        for (i = 0; i < newGrid.length; i += 1) {
+            if (newGrid[i].length && newGrid[i][0].parentNode === row) {
+                rowCells = newGrid[i];
+                break;
+            }
+        }
+
+        if (Object.prototype.toString.call(values) === '[object Array]') {
+            for (j = 0; j < rowCells.length && j < values.length; j += 1) {
+                if (!this._isReadOnly(rowCells[j])) {
+                    this._writeValue(rowCells[j], values[j], true);
+                }
+            }
+        } else if (values && typeof values === 'object') {
+            keys = this._inferJsonKeys(newGrid, null);
+            for (j = 0; j < rowCells.length && j < keys.length; j += 1) {
+                if (own(values, keys[j]) && !this._isReadOnly(rowCells[j])) {
+                    value = values[keys[j]];
+                    this._writeValue(rowCells[j], value, true);
+                }
+            }
+        }
+
+        record = {
+            row: row,
+            parent: parent,
+            nextSibling: row.nextSibling,
+            sectionIndex: row.sectionRowIndex
+        };
+        if (notifyChange !== false) {
+            this._notifyRowsChange([record], meta);
+        }
+        return record;
+    };
+
+    Grid.prototype.addRow = function (values) {
+        var meta = {
+            type: 'addRow',
+            originalType: 'addRow',
+            action: 'add'
+        };
+        var record;
+        var grid;
+        var row;
+        var selectionBefore;
+        var selectionAfter;
+
+        this._assertActive();
+        if (this.editingCell) {
+            this._finishEditMode(false, false);
+        }
+        selectionBefore = this._snapshotSelection();
+        record = this._appendRow(values, meta, true);
+        if (!record) {
+            return null;
+        }
+
+        grid = this._getGrid();
+        for (row = 0; row < grid.length; row += 1) {
+            if (grid[row].length && grid[row][0].parentNode === record.row) {
+                this._setSelection(grid[row][0], grid[row][0], true);
+                break;
+            }
+        }
+        selectionAfter = this._snapshotSelection();
+        this._pushHistory({
+            kind: 'addedRows',
+            type: 'addRow',
+            addedRows: [record],
+            selectionBefore: selectionBefore,
+            selectionAfter: selectionAfter
+        });
+        return record.row;
+    };
+
+    Grid.prototype.insertRowBelow = function (values) {
+        var grid;
+        var activePosition;
+        var referenceRow;
+        var preferredColumn;
+        var meta;
+        var record;
+        var selectionBefore;
+        var selectionAfter;
+        var row;
+        var column;
+
+        this._assertActive();
+        if (this.editingCell) {
+            this._finishEditMode(false, false);
+        }
+        if ((this.selectionType !== 'cells' && this.selectionType !== 'rows') ||
+                !this.activeCell) {
+            return null;
+        }
+
+        grid = this._getGrid();
+        activePosition = this._positionOf(grid, this.activeCell);
+        if (!activePosition) {
+            return null;
+        }
+        referenceRow = this.activeCell.parentNode;
+        preferredColumn = this.selectionType === 'cells' ? activePosition.column : 0;
+        meta = {
+            type: 'insertRow',
+            originalType: 'insertRow',
+            action: 'add',
+            position: 'after',
+            insertIndex: activePosition.row + 1
+        };
+        selectionBefore = this._snapshotSelection();
+        record = this._appendRow(values, meta, true, {
+            referenceRow: referenceRow
+        });
+        if (!record) {
+            return null;
+        }
+
+        grid = this._getGrid();
+        for (row = 0; row < grid.length; row += 1) {
+            if (grid[row].length && grid[row][0].parentNode === record.row) {
+                column = Math.max(0, Math.min(grid[row].length - 1, preferredColumn));
+                this._setSelection(grid[row][column], grid[row][column], true);
+                break;
+            }
+        }
+        selectionAfter = this._snapshotSelection();
+        this._pushHistory({
+            kind: 'addedRows',
+            type: 'insertRow',
+            addedRows: [record],
+            selectionBefore: selectionBefore,
+            selectionAfter: selectionAfter
+        });
+        return record.row;
+    };
+
+    Grid.prototype.addRowBelow = Grid.prototype.insertRowBelow;
+
+    Grid.prototype.deleteRows = function () {
+        var grid;
+        var bounds;
+        var records;
+        var rows = [];
+        var selectionBefore;
+        var selectionAfter;
+        var targetRow;
+        var targetColumn;
+        var beforeResult;
+        var removed = [];
+        var meta = {
+            type: 'deleteRows',
+            originalType: 'deleteRows',
+            action: 'remove'
+        };
+        var i;
+
+        this._assertActive();
+        if (this.editingCell) {
+            this._finishEditMode(false, false);
+        }
+        this.refresh();
+        if (!this.selectedCells.length) {
+            return 0;
+        }
+
+        grid = this._getGrid();
+        bounds = this._selectionBounds(grid);
+        records = this._collectSelectedRowRecords();
+        if (!bounds || !records.length) {
+            return 0;
+        }
+        if (grid.length - records.length < parseInt(this.options.minRows, 10)) {
+            this._reportError(new Error(
+                'VirtualExcelTable: 최소 ' + this.options.minRows + '개의 행은 남아 있어야 합니다.'
+            ));
+            return 0;
+        }
+
+        for (i = 0; i < records.length; i += 1) {
+            if (this._isRowReadOnly(records[i].row)) {
+                this._reportError(new Error(
+                    'VirtualExcelTable: 삭제할 수 없는 읽기 전용 행이 선택되어 있습니다.'
+                ));
+                return 0;
+            }
+            rows.push(records[i].row);
+        }
+
+        if (typeof this.options.beforeRowsDelete === 'function') {
+            try {
+                beforeResult = this.options.beforeRowsDelete(rows.slice(0), meta);
+            } catch (beforeError) {
+                this._reportError(beforeError);
+                return 0;
+            }
+            if (beforeResult === false) {
+                return 0;
+            }
+        }
+
+        /* A callback may have changed the DOM, so validate the entire batch again. */
+        for (i = 0; i < records.length; i += 1) {
+            if (records[i].row.parentNode !== records[i].parent ||
+                    !contains(this.table, records[i].row)) {
+                this._reportError(new Error(
+                    'VirtualExcelTable: 행 삭제 전에 테이블 구조가 변경되었습니다.'
+                ));
+                return 0;
+            }
+        }
+
+        selectionBefore = this._snapshotSelection();
+        this._clearSelectionState();
+        try {
+            for (i = records.length - 1; i >= 0; i -= 1) {
+                records[i].parent.removeChild(records[i].row);
+                removed.push(records[i]);
+            }
+        } catch (removeError) {
+            for (i = 0; i < removed.length; i += 1) {
+                try {
+                    removed[i].parent.insertBefore(
+                        removed[i].row,
+                        removed[i].nextSibling &&
+                            removed[i].nextSibling.parentNode === removed[i].parent ?
+                            removed[i].nextSibling : null
+                    );
+                } catch (ignore) {
+                    /* Best-effort rollback; preserve the original error. */
+                }
+            }
+            this.refresh();
+            this._restoreSelection(selectionBefore, false);
+            this._reportError(removeError);
+            return 0;
+        }
+
+        this.refresh();
+        grid = this._getGrid();
+        if (grid.length) {
+            targetRow = Math.min(bounds.startRow, grid.length - 1);
+            targetColumn = Math.min(bounds.startColumn, grid[targetRow].length - 1);
+            if (grid[targetRow][targetColumn]) {
+                this._setSelection(
+                    grid[targetRow][targetColumn],
+                    grid[targetRow][targetColumn],
+                    true
+                );
+            }
+        } else {
+            this._notifySelectionChange();
+        }
+        selectionAfter = this._snapshotSelection();
+        this._recordRows(records, selectionBefore, selectionAfter);
+        this._notifyRowsChange(records, meta);
+        return records.length;
+    };
+
+    Grid.prototype.removeSelectedRows = Grid.prototype.deleteRows;
+
+    Grid.prototype._undoDeletedRows = function (entry) {
+        var inserted = [];
+        var record;
+        var reference;
+        var meta = {
+            type: 'undo',
+            originalType: 'deleteRows',
+            action: 'restore'
+        };
+        var i;
+
+        for (i = 0; i < entry.rows.length; i += 1) {
+            record = entry.rows[i];
+            if (!contains(this.table, record.parent) || record.row.parentNode) {
+                this._reportError(new Error(
+                    'VirtualExcelTable: 삭제된 행의 원래 위치가 변경되어 복원할 수 없습니다.'
+                ));
+                return false;
+            }
+        }
+
+        try {
+            for (i = entry.rows.length - 1; i >= 0; i -= 1) {
+                record = entry.rows[i];
+                reference = record.nextSibling &&
+                    record.nextSibling.parentNode === record.parent ?
+                    record.nextSibling : (record.parent.rows[record.sectionIndex] || null);
+                record.parent.insertBefore(record.row, reference);
+                inserted.push(record);
+            }
+        } catch (insertError) {
+            for (i = 0; i < inserted.length; i += 1) {
+                if (inserted[i].row.parentNode === inserted[i].parent) {
+                    inserted[i].parent.removeChild(inserted[i].row);
+                }
+            }
+            this.refresh();
+            this._reportError(insertError);
+            return false;
+        }
+
+        this.refresh();
+        this._restoreSelection(entry.selectionBefore, true);
+        this._notifyRowsChange(entry.rows, meta);
+        return true;
+    };
+
+    Grid.prototype._redoDeletedRows = function (entry) {
+        var removed = [];
+        var record;
+        var grid = this._getGrid();
+        var meta = {
+            type: 'redo',
+            originalType: 'deleteRows',
+            action: 'remove'
+        };
+        var i;
+
+        if (grid.length - entry.rows.length < parseInt(this.options.minRows, 10)) {
+            this._reportError(new Error(
+                'VirtualExcelTable: 최소 ' + this.options.minRows + '개의 행은 남아 있어야 합니다.'
+            ));
+            return false;
+        }
+
+        for (i = 0; i < entry.rows.length; i += 1) {
+            record = entry.rows[i];
+            if (record.row.parentNode !== record.parent ||
+                    !contains(this.table, record.row) || this._isRowReadOnly(record.row)) {
+                this._reportError(new Error(
+                    'VirtualExcelTable: 행 구조가 변경되었거나 읽기 전용이어서 다시 삭제할 수 없습니다.'
+                ));
+                return false;
+            }
+        }
+
+        this._clearSelectionState();
+        try {
+            for (i = entry.rows.length - 1; i >= 0; i -= 1) {
+                entry.rows[i].parent.removeChild(entry.rows[i].row);
+                removed.push(entry.rows[i]);
+            }
+        } catch (removeError) {
+            for (i = 0; i < removed.length; i += 1) {
+                record = removed[i];
+                record.parent.insertBefore(
+                    record.row,
+                    record.nextSibling && record.nextSibling.parentNode === record.parent ?
+                        record.nextSibling : (record.parent.rows[record.sectionIndex] || null)
+                );
+            }
+            this.refresh();
+            this._restoreSelection(entry.selectionBefore, false);
+            this._reportError(removeError);
+            return false;
+        }
+
+        this.refresh();
+        this._restoreSelection(entry.selectionAfter, true);
+        if (!this.activeCell) {
+            this._notifySelectionChange();
+        }
+        this._notifyRowsChange(entry.rows, meta);
+        return true;
+    };
+
+    Grid.prototype._removePasteAddedRows = function (entry) {
+        var records = entry.addedRows || [];
+        var meta = {
+            type: 'undo',
+            originalType: entry.type,
+            action: 'removeAddedRows'
+        };
+        var i;
+
+        for (i = 0; i < records.length; i += 1) {
+            if (records[i].row.parentNode !== records[i].parent) {
+                this._reportError(new Error(
+                    'VirtualExcelTable: 추가된 행 구조가 변경되어 되돌릴 수 없습니다.'
+                ));
+                return false;
+            }
+        }
+        this._clearSelectionState();
+        for (i = records.length - 1; i >= 0; i -= 1) {
+            records[i].parent.removeChild(records[i].row);
+        }
+        this.refresh();
+        this._notifyRowsChange(records, meta);
+        return true;
+    };
+
+    Grid.prototype._restorePasteAddedRows = function (entry) {
+        var records = entry.addedRows || [];
+        var record;
+        var reference;
+        var meta = {
+            type: 'redo',
+            originalType: entry.type,
+            action: 'restoreAddedRows'
+        };
+        var i;
+
+        for (i = 0; i < records.length; i += 1) {
+            if (!contains(this.table, records[i].parent) || records[i].row.parentNode) {
+                this._reportError(new Error(
+                    'VirtualExcelTable: 추가된 행의 위치가 변경되어 다시 실행할 수 없습니다.'
+                ));
+                return false;
+            }
+        }
+        for (i = 0; i < records.length; i += 1) {
+            record = records[i];
+            reference = record.nextSibling && record.nextSibling.parentNode === record.parent ?
+                record.nextSibling : (record.parent.rows[record.sectionIndex] || null);
+            record.parent.insertBefore(record.row, reference);
+        }
+        this.refresh();
+        this._notifyRowsChange(records, meta);
+        return true;
+    };
+
+    Grid.prototype.undo = function () {
+        var entry;
+        var changes = [];
+        var original;
+        var i;
+
+        this._assertActive();
+
+        if (!this.undoStack.length) {
+            return false;
+        }
+        entry = this.undoStack[this.undoStack.length - 1];
+        if (entry.kind === 'rows') {
+            if (!this._undoDeletedRows(entry)) {
+                return false;
+            }
+            this.undoStack.pop();
+            this.redoStack.push(entry);
+            return true;
+        }
+        if (entry.kind === 'addedRows') {
+            if (!this._removePasteAddedRows(entry)) {
+                return false;
+            }
+            this.undoStack.pop();
+            this.redoStack.push(entry);
+            this._restoreSelection(entry.selectionBefore, true);
+            return true;
+        }
+        if (entry.addedRows) {
+            for (i = 0; i < entry.addedRows.length; i += 1) {
+                if (entry.addedRows[i].row.parentNode !== entry.addedRows[i].parent) {
+                    this._reportError(new Error(
+                        'VirtualExcelTable: 자동 추가된 행 구조가 변경되어 되돌릴 수 없습니다.'
+                    ));
+                    return false;
+                }
+            }
+        }
+        for (i = entry.changes.length - 1; i >= 0; i -= 1) {
+            original = entry.changes[i];
+            if (contains(this.table, original.cell)) {
+                if (this._isReadOnly(original.cell)) {
+                    this._reportError(new Error(
+                        'VirtualExcelTable: 읽기 전용으로 변경된 셀이 있어 되돌릴 수 없습니다.'
+                    ));
+                    return false;
+                }
+                changes.push({
+                    cell: original.cell,
+                    oldValue: this._readValue(original.cell),
+                    newValue: original.oldValue
+                });
+            }
+        }
+        if (!this._applyChanges(changes, { type: 'undo', originalType: entry.type })) {
+            return false;
+        }
+        if (entry.addedRows && !this._removePasteAddedRows(entry)) {
+            return false;
+        }
+        this.undoStack.pop();
+        this.redoStack.push(entry);
+        this._restoreSelection(entry.selectionBefore, true);
+        return true;
+    };
+
+    Grid.prototype.redo = function () {
+        var entry;
+        var changes = [];
+        var original;
+        var i;
+
+        this._assertActive();
+
+        if (!this.redoStack.length) {
+            return false;
+        }
+        entry = this.redoStack[this.redoStack.length - 1];
+        if (entry.kind === 'rows') {
+            if (!this._redoDeletedRows(entry)) {
+                return false;
+            }
+            this.redoStack.pop();
+            this.undoStack.push(entry);
+            return true;
+        }
+        if (entry.kind === 'addedRows') {
+            if (!this._restorePasteAddedRows(entry)) {
+                return false;
+            }
+            this.redoStack.pop();
+            this.undoStack.push(entry);
+            this._restoreSelection(entry.selectionAfter, true);
+            return true;
+        }
+        if (entry.addedRows && !this._restorePasteAddedRows(entry)) {
+            return false;
+        }
+        for (i = 0; i < entry.changes.length; i += 1) {
+            original = entry.changes[i];
+            if (contains(this.table, original.cell)) {
+                if (this._isReadOnly(original.cell)) {
+                    this._reportError(new Error(
+                        'VirtualExcelTable: 읽기 전용으로 변경된 셀이 있어 다시 실행할 수 없습니다.'
+                    ));
+                    return false;
+                }
+                changes.push({
+                    cell: original.cell,
+                    oldValue: this._readValue(original.cell),
+                    newValue: original.newValue
+                });
+            }
+        }
+        if (!this._applyChanges(changes, { type: 'redo', originalType: entry.type })) {
+            if (entry.addedRows) {
+                this._removePasteAddedRows(entry);
+            }
+            return false;
+        }
+        this.redoStack.pop();
+        this.undoStack.push(entry);
+        this._restoreSelection(entry.selectionAfter, true);
+        return true;
+    };
+
+    Grid.prototype.canUndo = function () {
+        return this.undoStack.length > 0;
+    };
+
+    Grid.prototype.canRedo = function () {
+        return this.redoStack.length > 0;
+    };
+
+    Grid.prototype.destroy = function () {
+        var i;
+
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        this.table.removeEventListener('mousedown', this.handlers.mousedown, false);
+        this.table.removeEventListener('dblclick', this.handlers.dblclick, false);
+        this.table.removeEventListener('mouseover', this.handlers.mouseover, false);
+        this.table.removeEventListener('focusin', this.handlers.focusin, false);
+        this.table.removeEventListener('focusout', this.handlers.focusout, false);
+        this.table.removeEventListener('keydown', this.handlers.keydown, false);
+        this.table.removeEventListener('paste', this.handlers.paste, false);
+        this.table.removeEventListener('copy', this.handlers.copy, false);
+        document.removeEventListener('mouseup', this.handlers.mouseup, false);
+
+        for (i = 0; i < this.knownCells.length; i += 1) {
+            removeClass(this.knownCells[i], CELL_CLASS);
+            removeClass(this.knownCells[i], SELECTED_CLASS);
+            removeClass(this.knownCells[i], ACTIVE_CLASS);
+            removeClass(this.knownCells[i], READONLY_CLASS);
+        }
+        for (i = 0; i < this.knownHeaders.length; i += 1) {
+            removeClass(this.knownHeaders[i], HEADER_CLASS);
+            removeClass(this.knownHeaders[i], HEADER_SELECTED_CLASS);
+        }
+        removeClass(this.table, TABLE_CLASS);
+        removeClass(this.table, DRAGGING_CLASS);
+
+        if (this.originalTabIndex === null) {
+            this.table.removeAttribute('tabindex');
+        } else {
+            this.table.setAttribute('tabindex', this.originalTabIndex);
+        }
+        if (this.originalDataEnabled === null) {
+            this.table.removeAttribute('data-virtual-excel-table');
+        } else {
+            this.table.setAttribute('data-virtual-excel-table', this.originalDataEnabled);
+        }
+
+        this.selectedCells = [];
+        this.selectedHeaders = [];
+        this.selectionType = 'cells';
+        this._clearEditState();
+        this.undoStack = [];
+        this.redoStack = [];
+        this.knownCells = [];
+        this.knownHeaders = [];
+        if (this.table[INSTANCE_KEY] === this) {
+            try {
+                delete this.table[INSTANCE_KEY];
+            } catch (ignore) {
+                this.table[INSTANCE_KEY] = null;
+            }
+        }
+    };
+
+    function attachOne(table, options) {
+        ensureTable(table);
+        if (table[INSTANCE_KEY] && !table[INSTANCE_KEY].destroyed) {
+            return table[INSTANCE_KEY];
+        }
+        table[INSTANCE_KEY] = new Grid(table, options);
+        return table[INSTANCE_KEY];
+    }
+
+    function VirtualExcelTable(target, options) {
+        var tables = resolveTables(target);
+
+        if (tables.length === 0) {
+            throw new Error('VirtualExcelTable: 셀렉터에 해당하는 테이블을 찾지 못했습니다.');
+        }
+        if (tables.length > 1) {
+            throw new Error('VirtualExcelTable: 여러 테이블에는 VirtualExcelTable.attachAll()을 사용하세요.');
+        }
+        return attachOne(tables[0], options);
+    }
+
+    VirtualExcelTable.attach = VirtualExcelTable;
+    VirtualExcelTable.attachAll = function (target, options) {
+        var tables = resolveTables(target);
+        var instances = [];
+        var i;
+
+        for (i = 0; i < tables.length; i += 1) {
+            instances.push(attachOne(tables[i], options));
+        }
+        return instances;
+    };
+    VirtualExcelTable.parseClipboardText = parseClipboardText;
+    VirtualExcelTable.version = VERSION;
+
+    return VirtualExcelTable;
+}));