{"version":3,"file":"quill-delta-DPK0Z0JV.js","sources":["../../../node_modules/quill-delta/dist/AttributeMap.js","../../../node_modules/quill-delta/dist/Iterator.js","../../../node_modules/quill-delta/dist/Op.js","../../../node_modules/quill-delta/dist/Delta.js"],"sourcesContent":["\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar lodash_clonedeep_1 = __importDefault(require(\"lodash.clonedeep\"));\nvar lodash_isequal_1 = __importDefault(require(\"lodash.isequal\"));\nvar AttributeMap;\n(function (AttributeMap) {\n    function compose(a, b, keepNull) {\n        if (a === void 0) { a = {}; }\n        if (b === void 0) { b = {}; }\n        if (typeof a !== 'object') {\n            a = {};\n        }\n        if (typeof b !== 'object') {\n            b = {};\n        }\n        var attributes = lodash_clonedeep_1.default(b);\n        if (!keepNull) {\n            attributes = Object.keys(attributes).reduce(function (copy, key) {\n                if (attributes[key] != null) {\n                    copy[key] = attributes[key];\n                }\n                return copy;\n            }, {});\n        }\n        for (var key in a) {\n            if (a[key] !== undefined && b[key] === undefined) {\n                attributes[key] = a[key];\n            }\n        }\n        return Object.keys(attributes).length > 0 ? attributes : undefined;\n    }\n    AttributeMap.compose = compose;\n    function diff(a, b) {\n        if (a === void 0) { a = {}; }\n        if (b === void 0) { b = {}; }\n        if (typeof a !== 'object') {\n            a = {};\n        }\n        if (typeof b !== 'object') {\n            b = {};\n        }\n        var attributes = Object.keys(a)\n            .concat(Object.keys(b))\n            .reduce(function (attrs, key) {\n            if (!lodash_isequal_1.default(a[key], b[key])) {\n                attrs[key] = b[key] === undefined ? null : b[key];\n            }\n            return attrs;\n        }, {});\n        return Object.keys(attributes).length > 0 ? attributes : undefined;\n    }\n    AttributeMap.diff = diff;\n    function invert(attr, base) {\n        if (attr === void 0) { attr = {}; }\n        if (base === void 0) { base = {}; }\n        attr = attr || {};\n        var baseInverted = Object.keys(base).reduce(function (memo, key) {\n            if (base[key] !== attr[key] && attr[key] !== undefined) {\n                memo[key] = base[key];\n            }\n            return memo;\n        }, {});\n        return Object.keys(attr).reduce(function (memo, key) {\n            if (attr[key] !== base[key] && base[key] === undefined) {\n                memo[key] = null;\n            }\n            return memo;\n        }, baseInverted);\n    }\n    AttributeMap.invert = invert;\n    function transform(a, b, priority) {\n        if (priority === void 0) { priority = false; }\n        if (typeof a !== 'object') {\n            return b;\n        }\n        if (typeof b !== 'object') {\n            return undefined;\n        }\n        if (!priority) {\n            return b; // b simply overwrites us without priority\n        }\n        var attributes = Object.keys(b).reduce(function (attrs, key) {\n            if (a[key] === undefined) {\n                attrs[key] = b[key]; // null is a valid value\n            }\n            return attrs;\n        }, {});\n        return Object.keys(attributes).length > 0 ? attributes : undefined;\n    }\n    AttributeMap.transform = transform;\n})(AttributeMap || (AttributeMap = {}));\nexports.default = AttributeMap;\n//# sourceMappingURL=AttributeMap.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Op_1 = __importDefault(require(\"./Op\"));\nvar Iterator = /** @class */ (function () {\n    function Iterator(ops) {\n        this.ops = ops;\n        this.index = 0;\n        this.offset = 0;\n    }\n    Iterator.prototype.hasNext = function () {\n        return this.peekLength() < Infinity;\n    };\n    Iterator.prototype.next = function (length) {\n        if (!length) {\n            length = Infinity;\n        }\n        var nextOp = this.ops[this.index];\n        if (nextOp) {\n            var offset = this.offset;\n            var opLength = Op_1.default.length(nextOp);\n            if (length >= opLength - offset) {\n                length = opLength - offset;\n                this.index += 1;\n                this.offset = 0;\n            }\n            else {\n                this.offset += length;\n            }\n            if (typeof nextOp.delete === 'number') {\n                return { delete: length };\n            }\n            else {\n                var retOp = {};\n                if (nextOp.attributes) {\n                    retOp.attributes = nextOp.attributes;\n                }\n                if (typeof nextOp.retain === 'number') {\n                    retOp.retain = length;\n                }\n                else if (typeof nextOp.insert === 'string') {\n                    retOp.insert = nextOp.insert.substr(offset, length);\n                }\n                else {\n                    // offset should === 0, length should === 1\n                    retOp.insert = nextOp.insert;\n                }\n                return retOp;\n            }\n        }\n        else {\n            return { retain: Infinity };\n        }\n    };\n    Iterator.prototype.peek = function () {\n        return this.ops[this.index];\n    };\n    Iterator.prototype.peekLength = function () {\n        if (this.ops[this.index]) {\n            // Should never return 0 if our index is being managed correctly\n            return Op_1.default.length(this.ops[this.index]) - this.offset;\n        }\n        else {\n            return Infinity;\n        }\n    };\n    Iterator.prototype.peekType = function () {\n        if (this.ops[this.index]) {\n            if (typeof this.ops[this.index].delete === 'number') {\n                return 'delete';\n            }\n            else if (typeof this.ops[this.index].retain === 'number') {\n                return 'retain';\n            }\n            else {\n                return 'insert';\n            }\n        }\n        return 'retain';\n    };\n    Iterator.prototype.rest = function () {\n        if (!this.hasNext()) {\n            return [];\n        }\n        else if (this.offset === 0) {\n            return this.ops.slice(this.index);\n        }\n        else {\n            var offset = this.offset;\n            var index = this.index;\n            var next = this.next();\n            var rest = this.ops.slice(this.index);\n            this.offset = offset;\n            this.index = index;\n            return [next].concat(rest);\n        }\n    };\n    return Iterator;\n}());\nexports.default = Iterator;\n//# sourceMappingURL=Iterator.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Iterator_1 = __importDefault(require(\"./Iterator\"));\nvar Op;\n(function (Op) {\n    function iterator(ops) {\n        return new Iterator_1.default(ops);\n    }\n    Op.iterator = iterator;\n    function length(op) {\n        if (typeof op.delete === 'number') {\n            return op.delete;\n        }\n        else if (typeof op.retain === 'number') {\n            return op.retain;\n        }\n        else {\n            return typeof op.insert === 'string' ? op.insert.length : 1;\n        }\n    }\n    Op.length = length;\n})(Op || (Op = {}));\nexports.default = Op;\n//# sourceMappingURL=Op.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar fast_diff_1 = __importDefault(require(\"fast-diff\"));\nvar lodash_clonedeep_1 = __importDefault(require(\"lodash.clonedeep\"));\nvar lodash_isequal_1 = __importDefault(require(\"lodash.isequal\"));\nvar AttributeMap_1 = __importDefault(require(\"./AttributeMap\"));\nvar Op_1 = __importDefault(require(\"./Op\"));\nvar NULL_CHARACTER = String.fromCharCode(0); // Placeholder char for embed in diff()\nvar Delta = /** @class */ (function () {\n    function Delta(ops) {\n        // Assume we are given a well formed ops\n        if (Array.isArray(ops)) {\n            this.ops = ops;\n        }\n        else if (ops != null && Array.isArray(ops.ops)) {\n            this.ops = ops.ops;\n        }\n        else {\n            this.ops = [];\n        }\n    }\n    Delta.prototype.insert = function (arg, attributes) {\n        var newOp = {};\n        if (typeof arg === 'string' && arg.length === 0) {\n            return this;\n        }\n        newOp.insert = arg;\n        if (attributes != null &&\n            typeof attributes === 'object' &&\n            Object.keys(attributes).length > 0) {\n            newOp.attributes = attributes;\n        }\n        return this.push(newOp);\n    };\n    Delta.prototype.delete = function (length) {\n        if (length <= 0) {\n            return this;\n        }\n        return this.push({ delete: length });\n    };\n    Delta.prototype.retain = function (length, attributes) {\n        if (length <= 0) {\n            return this;\n        }\n        var newOp = { retain: length };\n        if (attributes != null &&\n            typeof attributes === 'object' &&\n            Object.keys(attributes).length > 0) {\n            newOp.attributes = attributes;\n        }\n        return this.push(newOp);\n    };\n    Delta.prototype.push = function (newOp) {\n        var index = this.ops.length;\n        var lastOp = this.ops[index - 1];\n        newOp = lodash_clonedeep_1.default(newOp);\n        if (typeof lastOp === 'object') {\n            if (typeof newOp.delete === 'number' &&\n                typeof lastOp.delete === 'number') {\n                this.ops[index - 1] = { delete: lastOp.delete + newOp.delete };\n                return this;\n            }\n            // Since it does not matter if we insert before or after deleting at the same index,\n            // always prefer to insert first\n            if (typeof lastOp.delete === 'number' && newOp.insert != null) {\n                index -= 1;\n                lastOp = this.ops[index - 1];\n                if (typeof lastOp !== 'object') {\n                    this.ops.unshift(newOp);\n                    return this;\n                }\n            }\n            if (lodash_isequal_1.default(newOp.attributes, lastOp.attributes)) {\n                if (typeof newOp.insert === 'string' &&\n                    typeof lastOp.insert === 'string') {\n                    this.ops[index - 1] = { insert: lastOp.insert + newOp.insert };\n                    if (typeof newOp.attributes === 'object') {\n                        this.ops[index - 1].attributes = newOp.attributes;\n                    }\n                    return this;\n                }\n                else if (typeof newOp.retain === 'number' &&\n                    typeof lastOp.retain === 'number') {\n                    this.ops[index - 1] = { retain: lastOp.retain + newOp.retain };\n                    if (typeof newOp.attributes === 'object') {\n                        this.ops[index - 1].attributes = newOp.attributes;\n                    }\n                    return this;\n                }\n            }\n        }\n        if (index === this.ops.length) {\n            this.ops.push(newOp);\n        }\n        else {\n            this.ops.splice(index, 0, newOp);\n        }\n        return this;\n    };\n    Delta.prototype.chop = function () {\n        var lastOp = this.ops[this.ops.length - 1];\n        if (lastOp && lastOp.retain && !lastOp.attributes) {\n            this.ops.pop();\n        }\n        return this;\n    };\n    Delta.prototype.filter = function (predicate) {\n        return this.ops.filter(predicate);\n    };\n    Delta.prototype.forEach = function (predicate) {\n        this.ops.forEach(predicate);\n    };\n    Delta.prototype.map = function (predicate) {\n        return this.ops.map(predicate);\n    };\n    Delta.prototype.partition = function (predicate) {\n        var passed = [];\n        var failed = [];\n        this.forEach(function (op) {\n            var target = predicate(op) ? passed : failed;\n            target.push(op);\n        });\n        return [passed, failed];\n    };\n    Delta.prototype.reduce = function (predicate, initialValue) {\n        return this.ops.reduce(predicate, initialValue);\n    };\n    Delta.prototype.changeLength = function () {\n        return this.reduce(function (length, elem) {\n            if (elem.insert) {\n                return length + Op_1.default.length(elem);\n            }\n            else if (elem.delete) {\n                return length - elem.delete;\n            }\n            return length;\n        }, 0);\n    };\n    Delta.prototype.length = function () {\n        return this.reduce(function (length, elem) {\n            return length + Op_1.default.length(elem);\n        }, 0);\n    };\n    Delta.prototype.slice = function (start, end) {\n        if (start === void 0) { start = 0; }\n        if (end === void 0) { end = Infinity; }\n        var ops = [];\n        var iter = Op_1.default.iterator(this.ops);\n        var index = 0;\n        while (index < end && iter.hasNext()) {\n            var nextOp = void 0;\n            if (index < start) {\n                nextOp = iter.next(start - index);\n            }\n            else {\n                nextOp = iter.next(end - index);\n                ops.push(nextOp);\n            }\n            index += Op_1.default.length(nextOp);\n        }\n        return new Delta(ops);\n    };\n    Delta.prototype.compose = function (other) {\n        var thisIter = Op_1.default.iterator(this.ops);\n        var otherIter = Op_1.default.iterator(other.ops);\n        var ops = [];\n        var firstOther = otherIter.peek();\n        if (firstOther != null &&\n            typeof firstOther.retain === 'number' &&\n            firstOther.attributes == null) {\n            var firstLeft = firstOther.retain;\n            while (thisIter.peekType() === 'insert' &&\n                thisIter.peekLength() <= firstLeft) {\n                firstLeft -= thisIter.peekLength();\n                ops.push(thisIter.next());\n            }\n            if (firstOther.retain - firstLeft > 0) {\n                otherIter.next(firstOther.retain - firstLeft);\n            }\n        }\n        var delta = new Delta(ops);\n        while (thisIter.hasNext() || otherIter.hasNext()) {\n            if (otherIter.peekType() === 'insert') {\n                delta.push(otherIter.next());\n            }\n            else if (thisIter.peekType() === 'delete') {\n                delta.push(thisIter.next());\n            }\n            else {\n                var length_1 = Math.min(thisIter.peekLength(), otherIter.peekLength());\n                var thisOp = thisIter.next(length_1);\n                var otherOp = otherIter.next(length_1);\n                if (typeof otherOp.retain === 'number') {\n                    var newOp = {};\n                    if (typeof thisOp.retain === 'number') {\n                        newOp.retain = length_1;\n                    }\n                    else {\n                        newOp.insert = thisOp.insert;\n                    }\n                    // Preserve null when composing with a retain, otherwise remove it for inserts\n                    var attributes = AttributeMap_1.default.compose(thisOp.attributes, otherOp.attributes, typeof thisOp.retain === 'number');\n                    if (attributes) {\n                        newOp.attributes = attributes;\n                    }\n                    delta.push(newOp);\n                    // Optimization if rest of other is just retain\n                    if (!otherIter.hasNext() &&\n                        lodash_isequal_1.default(delta.ops[delta.ops.length - 1], newOp)) {\n                        var rest = new Delta(thisIter.rest());\n                        return delta.concat(rest).chop();\n                    }\n                    // Other op should be delete, we could be an insert or retain\n                    // Insert + delete cancels out\n                }\n                else if (typeof otherOp.delete === 'number' &&\n                    typeof thisOp.retain === 'number') {\n                    delta.push(otherOp);\n                }\n            }\n        }\n        return delta.chop();\n    };\n    Delta.prototype.concat = function (other) {\n        var delta = new Delta(this.ops.slice());\n        if (other.ops.length > 0) {\n            delta.push(other.ops[0]);\n            delta.ops = delta.ops.concat(other.ops.slice(1));\n        }\n        return delta;\n    };\n    Delta.prototype.diff = function (other, cursor) {\n        if (this.ops === other.ops) {\n            return new Delta();\n        }\n        var strings = [this, other].map(function (delta) {\n            return delta\n                .map(function (op) {\n                if (op.insert != null) {\n                    return typeof op.insert === 'string' ? op.insert : NULL_CHARACTER;\n                }\n                var prep = delta === other ? 'on' : 'with';\n                throw new Error('diff() called ' + prep + ' non-document');\n            })\n                .join('');\n        });\n        var retDelta = new Delta();\n        var diffResult = fast_diff_1.default(strings[0], strings[1], cursor);\n        var thisIter = Op_1.default.iterator(this.ops);\n        var otherIter = Op_1.default.iterator(other.ops);\n        diffResult.forEach(function (component) {\n            var length = component[1].length;\n            while (length > 0) {\n                var opLength = 0;\n                switch (component[0]) {\n                    case fast_diff_1.default.INSERT:\n                        opLength = Math.min(otherIter.peekLength(), length);\n                        retDelta.push(otherIter.next(opLength));\n                        break;\n                    case fast_diff_1.default.DELETE:\n                        opLength = Math.min(length, thisIter.peekLength());\n                        thisIter.next(opLength);\n                        retDelta.delete(opLength);\n                        break;\n                    case fast_diff_1.default.EQUAL:\n                        opLength = Math.min(thisIter.peekLength(), otherIter.peekLength(), length);\n                        var thisOp = thisIter.next(opLength);\n                        var otherOp = otherIter.next(opLength);\n                        if (lodash_isequal_1.default(thisOp.insert, otherOp.insert)) {\n                            retDelta.retain(opLength, AttributeMap_1.default.diff(thisOp.attributes, otherOp.attributes));\n                        }\n                        else {\n                            retDelta.push(otherOp).delete(opLength);\n                        }\n                        break;\n                }\n                length -= opLength;\n            }\n        });\n        return retDelta.chop();\n    };\n    Delta.prototype.eachLine = function (predicate, newline) {\n        if (newline === void 0) { newline = '\\n'; }\n        var iter = Op_1.default.iterator(this.ops);\n        var line = new Delta();\n        var i = 0;\n        while (iter.hasNext()) {\n            if (iter.peekType() !== 'insert') {\n                return;\n            }\n            var thisOp = iter.peek();\n            var start = Op_1.default.length(thisOp) - iter.peekLength();\n            var index = typeof thisOp.insert === 'string'\n                ? thisOp.insert.indexOf(newline, start) - start\n                : -1;\n            if (index < 0) {\n                line.push(iter.next());\n            }\n            else if (index > 0) {\n                line.push(iter.next(index));\n            }\n            else {\n                if (predicate(line, iter.next(1).attributes || {}, i) === false) {\n                    return;\n                }\n                i += 1;\n                line = new Delta();\n            }\n        }\n        if (line.length() > 0) {\n            predicate(line, {}, i);\n        }\n    };\n    Delta.prototype.invert = function (base) {\n        var inverted = new Delta();\n        this.reduce(function (baseIndex, op) {\n            if (op.insert) {\n                inverted.delete(Op_1.default.length(op));\n            }\n            else if (op.retain && op.attributes == null) {\n                inverted.retain(op.retain);\n                return baseIndex + op.retain;\n            }\n            else if (op.delete || (op.retain && op.attributes)) {\n                var length_2 = (op.delete || op.retain);\n                var slice = base.slice(baseIndex, baseIndex + length_2);\n                slice.forEach(function (baseOp) {\n                    if (op.delete) {\n                        inverted.push(baseOp);\n                    }\n                    else if (op.retain && op.attributes) {\n                        inverted.retain(Op_1.default.length(baseOp), AttributeMap_1.default.invert(op.attributes, baseOp.attributes));\n                    }\n                });\n                return baseIndex + length_2;\n            }\n            return baseIndex;\n        }, 0);\n        return inverted.chop();\n    };\n    Delta.prototype.transform = function (arg, priority) {\n        if (priority === void 0) { priority = false; }\n        priority = !!priority;\n        if (typeof arg === 'number') {\n            return this.transformPosition(arg, priority);\n        }\n        var other = arg;\n        var thisIter = Op_1.default.iterator(this.ops);\n        var otherIter = Op_1.default.iterator(other.ops);\n        var delta = new Delta();\n        while (thisIter.hasNext() || otherIter.hasNext()) {\n            if (thisIter.peekType() === 'insert' &&\n                (priority || otherIter.peekType() !== 'insert')) {\n                delta.retain(Op_1.default.length(thisIter.next()));\n            }\n            else if (otherIter.peekType() === 'insert') {\n                delta.push(otherIter.next());\n            }\n            else {\n                var length_3 = Math.min(thisIter.peekLength(), otherIter.peekLength());\n                var thisOp = thisIter.next(length_3);\n                var otherOp = otherIter.next(length_3);\n                if (thisOp.delete) {\n                    // Our delete either makes their delete redundant or removes their retain\n                    continue;\n                }\n                else if (otherOp.delete) {\n                    delta.push(otherOp);\n                }\n                else {\n                    // We retain either their retain or insert\n                    delta.retain(length_3, AttributeMap_1.default.transform(thisOp.attributes, otherOp.attributes, priority));\n                }\n            }\n        }\n        return delta.chop();\n    };\n    Delta.prototype.transformPosition = function (index, priority) {\n        if (priority === void 0) { priority = false; }\n        priority = !!priority;\n        var thisIter = Op_1.default.iterator(this.ops);\n        var offset = 0;\n        while (thisIter.hasNext() && offset <= index) {\n            var length_4 = thisIter.peekLength();\n            var nextType = thisIter.peekType();\n            thisIter.next();\n            if (nextType === 'delete') {\n                index -= Math.min(length_4, index - offset);\n                continue;\n            }\n            else if (nextType === 'insert' && (offset < index || !priority)) {\n                index += length_4;\n            }\n            offset += length_4;\n        }\n        return index;\n    };\n    Delta.Op = Op_1.default;\n    Delta.AttributeMap = AttributeMap_1.default;\n    return Delta;\n}());\nmodule.exports = Delta;\n//# sourceMappingURL=Delta.js.map"],"names":["__importDefault","this","mod","AttributeMap_1","lodash_clonedeep_1","require$$0","lodash_isequal_1","require$$1","AttributeMap","compose","a","b","keepNull","attributes","copy","key","diff","attrs","invert","attr","base","baseInverted","memo","transform","priority","Iterator_1","Op_1","Iterator","ops","length","nextOp","offset","opLength","retOp","index","next","rest","Op","iterator","op","fast_diff_1","require$$2","require$$3","require$$4","NULL_CHARACTER","Delta","arg","newOp","lastOp","predicate","passed","failed","target","initialValue","elem","start","end","iter","other","thisIter","otherIter","firstOther","firstLeft","delta","length_1","thisOp","otherOp","cursor","strings","prep","retDelta","diffResult","component","newline","line","inverted","baseIndex","length_2","slice","baseOp","length_3","length_4","nextType","Delta_1"],"mappings":"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","x_google_ignoreList":[0,1,2,3]}