@progress/kendo-spreadsheet-common 1.1.3-develop.1 → 1.1.3-develop.3

package/dist/index-esm.js

@@ -1165,66 +1165,36 @@ function withExit(f, obj) {
     }
 }
 
-const wrapExpression = function(members, paramName) {
-    let result = paramName || "d",
-        index,
-        idx,
-        length,
-        member,
-        count = 1;
-
-    for (idx = 0, length = members.length; idx < length; idx++) {
-        member = members[idx];
-        if (member !== "") {
-            index = member.indexOf("[");
-
-            if (index !== 0) {
-                if (index === -1) {
-                    member = "." + member;
-                } else {
-                    count++;
-                    member = "." + member.substring(0, index) + " || {})" + member.substring(index);
-                }
-            }
-
-            count++;
-            result += member + ((idx < length - 1) ? " || {})" : ")");
-        }
-    }
-    return new Array(count).join("(") + result;
-};
-
 const getterCache = {};
 
-function expr(expression, safe, paramName) {
-    expression = expression || "";
-
-    if (typeof safe == 'string') {
-        paramName = safe;
-        safe = false;
-    }
+getterCache["undefined"] = (obj) => obj;
 
-    paramName = paramName || "d";
+const FIELD_REGEX = /\[(?:(\d+)|['"](.*?)['"])\]|((?:(?!\[.*?\]|\.).)+)/g;
+function getter(field, safe) {
+    const key = field + safe;
 
-    if (expression && expression.charAt(0) !== "[") {
-        expression = "." + expression;
+    if (getterCache[key]) {
+        return getterCache[key];
     }
 
-    if (safe) {
-        expression = expression.replace(/"([^.]*)\.([^"]*)"/g,'"$1_$DOT$_$2"');
-        expression = expression.replace(/'([^.]*)\.([^']*)'/g,"'$1_$DOT$_$2'");
-        expression = wrapExpression(expression.split("."), paramName);
-        expression = expression.replace(/_\$DOT\$_/g, ".");
-    } else {
-        expression = paramName + expression;
-    }
+    const fields = [];
+    field.replace(FIELD_REGEX, (_, index, indexAccessor, field) => {
+        fields.push(isPresent(index) ? index : indexAccessor || field);
+        return undefined;
+    });
 
-    return expression;
-}
+    getterCache[key] = (obj) => {
+        let result = obj;
+        for (let idx = 0; idx < fields.length; idx++) {
+            result = result[fields[idx]];
+            if (!isPresent(result) && safe) {
+                return result;
+            }
+        }
+
+        return result;
+    };
 
-function getter(expression, safe) {
-    let key = expression + safe;
-    getterCache[key] = getterCache[key] || new Function("d", "return " + expr(expression, safe));
     return getterCache[key];
 }
 
@@ -1239,10 +1209,6 @@ function deepExtend(destination) {
     return destination;
 }
 
-function isFunction(fn) {
-    return typeof fn === "function";
-}
-
 function deepExtendOne(destination, source) {
     let property,
         propValue,
@@ -1316,7 +1282,12 @@ const scrollbar = function(refresh) {
     let div = document.createElement("div"),
         result;
 
-    div.style.cssText = "overflow:scroll;overflow-x:hidden;zoom:1;clear:both;display:block";
+    div.style.overflow = "scroll";
+    div.style.overflowX = "hidden";
+    div.style.zoom = "1";
+    div.style.clear = "both";
+    div.style.display = "block";
+
     div.innerHTML = "&nbsp;";
     document.body.appendChild(div);
 
@@ -1391,6 +1362,13 @@ const _activeElement$1 = function() {
     }
 };
 
+const isPresent = (value) => value !== null && value !== undefined;
+const isBlank = (value) => !isPresent(value);
+const isDate = (value) => value && value.getTime;
+const isString = (value) => typeof value === "string";
+const isNumeric = (value) => !isNaN(value - parseFloat(value));
+const isFunction = (fn) => typeof fn === "function";
+
 class CalcError {
 
     constructor(code) {
@@ -2485,13 +2463,13 @@ function compileArgumentChecks(functionName, args) {
     }
 }
 
-function limitPrecision$1(num) {
-    return num === parseInt(num, 10) ? num : +num.toPrecision(16);
+function limitPrecision$1(num, digits) {
+    return num === parseInt(num, 10) ? num : +num.toPrecision(digits || 16);
 }
 
-function maybeRoundFloatErrors(num) {
+function maybeRoundFloatErrors(num, digits) {
     if (typeof num == "number") {
-        return limitPrecision$1(num);
+        return limitPrecision$1(num, digits);
     } else {
         return num;
     }
@@ -5650,6 +5628,10 @@ class FormulaContext {
                 // try global name
                 val = this.workbook.nameValue(this._displayString(ref.name));
             }
+            if (val == null) {
+                // try without _displayString
+                val = this.workbook.nameValue(ref.print()) || this.workbook.nameValue(ref.name);
+            }
         }
         if (val instanceof Ref) {
             val = val.absolute(frow, fcol);
@@ -8868,6 +8850,7 @@ let Range$1 = class Range {
                 sheet._set(ref, propName, propValue);
             };
 
+            let isValue = false;
             for (ci = topLeftCol; ci <= bottomRightCol; ci ++) {
                 if (!isAutofill && sheet.isHiddenColumn(ci)) {
                     continue;
@@ -8883,12 +8866,14 @@ let Range$1 = class Range {
                     if (row) {
                         data = row[ci - topLeftCol];
                         if (data) {
-                            Object.keys(data).forEach(setProp);
+                            const keys = Object.keys(data);
+                            keys.forEach(setProp);
+                            isValue = isValue || keys.includes("value");
                         }
                     }
                 }
             }
-            sheet.triggerChange({ recalc: true, ref: this._ref });
+            sheet.triggerChange({ recalc: true, ref: this._ref, isValue: isValue });
             return this;
         }
     }
@@ -8901,7 +8886,8 @@ let Range$1 = class Range {
 
         let reason = {
             recalc: clearAll || options.contentsOnly,
-            ref: this._ref
+            ref: this._ref,
+            isValue: true
         };
 
         sheet.batch(function() {
@@ -9398,13 +9384,18 @@ function looksLikeANumber(str) {
 
 function getTextHeight(text, width, fontFamily, fontSize, wrap) {
     const measureBox = document.createElement("div");
-    measureBox.setAttribute(
-        "style",
-        "position: absolute !important; top: -4000px !important; height: auto !important;" +
-            "padding: 1px 3px !important; box-sizing: border-box; margin: 0 !important; border: 1px solid black !important;" +
-            "line-height: normal !important; visibility: hidden !important;" +
-            "white-space: pre-wrap;"
-    );
+
+    measureBox.style.setProperty('position', 'absolute', 'important');
+    measureBox.style.setProperty('top', '-4000px', 'important');
+    measureBox.style.setProperty('height', 'auto', 'important');
+    measureBox.style.setProperty('padding', '1px 3px', 'important');
+    measureBox.style.setProperty('box-sizing', 'border-box', 'important');
+    measureBox.style.setProperty('margin', '0', 'important');
+    measureBox.style.setProperty('border', '1px solid black', 'important');
+    measureBox.style.setProperty('line-height', 'normal', 'important');
+    measureBox.style.setProperty('visibility', 'hidden', 'important');
+    measureBox.style.setProperty('white-space', 'pre-wrap');
+
     let styles = {
         "baselineMarkerSize" : 0,
         "width" : (wrap === true) ? width + "px" : "auto",
@@ -12119,210 +12110,131 @@ const kendoDate = (function() {
 
 /* eslint-disable no-var */
 
-const dateRegExp = /^\/Date\((.*?)\)\/$/;
+const logic = {
+    or: {
+        concat: (acc, fn) => (a) => acc(a) || fn(a),
+        identity: () => false,
+    },
+    and: {
+        concat: (acc, fn) => (a) => acc(a) && fn(a),
+        identity: () => true,
+    },
+};
+
+const operatorsMap = {
+    contains: (a, b) => (a || "").indexOf(b) >= 0,
+    doesnotcontain: (a, b) => (a || "").indexOf(b) === -1,
+    doesnotendwith: (a, b) =>
+        (a || "").indexOf(b, (a || "").length - (b || "").length) < 0,
+    doesnotstartwith: (a, b) => (a || "").lastIndexOf(b, 0) === -1,
+    endswith: (a, b) =>
+        (a || "").indexOf(b, (a || "").length - (b || "").length) >= 0,
+    eq: (a, b) => a === b,
+    gt: (a, b) => a > b,
+    gte: (a, b) => a >= b,
+    isempty: (a) => a === "",
+    isnotempty: (a) => a !== "",
+    isnotnull: (a) => isPresent(a),
+    isnull: (a) => isBlank(a),
+    lt: (a, b) => a < b,
+    lte: (a, b) => a <= b,
+    neq: (a, b) => a != b, // tslint:disable-line:triple-equals
+    startswith: (a, b) => (a || "").lastIndexOf(b, 0) === 0,
+};
 
-var operators = (function() {
+const dateRegExp = /^\/Date\((.*?)\)\/$/;
 
-    function quote(str) {
-        if (typeof str == "string") {
-            str = str.replace(/[\r\n]+/g, "");
+const convertValue = (value, ignoreCase, accentFoldingFiltering) => {
+    if (value != null && isString(value)) {
+        const date = dateRegExp.exec(value);
+        if (date) {
+            return new Date(+date[1]).getTime();
+        } else if (ignoreCase) {
+            return accentFoldingFiltering
+                ? value.toLocaleLowerCase(accentFoldingFiltering)
+                : value.toLowerCase();
         }
-        return JSON.stringify(str);
+    } else if (value != null && isDate(value)) {
+        return value.getTime();
     }
+    return value;
+};
 
-    function textOp(impl) {
-        return function(a, b, ignore, accentFoldingFiltering) {
-            b += "";
-            if (ignore) {
-                a = "(" + a + " + '').toString()" + ((accentFoldingFiltering) ? ".toLocaleLowerCase('" + accentFoldingFiltering + "')" : ".toLowerCase()");
-                b = ((accentFoldingFiltering) ? b.toLocaleLowerCase(accentFoldingFiltering) : b.toLowerCase());
-            }
-            return impl(a, quote(b), ignore);
-        };
-    }
+const transformFilter = ({
+    field,
+    ignoreCase,
+    value,
+    operator,
+    accentFoldingFiltering,
+}) => {
+    field = !isPresent(field) ? (a) => a : field;
+
+    ignoreCase = isPresent(ignoreCase) ? ignoreCase : true;
+
+    const itemProp = typedGetter(
+        isFunction(field) ? field : getter(field, true),
+        value,
+        ignoreCase,
+        accentFoldingFiltering
+    );
 
-    function operator(op, a, b, ignore, accentFoldingFiltering) {
-        if (b != null) {
-            if (typeof b === 'string') {
-                var date = dateRegExp.exec(b);
-                if (date) {
-                    b = new Date(+date[1]);
-                } else if (ignore) {
-                    b = quote(((accentFoldingFiltering) ? b.toLocaleLowerCase(accentFoldingFiltering) : b.toLowerCase()));
-                    a = "((" + a + " || '')+'')" + ((accentFoldingFiltering) ? ".toLocaleLowerCase('" + accentFoldingFiltering + "')" : ".toLowerCase()");
-                } else {
-                    b = quote(b);
-                }
-            }
+    value = convertValue(value, ignoreCase, accentFoldingFiltering);
 
-            if (b.getTime) {
-                //b looks like a Date
-                a = "(" + a + "&&" + a + ".getTime?" + a + ".getTime():" + a + ")";
-                b = b.getTime();
-            }
-        }
+    const op = isFunction(operator) ? operator : operatorsMap[operator];
 
-        return a + " " + op + " " + b;
-    }
+    return (a) => op(itemProp(a), value, ignoreCase);
+};
 
-    function getMatchRegexp(pattern) {
-        // take a pattern, as supported by Excel match filter, and
-        // convert it to the equivalent JS regular expression.
-        // Excel patterns support:
-        //
-        //   * - match any sequence of characters
-        //   ? - match a single character
-        //
-        // to match a literal * or ?, they must be prefixed by a tilde (~)
-        var rx = "/^";
-        for (var esc = false, i = 0; i < pattern.length; ++i) {
-            var ch = pattern.charAt(i);
-            if (esc) {
-                rx += "\\" + ch;
-            } else if (ch === "~") {
-                esc = true;
-                continue;
-            } else if (ch === "*") {
-                rx += ".*";
-            } else if (ch === "?") {
-                rx += ".";
-            } else if (".+^$()[]{}|\\/\n\r\u2028\u2029\xA0".indexOf(ch) >= 0) {
-                rx += "\\" + ch;
-            } else {
-                rx += ch;
-            }
-            esc = false;
-        }
-        return rx + "$/";
+const typedGetter = (prop, value, ignoreCase, accentFoldingFiltering) => {
+    if (!isPresent(value)) {
+        return prop;
     }
 
-    return {
-        quote: function(value) {
-            if (value && value.getTime) {
-                return "new Date(" + value.getTime() + ")";
-            }
-            return quote(value);
-        },
-        eq: function(a, b, ignore, accentFoldingFiltering) {
-            return operator("==", a, b, ignore, accentFoldingFiltering);
-        },
-        neq: function(a, b, ignore, accentFoldingFiltering) {
-            return operator("!=", a, b, ignore, accentFoldingFiltering);
-        },
-        gt: function(a, b, ignore) {
-            return operator(">", a, b, ignore);
-        },
-        gte: function(a, b, ignore) {
-            return operator(">=", a, b, ignore);
-        },
-        lt: function(a, b, ignore) {
-            return operator("<", a, b, ignore);
-        },
-        lte: function(a, b, ignore) {
-            return operator("<=", a, b, ignore);
-        },
-        startswith: textOp(function(a, b) {
-            return a + ".lastIndexOf(" + b + ", 0) == 0";
-        }),
-        doesnotstartwith: textOp(function(a, b) {
-            return a + ".lastIndexOf(" + b + ", 0) == -1";
-        }),
-        endswith: textOp(function(a, b) {
-            var n = b ? b.length - 2 : 0;
-            return a + ".indexOf(" + b + ", " + a + ".length - " + n + ") >= 0";
-        }),
-        doesnotendwith: textOp(function(a, b) {
-            var n = b ? b.length - 2 : 0;
-            return a + ".indexOf(" + b + ", " + a + ".length - " + n + ") < 0";
-        }),
-        contains: textOp(function(a, b) {
-            return a + ".indexOf(" + b + ") >= 0";
-        }),
-        doesnotcontain: textOp(function(a, b) {
-            return a + ".indexOf(" + b + ") == -1";
-        }),
-        matches: textOp(function(a, b) {
-            b = b.substring(1, b.length - 1);
-            return getMatchRegexp(b) + ".test(" + a + ")";
-        }),
-        doesnotmatch: textOp(function(a, b) {
-            b = b.substring(1, b.length - 1);
-            return "!" + getMatchRegexp(b) + ".test(" + a + ")";
-        }),
-        isempty: function(a) {
-            return a + " === ''";
-        },
-        isnotempty: function(a) {
-            return a + " !== ''";
-        },
-        isnull: function(a) {
-            return "(" + a + " == null)";
-        },
-        isnotnull: function(a) {
-            return "(" + a + " != null)";
-        },
-        isnullorempty: function(a) {
-            return "(" + a + " === null) || (" + a + " === '')";
-        },
-        isnotnullorempty: function(a) {
-            return "(" + a + " !== null) && (" + a + " !== '')";
-        }
-    };
-})();
-
-const filterExpr = function(expression) {
-    var expressions = [],
-        logic = { and: " && ", or: " || " },
-        idx,
-        length,
-        filter,
-        expr$1,
-        fieldFunctions = [],
-        operatorFunctions = [],
-        field,
-        operator,
-        filters = expression.filters;
-
-    for (idx = 0, length = filters.length; idx < length; idx++) {
-        filter = filters[idx];
-        field = filter.field;
-        operator = filter.operator;
-
-        if (filter.filters) {
-            expr$1 = filterExpr(filter);
-            //Nested function fields or operators - update their index e.g. __o[0] -> __o[1]
-            filter = expr$1.expression
-            .replace(/__o\[(\d+)\]/g, function(match, index) {
-                index = +index;
-                return "__o[" + (operatorFunctions.length + index) + "]";
-            })
-            .replace(/__f\[(\d+)\]/g, function(match, index) {
-                index = +index;
-                return "__f[" + (fieldFunctions.length + index) + "]";
-            });
+    let acc = prop;
 
-            operatorFunctions.push.apply(operatorFunctions, expr$1.operators);
-            fieldFunctions.push.apply(fieldFunctions, expr$1.fields);
+    if (isString(value)) {
+        const date = dateRegExp.exec(value);
+        if (date) {
+            value = new Date(+date[1]);
         } else {
-            if (typeof field === 'function') {
-                expr$1 = "__f[" + fieldFunctions.length + "](d)";
-                fieldFunctions.push(field);
-            } else {
-                expr$1 = expr(field);
-            }
-
-            if (typeof operator === 'function') {
-                filter = "__o[" + operatorFunctions.length + "](" + expr$1 + ", " + operators.quote(filter.value) + ")";
-                operatorFunctions.push(operator);
-            } else {
-                filter = operators[(operator || "eq").toLowerCase()](expr$1, filter.value, filter.ignoreCase !== undefined ? filter.ignoreCase : true, expression.accentFoldingFiltering);
-            }
+            acc = (a) => {
+                const x = prop(a);
+                if (typeof x === "string" && ignoreCase) {
+                    return accentFoldingFiltering
+                        ? x.toLocaleLowerCase(accentFoldingFiltering)
+                        : x.toLowerCase();
+                } else {
+                    return isNumeric(x) ? x + "" : x;
+                }
+            };
         }
+    }
 
-        expressions.push(filter);
+    if (isDate(value)) {
+        return (a) => {
+            const x = acc(a);
+            return isDate(x) ? x.getTime() : x;
+        };
     }
+    return acc;
+};
 
-    return { expression: "(" + expressions.join(logic[expression.logic]) + ")", fields: fieldFunctions, operators: operatorFunctions };
+const transformCompositeFilter = function (filter) {
+    const accentFoldingFiltering = filter.accentFoldingFiltering;
+    const combiner = logic[filter.logic || "and"];
+
+    return filter.filters
+        .filter(isPresent)
+        .map((x) => {
+            const extendedFilter = isPresent(accentFoldingFiltering)
+                ? deepExtend({}, x, { accentFoldingFiltering })
+                : x;
+
+            return isPresent(x.filters)
+                ? transformCompositeFilter(extendedFilter)
+                : transformFilter(extendedFilter);
+        })
+        .reduce(combiner.concat, combiner.identity);
 };
 
 /* eslint-disable max-params */
@@ -12437,13 +12349,11 @@ class CustomFilter extends Filter {
 
         this._criteria = options.criteria;
 
-        var expression = filterExpr({
+        this._matches = transformCompositeFilter({
             logic: this._logic,
             filters: this._criteria,
-            accentFoldingFiltering: culture().name
-        }).expression;
-
-        this._matches = new Function("d", "return " + expression);
+            accentFoldingFiltering: culture().name,
+        });
     }
     matches(value) {
         if (value === null) {
@@ -16172,7 +16082,7 @@ function drawCell(collection, cell, cls, showGrid) {
         if (data.__dataType) {
             type = data.__dataType;
         }
-    } else if (data !== null && data !== undefined) {
+    } else if (data != null) {
         if (cell.html) {
             data = dom.html(data);
         } else {
@@ -16207,6 +16117,17 @@ function drawCell(collection, cell, cls, showGrid) {
     }
     if (cell.merged) {
         classNames.push("k-spreadsheet-merged-cell");
+        if (!cell.enable) {
+            collection.push(dom.element("div", {
+                className: "k-spreadsheet-disabled-mask",
+                style: {
+                    left: (cell.left + 1) + "px",
+                    top: (cell.top + 1) + "px",
+                    width: (cell.width - 1) + "px",
+                    height: (cell.height - 1) + "px"
+                }
+            }));
+        }
     }
     if (cell.comment) {
         classNames.push("k-spreadsheet-has-comment");
@@ -17008,24 +16929,9 @@ class FormulaInput extends Widget {
             end = begin;
         }
         if (begin && end) {
-            let range = document.createRange();
-            range.setStart(begin.node, begin.pos);
-            range.setEnd(end.node, end.pos);
-            let sel = window.getSelection();
-            let currentRange = sel.getRangeAt(0);
-            if (differ(range, currentRange))  {
-                sel.removeAllRanges();
-                sel.addRange(range);
-            }
-        }
-        function differ(a, b) {
-            return (
-                a.startOffset !== b.startOffset ||
-                a.endOffset !== b.endOffset ||
-                a.startContainer !== b.endContainer ||
-                a.endContainer !== b.endContainer
-            );
+            this._setRange(begin, end);
         }
+
         function lookup(node, pos) {
             try {
                 (function loop(node) {
@@ -17063,6 +16969,27 @@ class FormulaInput extends Widget {
         return this.value().length;
     }
 
+    _setRange(begin, end) {
+        let range = document.createRange();
+        range.setStart(begin.node, begin.pos);
+        range.setEnd(end.node, end.pos);
+        let sel = window.getSelection();
+        let currentRange = sel.getRangeAt(0);
+        if (differ(range, currentRange))  {
+            sel.removeAllRanges();
+            sel.addRange(range);
+        }
+
+        function differ(a, b) {
+            return (
+                a.startOffset !== b.startOffset ||
+                a.endOffset !== b.endOffset ||
+                a.startContainer !== b.endContainer ||
+                a.endContainer !== b.endContainer
+            );
+        }
+    }
+
     _formulaSource() {
         let result = [];
         let value;
@@ -17813,27 +17740,43 @@ function addCell(table, row, cell) {
         }
     }
 
+    let attrs = { style: style };
+
     if (!style.textAlign) {
         switch (type) {
-        case "number":
-        case "date":
-        case "percent":
-        case "currency":
-            style.textAlign = "right";
-            break;
-        case "boolean":
-            style.textAlign = "center";
+            case "number":
+            case "date":
+            case "percent":
+            case "currency":
+                style.textAlign = "right";
+                break;
+            case "boolean":
+                style.textAlign = "center";
             break;
         }
     }
 
+    if (!/^(?:string|undefined)$/.test(type)) {
+        // provide original value and number format for better
+        // interoperability with google sheets and libre office.
+        attrs.sdval = cell.value;
+        attrs["data-sheets-value"] = JSON.stringify({ 1: 3, 3: cell.value });
+        if (format) {
+            attrs.sdnum = format;
+            attrs["data-sheets-numberformat"] = JSON.stringify({ 1: 2, 2: format, 3: 1 });
+        }
+    }
+    if (cell.formula) {
+        attrs["data-sheets-formula"] = "=" + cell.formula.print();
+    }
+
     let className = null;
 
     if (cell.enable === false) {
         className = "k-disabled";
     }
 
-    let td = table.addCell(row, data, style, className, cell.validation);
+    let td = table.addCell(row, data, attrs, className, cell.validation);
 
     let border, sibling;
 
@@ -17892,7 +17835,7 @@ class HtmlTable {
         this.trs.push(tr);
     }
 
-    addCell(rowIndex, text, style, className, validation) {
+    addCell(rowIndex, text, attrs, className, validation) {
         if (text === null || text === undefined) {
             text = "";
         }
@@ -17901,19 +17844,18 @@ class HtmlTable {
         }
 
         let children = [ text ];
-        let properties = { style: style };
 
         if (validation && !validation.value) {
             children.push(dom.element("span", { className: "k-dirty" }));
 
             className = (className || "") + (className ? " " : "") + "k-dirty-cell";
-            properties.title = validation.message;
+            attrs.title = validation.message;
         }
 
         if (className) {
-            properties.className = className;
+            attrs.className = className;
         }
-        let td = dom.element("td", properties, children);
+        let td = dom.element("td", attrs, children);
 
         this.trs[rowIndex].children.push(td);
         return td;
@@ -18906,7 +18848,13 @@ function stripStyle(style) {
     return style.replace(/^-(?:ms|moz|webkit)-/, "");
 }
 
-function borderObject(styles) {
+function borderObject(element, styles) {
+    // MS Office uses class name and writes borders in the <style> section, so for it we need to
+    // use the computed styles.  For Google Sheets / LibreOffice, however, the inline styles are
+    // more accurate.
+    if (!element.className) {
+        styles = element.style;
+    }
     let obj = {};
     [
         "borderBottom",
@@ -18914,16 +18862,45 @@ function borderObject(styles) {
         "borderLeft",
         "borderTop"
     ].forEach(function(key) {
-        obj[key] = styles[key + "Style"] === "none" ? null : {
-            size: 1,
-            color: styles[key + "Color"]
-        };
+        let width = styles[key + "Width"];
+        if (width) {
+            width = parseInt(width, 10);
+        }
+        if (width) {
+            obj[key] = {
+                size: width,
+                color: styles[key + "Color"] || "#000"
+            };
+        }
     });
     return obj;
 }
 
 function cellState(row, col, element, hBorders, vBorders) {
     let styles = window.getComputedStyle(element);
+    let value, format, formula;
+
+    // google sheets
+    if ((value = element.getAttribute("data-sheets-value"))) {
+        value = JSON.parse(value);
+        value = value[value[1]];
+    }
+    if ((format = element.getAttribute("data-sheets-numberformat"))) {
+        format = JSON.parse(format);
+        format = format[format[1]];
+    }
+    formula = element.getAttribute("data-sheets-formula");
+
+    // libre office
+    if (value == null && format == null && formula == null) {
+        value = element.getAttribute("sdval");
+        format = element.getAttribute("sdnum");
+        if (format) {
+            // for ungoogable reasons, libreoffice prepends format strings with
+            // "1033;" and sometimes with "1033;0;". discard it below.
+            format = format.replace(/^1033;(?:0;)?/, "");
+        }
+    }
 
     // note: Chrome 70 appends a \t to a cell's text, which is actually mandated by the standard
     // ([1] item 6).  We remove it below.  In [2] it's suggested they might switch back to
@@ -18931,49 +18908,62 @@ function cellState(row, col, element, hBorders, vBorders) {
     //
     // [1] https://www.w3.org/TR/html53/dom.html#dom-htmlelement-innertext
     // [2] https://bugs.chromium.org/p/chromium/issues/detail?id=897373
-    let text = (element.innerText || element.textContent).replace(/\t$/, "");
+    if (value == null) {
+        value = (element.innerText || element.textContent).replace(/\t$/, "");
+    }
 
-    let borders = borderObject(styles);
+    let borders = borderObject(element, styles);
     let state = {
-        value: text === "" ? null : text,
+        value: value === "" ? null : value,
+        formula: formula,
 
         borderTop: borders.borderTop || hBorders.get(row, col) || null,
         borderBottom: borders.borderBottom || hBorders.get(row + 1, col) || null,
         borderLeft: borders.borderLeft || vBorders.get(row, col) || null,
         borderRight: borders.borderRight || vBorders.get(row, col + 1) || null,
 
-        fontSize: parseInt(styles["font-size"], 10)
+        fontSize: parseInt(styles["fontSize"], 10)
     };
 
+    if (format != null) {
+        state.format = format;
+    }
+
     hBorders.set(row, col, state.borderTop);
     hBorders.set(row + 1, col, state.borderBottom);
     vBorders.set(row, col, state.borderLeft);
     vBorders.set(row, col + 1, state.borderRight);
 
-    if (styles["background-color"] !== "rgb(0, 0, 0)" && styles["background-color"] !== "rgba(0, 0, 0, 0)") {
-        state.background = styles["background-color"];
+    if (styles["backgroundColor"] !== "rgb(0, 0, 0)" && styles["backgroundColor"] !== "rgba(0, 0, 0, 0)") {
+        state.background = styles["backgroundColor"];
     }
+    if (stripStyle(styles["textAlign"]) !== "right") {
+        state.textAlign = stripStyle(styles["textAlign"]);
+    }
+    if (styles["verticalAlign"] !== "middle") {
+        state.verticalAlign = styles["verticalAlign"];
+    }
+    if (styles["wordWrap"] !== "normal" ) {
+        state.wrap = true;
+    }
+
+    const txtElem = element.querySelector("font"); // libre office
+    if (txtElem) {
+        styles = window.getComputedStyle(txtElem);
+    }
+
     if (styles.color !== "rgb(0, 0, 0)" && styles.color !== "rgba(0, 0, 0, 0)") {
         state.color = styles.color;
     }
-    if (styles["text-decoration"] === "underline") {
+    if (/^underline/.test(styles["textDecoration"])) {
         state.underline = true;
     }
-    if (styles["font-style"] === "italic") {
+    if (styles["fontStyle"] == "italic") {
         state.italic = true;
     }
-    if (styles["font-weight"] === "bold") {
+    if (/^(?:bold|[67]00)$/i.test(styles["fontWeight"])) {
         state.bold = true;
     }
-    if (stripStyle(styles["text-align"]) !== "right") {
-        state.textAlign = stripStyle(styles["text-align"]);
-    }
-    if (styles["vertical-align"] !== "middle") {
-        state.verticalAlign = styles["vertical-align"];
-    }
-    if (styles["word-wrap"] !== "normal" ) {
-        state.wrap = true;
-    }
 
     return state;
 }
@@ -20807,6 +20797,60 @@ const parseXML = function parseXML() {
     }
 };
 
+class Deferred {
+    constructor() {
+        this._progressHandlers = [];
+        this._resolved = false;
+        this._rejected = false;
+        this.promise = new window.Promise((resolve, reject) => {
+            this._resolve = (value) => {
+                if (!this._resolved && !this._rejected) {
+                    this._resolved = true;
+                    resolve(value);
+                }
+            };
+            this._reject = (reason) => {
+                if (!this._resolved && !this._rejected) {
+                    this._rejected = true;
+                    reject(reason);
+                }
+            };
+        });
+    }
+
+    resolve(value) {
+        this._resolve(value);
+        return this;
+    }
+
+    reject(reason) {
+        this._reject(reason);
+        return this;
+    }
+
+    notify(value) {
+        if (!this._resolved && !this._rejected) {
+            this._progressHandlers.forEach(handler => handler(value));
+        }
+    }
+
+    progress(callback) {
+        this._progressHandlers.push(callback);
+        return this;
+    }
+
+    then(onFulfilled, onRejected, onProgress) {
+        if (onProgress) {
+            this.progress(onProgress);
+        }
+        return this.promise.then(onFulfilled, onRejected);
+    }
+
+    promise() {
+        return this.promise;
+    }
+}
+
 /* eslint-disable complexity */
 
 // WARNING: removing the following jshint declaration and turning
@@ -20821,12 +20865,11 @@ let MAP_EXCEL_OPERATOR = {
 
 let ERROR_LOG = null;
 
-function readExcel(file, workbook) {
+function readExcel(file, workbook, deferred) {
     let reader = new FileReader();
-    reader.onload = function(e) {
-        JSZip.loadAsync(e.target.result).then(zip => {
-            readWorkbook(zip, workbook);
-        });
+    reader.onload = async function(e) {
+        JSZip.loadAsync(e.target.result)
+            .then(async zip => await readWorkbook(zip, workbook, deferred));
     };
 
     reader.readAsArrayBuffer(file);
@@ -20848,6 +20891,7 @@ let SEL_VALUE = ["sheetData", "row", "c", "v"];
 let SEL_VIEW = ["bookViews", "workbookView"];
 let SEL_SHEET_VIEW = ["sheetViews", "sheetView"];
 let SEL_HYPERLINK = ["hyperlinks", "hyperlink"];
+let SEL_PROTECTION = ["sheetProtection"];
 
 /* A validation section looks like this:
     *
@@ -20909,7 +20953,7 @@ function xl(file) {
     return file;
 }
 
-async function readWorkbook(zip, workbook) {
+async function readWorkbook(zip, workbook, progress) {
     ERROR_LOG = workbook.excelImportErrors = [];
 
     let strings = await readStrings(zip);
@@ -20926,6 +20970,10 @@ async function readWorkbook(zip, workbook) {
                 let file = relationships.byId[relId];
                 let name = attrs.name;
                 let state = attrs.state;
+                let dim = sheetDimensions(relationships.bytes[file]);
+
+                workbook.options.columnWidth = dim.columnWidth || workbook.options.columnWidth;
+                workbook.options.rowHeight = dim.rowHeight || workbook.options.rowHeight;
 
                 items.push({
                     workbook: workbook,
@@ -20935,7 +20983,11 @@ async function readWorkbook(zip, workbook) {
                     file: file,
                     options: {
                         state: state,
-                        name: name
+                        name: name,
+                        rows: Math.max(workbook.options.rows || 0, dim.rows),
+                        columns: Math.max(workbook.options.columns || 0, dim.cols),
+                        columnWidth: dim.columnWidth,
+                        rowHeight: dim.rowHeight
                     }
                 });
             } else if (this.is(SEL_VIEW)) {
@@ -20965,43 +21017,63 @@ async function readWorkbook(zip, workbook) {
         }
     });
 
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        const dim = await sheetDimensions(item.zip, item.file);
-        const { workbook } = item;
-
-        workbook.options.columnWidth = dim.columnWidth || workbook.options.columnWidth;
-        workbook.options.rowHeight = dim.rowHeight || workbook.options.rowHeight;
-
-        item.options = {
-            ...item.options,
-            rows: Math.max(workbook.options.rows || 0, dim.rows),
-            columns: Math.max(workbook.options.columns || 0, dim.cols),
-            columnWidth: dim.columnWidth,
-            rowHeight: dim.rowHeight
-        };
-    }
+    let loading = new Deferred();
+    loading.progress(function(args) {
+        if (progress) {
+            progress.notify(args);
+        }
+    })
+    .then(function() {
+        let sheets = workbook.sheets();
+        recalcSheets(sheets);
 
-    await loadSheets(items, workbook);
+        workbook.activeSheet(sheets[activeSheet]);
 
-    let sheets = workbook.sheets();
-    recalcSheets(sheets);
+        if (progress) {
+            progress.resolve();
+        }
+    });
 
-    workbook.activeSheet(sheets[activeSheet]);
+    loadSheets(items, workbook, loading);
 }
 
-async function loadSheets(items, workbook) {
+function loadSheets(items, workbook, progress) {
+    let ready = window.Promise.resolve();
     for (let i = 0; i < items.length; i++) {
-        const ctx = items[i];
-        let sheet = workbook.insertSheet(ctx.options);
+        (function(entry, i) {
+            ready = ready.then(function() {
+                let sheet = workbook.insertSheet(entry.options);
+                sheet.suspendChanges(true);
+
+                let promise = queueSheet(sheet, entry);
+                let args = {
+                    sheet: sheet,
+                    progress: i === 1 ? 1 : (i / (items.length - 1))
+                };
 
-        if (!sheet) {
-            continue;
-        }
+                promise.then(function() {
+                    progress.notify(args);
+                });
 
-        sheet.suspendChanges(true);
-        await readSheet(ctx.zip, ctx.file, sheet, ctx.strings, ctx.styles);
+                return promise;
+            });
+        })(items[i], i);
     }
+
+    ready.then(function() {
+        progress.resolve();
+    });
+}
+
+function queueSheet(sheet, ctx) {
+    let deferred = new Deferred();
+
+    setTimeout(async function() {
+        await readSheet(ctx.zip, ctx.file, sheet, ctx.strings, ctx.styles);
+        deferred.resolve();
+    }, 0);
+
+    return deferred;
 }
 
 function recalcSheets(sheets) {
@@ -21012,13 +21084,13 @@ function recalcSheets(sheets) {
     }
 }
 
-async function sheetDimensions(zip, file) {
+function sheetDimensions(bytes) {
     let ref, dim = {
             rows: 0,
             cols: 0
         };
 
-    await parse(zip, xl(file), {
+    parseXML(bytes, {
         enter: function(tag, attrs) {
             if (tag === "dimension") {
                 ref = calc.parseReference(attrs.ref);
@@ -21076,6 +21148,7 @@ async function readSheet(zip, file, sheet, strings, styles) {
     let valueFilterBlanks;
     let valueFilterValues;
     let filters = [];
+    let deferredStyles = [];
 
     ERROR_LOG = sheet._workbook.excelImportErrors;
 
@@ -21120,7 +21193,7 @@ async function readSheet(zip, file, sheet, strings, styles) {
 
                 let styleIndex = attrs.s;
                 if (styleIndex != null) {
-                    applyStyle(sheet, ref, styles, styleIndex);
+                    deferredStyles.push({ ref: ref,  sty: +styleIndex });
                 }
             } else if (this.is(SEL_MERGE)) {
                 sheet.range(attrs.ref).merge();
@@ -21141,10 +21214,13 @@ async function readSheet(zip, file, sheet, strings, styles) {
                 }
                 if (attrs.style != null) {
                     // apply style on a whole range of columns
-                    applyStyle(sheet, new RangeRef(
-                        new CellRef(-Infinity, start),
-                        new CellRef(+Infinity, stop)
-                    ), styles, attrs.style);
+                    deferredStyles.unshift({
+                        ref: new RangeRef(
+                            new CellRef(-Infinity, start),
+                            new CellRef(+Infinity, stop)
+                        ),
+                        sty: +attrs.style
+                    });
                 }
             } else if (this.is(SEL_ROW)) {
                 let row = integer(attrs.r) - 1;
@@ -21181,6 +21257,10 @@ async function readSheet(zip, file, sheet, strings, styles) {
                 if (target) {
                     sheet.range(attrs.ref).link(target);
                 }
+            } else if (this.is(SEL_PROTECTION)) {
+                if (attrs.sheet) {
+                    sheet.range(SHEETREF).enable(false);
+                }
             } else if (this.is(["autoFilter"])) {
                 filterRef = attrs.ref;
                 if (closed) {
@@ -21351,6 +21431,8 @@ async function readSheet(zip, file, sheet, strings, styles) {
         }
     });
 
+    deferredStyles.forEach(({ ref, sty }) => applyStyle(sheet, ref, styles, sty));
+
     if (relationships.byType.comments) {
         let commentFile = relative_file(file, relationships.byType.comments[0]);
         await readComments(zip, commentFile, sheet);
@@ -21401,12 +21483,14 @@ async function readDrawings(zip, file, sheet) {
     let relationships = await readRelationships(zip, relsFile);
 
     if (relationships.byType.image) {
-        for (const id of Object.keys(relationships.byId)) {
+        let relkeys = Object.keys(relationships.byId);
+        for (let i = 0; i < relkeys.length; ++i) {
+            let id = relkeys[i];
             let img = relative_file(file, relationships.byId[id]);
             let type = getContentType(img);
 
             if (type) {
-                let data = await zip.files[img].async("arrayBuffer");
+                let data = await zip.file(img).async("arraybuffer");
                 let name = getFileName(img);
                 let blob = name && !(browser.edge)
                     ? new window.File([ data ], name, { type: type })
@@ -21680,6 +21764,9 @@ function applyStyle(sheet, ref, styles, styleIndex) {
     if (shouldSet("applyNumberFormat", "numFmtId")) {
         setFormat(styles.numFmts[value] || DEFAULT_FORMATS[value]);
     }
+    if (shouldSet("applyProtection", "protection")) {
+        range.enable(!xf.protection.locked);
+    }
 
     function setFormat(f) {
         let format = typeof f == "string" ? f : f.formatCode;
@@ -21768,11 +21855,18 @@ function applyStyle(sheet, ref, styles, styleIndex) {
     }
 }
 
-async function parse(zip, file, callbacks) {
-    let part = zip.files[file];
-    if (part) {
-        await parseXML(await part.async("uint8array"), callbacks);
-    }
+function parse(zip, file, callbacks) {
+    return new window.Promise(resolve => {
+        let obj = zip.file(file);
+        if (obj) {
+            obj.async("uint8array").then(bytes => {
+                parseXML(bytes, callbacks);
+                resolve();
+            });
+        } else {
+            resolve();
+        }
+    });
 }
 
 async function readStrings(zip) {
@@ -21798,7 +21892,7 @@ async function readStrings(zip) {
 }
 
 async function readRelationships(zip, file) {
-    let map = { byId: {}, byType: { theme: [] } };
+    let map = { byId: {}, byType: { theme: [] }, bytes: {} };
     await parse(zip, xl(file) + ".rels", {
         enter: function(tag, attrs) {
             if (tag === "Relationship") {
@@ -21811,6 +21905,18 @@ async function readRelationships(zip, file) {
             }
         }
     });
+    let names = [];
+    let promises = [];
+    Object.keys(map.byId).forEach(id => {
+        let filename = map.byId[id];
+        let obj = zip.file(xl(filename));
+        if (obj) {
+            names.push(filename);
+            promises.push(obj.async("uint8array"));
+        }
+    });
+    let data = await window.Promise.all(promises);
+    names.forEach((name, i) => map.bytes[name] = data[i]);
     return map;
 }
 
@@ -21952,6 +22058,10 @@ async function readStyles(zip, theme) {
                     if (attrs.indent != null) {
                         xf.indent = integer(attrs.indent);
                     }
+                } else if (tag == "protection") {
+                    xf.protection = {
+                        locked: bool(attrs.locked)
+                    };
                 }
             }
         },
@@ -21983,10 +22093,12 @@ async function readStyles(zip, theme) {
         addBool("applyFill");
         addBool("applyFont");
         addBool("applyNumberFormat");
-        addBool("applyProtection");
+        if (addBool("applyProtection")) {
+            xf.protection = { locked: true };
+        }
         function addBool(name) {
             if (attrs[name] != null) {
-                xf[name] = bool(attrs[name]);
+                return xf[name] = bool(attrs[name]);
             }
         }
         return xf;
@@ -22035,7 +22147,7 @@ async function readTheme(zip, rel) {
     };
 
     let file = xl(rel);
-    if (zip.files[file]) {
+    if (zip.file(file)) {
         await parse(zip, file, {
             enter: function(tag, attrs) {
                 if (this.is(SEL_SCHEME_SYSCLR)) {
@@ -22766,10 +22878,18 @@ class Workbook extends Observable {
     }
 
     fromFile(file) {
-        if (file && !this.trigger("excelImport", { file })) {
+        const deferred = new Deferred();
+
+        if (file && !this.trigger("excelImport", { file, deferred })) {
             this._clearSheets();
-            readExcel(file, this);
+            this._readExcel(file, this, deferred);
         }
+
+        return deferred.promise;
+    }
+
+    _readExcel(file, workbook, deferred) {
+        readExcel(file, workbook, deferred);
     }
 
     saveAsExcel(options) {
@@ -24267,6 +24387,11 @@ function binaryCompare(left, right, func) {
         right = right.toLowerCase();
     }
     if (typeof right == typeof left) {
+        // for issue https://github.com/telerik/kendo-ui-core/issues/6879, limitPrecision
+        // digits got bumped to 16, but it's too much for the case 9.302 - 0.002 (issue
+        // https://github.com/telerik/kendo-ui-core/issues/7170).
+        left = maybeRoundFloatErrors(left, 15);
+        right = maybeRoundFloatErrors(right, 15);
         return func(left, right);
     } else {
         return new CalcError("VALUE");
@@ -32609,10 +32734,10 @@ defineBuiltinFunction('index', true, function () {
             }
         }
         if (ref.width == 1) {
-            return callback(ref.get(row - 1, 0));
+            return callback(ref.get((row || 1) - 1, 0));
         }
         if (ref.height == 1) {
-            return callback(ref.get(0, col - 1));
+            return callback(ref.get(0, (col || 1) - 1));
         }
     } else {
         callback(new CalcError('REF'));
@@ -43758,4 +43883,4 @@ const {
     defineAlias
 } = calc.runtime;
 
-export { CalcError, CellRef, Context, Matrix, NULLREF, NameRef, Range$1 as Range, RangeRef, Ref, Sheet, SpreadsheetWidget, UnionRef, View, Workbook, calc, dateToSerial, defineAlias, defineFunction, packDate, packTime, serialToDate, unpackDate, unpackTime };
+export { CalcError, CellRef, Context, Deferred, Matrix, NULLREF, NameRef, Range$1 as Range, RangeRef, Ref, Sheet, SpreadsheetWidget, UnionRef, View, Workbook, calc, dateToSerial, defineAlias, defineFunction, packDate, packTime, serialToDate, unpackDate, unpackTime };