vendor: 281,227 bytes, lines 1-5221
1/*! 2 * Quill Editor v1.3.6 3 * https://quilljs.com/ 4 * Copyright (c) 2014, Jason Chen 5 * Copyright (c) 2013, salesforce.com 6 */ 7(function webpackUniversalModuleDefinition(root, factory) { 8 if(typeof exports === 'object' && typeof module === 'object') 9 module.exports = factory(); 10 else if(typeof define === 'function' && define.amd) 11 define([], factory); 12 else if(typeof exports === 'object') 13 exports["Quill"] = factory(); 14 else 15 root["Quill"] = factory(); 16})(typeof self !== 'undefined' ? self : this, function() { 17 return /******/ (function(modules) { // webpackBootstrap 18 /******/ // The module cache 19 /******/ var installedModules = {}; 20 /******/ 21 /******/ // The require function 22 /******/ function __webpack_require__(moduleId) { 23 /******/ 24 /******/ // Check if module is in cache 25 /******/ if(installedModules[moduleId]) { 26 /******/ return installedModules[moduleId].exports; 27 /******/ } 28 /******/ // Create a new module (and put it into the cache) 29 /******/ var module = installedModules[moduleId] = { 30 /******/ i: moduleId, 31 /******/ l: false, 32 /******/ exports: {} 33 /******/ }; 34 /******/ 35 /******/ // Execute the module function 36 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 37 /******/ 38 /******/ // Flag the module as loaded 39 /******/ module.l = true; 40 /******/ 41 /******/ // Return the exports of the module 42 /******/ return module.exports; 43 /******/ } 44 /******/ 45 /******/ 46 /******/ // expose the modules object (__webpack_modules__) 47 /******/ __webpack_require__.m = modules; 48 /******/ 49 /******/ // expose the module cache 50 /******/ __webpack_require__.c = installedModules; 51 /******/ 52 /******/ // define getter function for harmony exports 53 /******/ __webpack_require__.d = function(exports, name, getter) { 54 /******/ if(!__webpack_require__.o(exports, name)) { 55 /******/ Object.defineProperty(exports, name, { 56 /******/ configurable: false, 57 /******/ enumerable: true, 58 /******/ get: getter 59 /******/ }); 60 /******/ } 61 /******/ }; 62 /******/ 63 /******/ // getDefaultExport function for compatibility with non-harmony modules 64 /******/ __webpack_require__.n = function(module) { 65 /******/ var getter = module && module.__esModule ? 66 /******/ function getDefault() { return module['default']; } : 67 /******/ function getModuleExports() { return module; }; 68 /******/ __webpack_require__.d(getter, 'a', getter); 69 /******/ return getter; 70 /******/ }; 71 /******/ 72 /******/ // Object.prototype.hasOwnProperty.call 73 /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 74 /******/ 75 /******/ // __webpack_public_path__ 76 /******/ __webpack_require__.p = ""; 77 /******/ 78 /******/ // Load entry module and return exports 79 /******/ return __webpack_require__(__webpack_require__.s = 109); 80 /******/ }) 81 /************************************************************************/ 82 /******/ ([ 83 /* 0 */ 84 /***/ (function(module, exports, __webpack_require__) { 85 86 "use strict"; 87 88 Object.defineProperty(exports, "__esModule", { value: true }); 89 var container_1 = __webpack_require__(17); 90 var format_1 = __webpack_require__(18); 91 var leaf_1 = __webpack_require__(19); 92 var scroll_1 = __webpack_require__(45); 93 var inline_1 = __webpack_require__(46); 94 var block_1 = __webpack_require__(47); 95 var embed_1 = __webpack_require__(48); 96 var text_1 = __webpack_require__(49); 97 var attributor_1 = __webpack_require__(12); 98 var class_1 = __webpack_require__(32); 99 var style_1 = __webpack_require__(33); 100 var store_1 = __webpack_require__(31); 101 var Registry = __webpack_require__(1); 102 var Parchment = { 103 Scope: Registry.Scope, 104 create: Registry.create, 105 find: Registry.find, 106 query: Registry.query, 107 register: Registry.register, 108 Container: container_1.default, 109 Format: format_1.default, 110 Leaf: leaf_1.default, 111 Embed: embed_1.default, 112 Scroll: scroll_1.default, 113 Block: block_1.default, 114 Inline: inline_1.default, 115 Text: text_1.default, 116 Attributor: { 117 Attribute: attributor_1.default, 118 Class: class_1.default, 119 Style: style_1.default, 120 Store: store_1.default, 121 }, 122 }; 123 exports.default = Parchment; 124 125 126 /***/ }), 127 /* 1 */ 128 /***/ (function(module, exports, __webpack_require__) { 129 130 "use strict"; 131 132 var __extends = (this && this.__extends) || (function () { 133 var extendStatics = Object.setPrototypeOf || 134 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 135 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 136 return function (d, b) { 137 extendStatics(d, b); 138 function __() { this.constructor = d; } 139 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 140 }; 141 })(); 142 Object.defineProperty(exports, "__esModule", { value: true }); 143 var ParchmentError = /** @class */ (function (_super) { 144 __extends(ParchmentError, _super); 145 function ParchmentError(message) { 146 var _this = this; 147 message = '[Parchment] ' + message; 148 _this = _super.call(this, message) || this; 149 _this.message = message; 150 _this.name = _this.constructor.name; 151 return _this; 152 } 153 return ParchmentError; 154 }(Error)); 155 exports.ParchmentError = ParchmentError; 156 var attributes = {}; 157 var classes = {}; 158 var tags = {}; 159 var types = {}; 160 exports.DATA_KEY = '__blot'; 161 var Scope; 162 (function (Scope) { 163 Scope[Scope["TYPE"] = 3] = "TYPE"; 164 Scope[Scope["LEVEL"] = 12] = "LEVEL"; 165 Scope[Scope["ATTRIBUTE"] = 13] = "ATTRIBUTE"; 166 Scope[Scope["BLOT"] = 14] = "BLOT"; 167 Scope[Scope["INLINE"] = 7] = "INLINE"; 168 Scope[Scope["BLOCK"] = 11] = "BLOCK"; 169 Scope[Scope["BLOCK_BLOT"] = 10] = "BLOCK_BLOT"; 170 Scope[Scope["INLINE_BLOT"] = 6] = "INLINE_BLOT"; 171 Scope[Scope["BLOCK_ATTRIBUTE"] = 9] = "BLOCK_ATTRIBUTE"; 172 Scope[Scope["INLINE_ATTRIBUTE"] = 5] = "INLINE_ATTRIBUTE"; 173 Scope[Scope["ANY"] = 15] = "ANY"; 174 })(Scope = exports.Scope || (exports.Scope = {})); 175 function create(input, value) { 176 var match = query(input); 177 if (match == null) { 178 throw new ParchmentError("Unable to create " + input + " blot"); 179 } 180 var BlotClass = match; 181 var node = 182 // @ts-ignore 183 input instanceof Node || input['nodeType'] === Node.TEXT_NODE ? input : BlotClass.create(value); 184 return new BlotClass(node, value); 185 } 186 exports.create = create; 187 function find(node, bubble) { 188 if (bubble === void 0) { bubble = false; } 189 if (node == null) 190 return null; 191 // @ts-ignore 192 if (node[exports.DATA_KEY] != null) 193 return node[exports.DATA_KEY].blot; 194 if (bubble) 195 return find(node.parentNode, bubble); 196 return null; 197 } 198 exports.find = find; 199 function query(query, scope) { 200 if (scope === void 0) { scope = Scope.ANY; } 201 var match; 202 if (typeof query === 'string') { 203 match = types[query] || attributes[query]; 204 // @ts-ignore 205 } 206 else if (query instanceof Text || query['nodeType'] === Node.TEXT_NODE) { 207 match = types['text']; 208 } 209 else if (typeof query === 'number') { 210 if (query & Scope.LEVEL & Scope.BLOCK) { 211 match = types['block']; 212 } 213 else if (query & Scope.LEVEL & Scope.INLINE) { 214 match = types['inline']; 215 } 216 } 217 else if (query instanceof HTMLElement) { 218 var names = (query.getAttribute('class') || '').split(/\s+/); 219 for (var i in names) { 220 match = classes[names[i]]; 221 if (match) 222 break; 223 } 224 match = match || tags[query.tagName]; 225 } 226 if (match == null) 227 return null; 228 // @ts-ignore 229 if (scope & Scope.LEVEL & match.scope && scope & Scope.TYPE & match.scope) 230 return match; 231 return null; 232 } 233 exports.query = query; 234 function register() { 235 var Definitions = []; 236 for (var _i = 0; _i < arguments.length; _i++) { 237 Definitions[_i] = arguments[_i]; 238 } 239 if (Definitions.length > 1) { 240 return Definitions.map(function (d) { 241 return register(d); 242 }); 243 } 244 var Definition = Definitions[0]; 245 if (typeof Definition.blotName !== 'string' && typeof Definition.attrName !== 'string') { 246 throw new ParchmentError('Invalid definition'); 247 } 248 else if (Definition.blotName === 'abstract') { 249 throw new ParchmentError('Cannot register abstract class'); 250 } 251 types[Definition.blotName || Definition.attrName] = Definition; 252 if (typeof Definition.keyName === 'string') { 253 attributes[Definition.keyName] = Definition; 254 } 255 else { 256 if (Definition.className != null) { 257 classes[Definition.className] = Definition; 258 } 259 if (Definition.tagName != null) { 260 if (Array.isArray(Definition.tagName)) { 261 Definition.tagName = Definition.tagName.map(function (tagName) { 262 return tagName.toUpperCase(); 263 }); 264 } 265 else { 266 Definition.tagName = Definition.tagName.toUpperCase(); 267 } 268 var tagNames = Array.isArray(Definition.tagName) ? Definition.tagName : [Definition.tagName]; 269 tagNames.forEach(function (tag) { 270 if (tags[tag] == null || Definition.className == null) { 271 tags[tag] = Definition; 272 } 273 }); 274 } 275 } 276 return Definition; 277 } 278 exports.register = register; 279 280 281 /***/ }), 282 /* 2 */ 283 /***/ (function(module, exports, __webpack_require__) { 284 285 var diff = __webpack_require__(51); 286 var equal = __webpack_require__(11); 287 var extend = __webpack_require__(3); 288 var op = __webpack_require__(20); 289 290 291 var NULL_CHARACTER = String.fromCharCode(0); // Placeholder char for embed in diff() 292 293 294 var Delta = function (ops) { 295 // Assume we are given a well formed ops 296 if (Array.isArray(ops)) { 297 this.ops = ops; 298 } else if (ops != null && Array.isArray(ops.ops)) { 299 this.ops = ops.ops; 300 } else { 301 this.ops = []; 302 } 303 }; 304 305 306 Delta.prototype.insert = function (text, attributes) { 307 var newOp = {}; 308 if (text.length === 0) return this; 309 newOp.insert = text; 310 if (attributes != null && typeof attributes === 'object' && Object.keys(attributes).length > 0) { 311 newOp.attributes = attributes; 312 } 313 return this.push(newOp); 314 }; 315 316 Delta.prototype['delete'] = function (length) { 317 if (length <= 0) return this; 318 return this.push({ 'delete': length }); 319 }; 320 321 Delta.prototype.retain = function (length, attributes) { 322 if (length <= 0) return this; 323 var newOp = { retain: length }; 324 if (attributes != null && typeof attributes === 'object' && Object.keys(attributes).length > 0) { 325 newOp.attributes = attributes; 326 } 327 return this.push(newOp); 328 }; 329 330 Delta.prototype.push = function (newOp) { 331 var index = this.ops.length; 332 var lastOp = this.ops[index - 1]; 333 newOp = extend(true, {}, newOp); 334 if (typeof lastOp === 'object') { 335 if (typeof newOp['delete'] === 'number' && typeof lastOp['delete'] === 'number') { 336 this.ops[index - 1] = { 'delete': lastOp['delete'] + newOp['delete'] }; 337 return this; 338 } 339 // Since it does not matter if we insert before or after deleting at the same index, 340 // always prefer to insert first 341 if (typeof lastOp['delete'] === 'number' && newOp.insert != null) { 342 index -= 1; 343 lastOp = this.ops[index - 1]; 344 if (typeof lastOp !== 'object') { 345 this.ops.unshift(newOp); 346 return this; 347 } 348 } 349 if (equal(newOp.attributes, lastOp.attributes)) { 350 if (typeof newOp.insert === 'string' && typeof lastOp.insert === 'string') { 351 this.ops[index - 1] = { insert: lastOp.insert + newOp.insert }; 352 if (typeof newOp.attributes === 'object') this.ops[index - 1].attributes = newOp.attributes 353 return this; 354 } else if (typeof newOp.retain === 'number' && typeof lastOp.retain === 'number') { 355 this.ops[index - 1] = { retain: lastOp.retain + newOp.retain }; 356 if (typeof newOp.attributes === 'object') this.ops[index - 1].attributes = newOp.attributes 357 return this; 358 } 359 } 360 } 361 if (index === this.ops.length) { 362 this.ops.push(newOp); 363 } else { 364 this.ops.splice(index, 0, newOp); 365 } 366 return this; 367 }; 368 369 Delta.prototype.chop = function () { 370 var lastOp = this.ops[this.ops.length - 1]; 371 if (lastOp && lastOp.retain && !lastOp.attributes) { 372 this.ops.pop(); 373 } 374 return this; 375 }; 376 377 Delta.prototype.filter = function (predicate) { 378 return this.ops.filter(predicate); 379 }; 380 381 Delta.prototype.forEach = function (predicate) { 382 this.ops.forEach(predicate); 383 }; 384 385 Delta.prototype.map = function (predicate) { 386 return this.ops.map(predicate); 387 }; 388 389 Delta.prototype.partition = function (predicate) { 390 var passed = [], failed = []; 391 this.forEach(function(op) { 392 var target = predicate(op) ? passed : failed; 393 target.push(op); 394 }); 395 return [passed, failed]; 396 }; 397 398 Delta.prototype.reduce = function (predicate, initial) { 399 return this.ops.reduce(predicate, initial); 400 }; 401 402 Delta.prototype.changeLength = function () { 403 return this.reduce(function (length, elem) { 404 if (elem.insert) { 405 return length + op.length(elem); 406 } else if (elem.delete) { 407 return length - elem.delete; 408 } 409 return length; 410 }, 0); 411 }; 412 413 Delta.prototype.length = function () { 414 return this.reduce(function (length, elem) { 415 return length + op.length(elem); 416 }, 0); 417 }; 418 419 Delta.prototype.slice = function (start, end) { 420 start = start || 0; 421 if (typeof end !== 'number') end = Infinity; 422 var ops = []; 423 var iter = op.iterator(this.ops); 424 var index = 0; 425 while (index < end && iter.hasNext()) { 426 var nextOp; 427 if (index < start) { 428 nextOp = iter.next(start - index); 429 } else { 430 nextOp = iter.next(end - index); 431 ops.push(nextOp); 432 } 433 index += op.length(nextOp); 434 } 435 return new Delta(ops); 436 }; 437 438 439 Delta.prototype.compose = function (other) { 440 var thisIter = op.iterator(this.ops); 441 var otherIter = op.iterator(other.ops); 442 var delta = new Delta(); 443 while (thisIter.hasNext() || otherIter.hasNext()) { 444 if (otherIter.peekType() === 'insert') { 445 delta.push(otherIter.next()); 446 } else if (thisIter.peekType() === 'delete') { 447 delta.push(thisIter.next()); 448 } else { 449 var length = Math.min(thisIter.peekLength(), otherIter.peekLength()); 450 var thisOp = thisIter.next(length); 451 var otherOp = otherIter.next(length); 452 if (typeof otherOp.retain === 'number') { 453 var newOp = {}; 454 if (typeof thisOp.retain === 'number') { 455 newOp.retain = length; 456 } else { 457 newOp.insert = thisOp.insert; 458 } 459 // Preserve null when composing with a retain, otherwise remove it for inserts 460 var attributes = op.attributes.compose(thisOp.attributes, otherOp.attributes, typeof thisOp.retain === 'number'); 461 if (attributes) newOp.attributes = attributes; 462 delta.push(newOp); 463 // Other op should be delete, we could be an insert or retain 464 // Insert + delete cancels out 465 } else if (typeof otherOp['delete'] === 'number' && typeof thisOp.retain === 'number') { 466 delta.push(otherOp); 467 } 468 } 469 } 470 return delta.chop(); 471 }; 472 473 Delta.prototype.concat = function (other) { 474 var delta = new Delta(this.ops.slice()); 475 if (other.ops.length > 0) { 476 delta.push(other.ops[0]); 477 delta.ops = delta.ops.concat(other.ops.slice(1)); 478 } 479 return delta; 480 }; 481 482 Delta.prototype.diff = function (other, index) { 483 if (this.ops === other.ops) { 484 return new Delta(); 485 } 486 var strings = [this, other].map(function (delta) { 487 return delta.map(function (op) { 488 if (op.insert != null) { 489 return typeof op.insert === 'string' ? op.insert : NULL_CHARACTER; 490 } 491 var prep = (delta === other) ? 'on' : 'with'; 492 throw new Error('diff() called ' + prep + ' non-document'); 493 }).join(''); 494 }); 495 var delta = new Delta(); 496 var diffResult = diff(strings[0], strings[1], index); 497 var thisIter = op.iterator(this.ops); 498 var otherIter = op.iterator(other.ops); 499 diffResult.forEach(function (component) { 500 var length = component[1].length; 501 while (length > 0) { 502 var opLength = 0; 503 switch (component[0]) { 504 case diff.INSERT: 505 opLength = Math.min(otherIter.peekLength(), length); 506 delta.push(otherIter.next(opLength)); 507 break; 508 case diff.DELETE: 509 opLength = Math.min(length, thisIter.peekLength()); 510 thisIter.next(opLength); 511 delta['delete'](opLength); 512 break; 513 case diff.EQUAL: 514 opLength = Math.min(thisIter.peekLength(), otherIter.peekLength(), length); 515 var thisOp = thisIter.next(opLength); 516 var otherOp = otherIter.next(opLength); 517 if (equal(thisOp.insert, otherOp.insert)) { 518 delta.retain(opLength, op.attributes.diff(thisOp.attributes, otherOp.attributes)); 519 } else { 520 delta.push(otherOp)['delete'](opLength); 521 } 522 break; 523 } 524 length -= opLength; 525 } 526 }); 527 return delta.chop(); 528 }; 529 530 Delta.prototype.eachLine = function (predicate, newline) { 531 newline = newline || '\n'; 532 var iter = op.iterator(this.ops); 533 var line = new Delta(); 534 var i = 0; 535 while (iter.hasNext()) { 536 if (iter.peekType() !== 'insert') return; 537 var thisOp = iter.peek(); 538 var start = op.length(thisOp) - iter.peekLength(); 539 var index = typeof thisOp.insert === 'string' ? 540 thisOp.insert.indexOf(newline, start) - start : -1; 541 if (index < 0) { 542 line.push(iter.next()); 543 } else if (index > 0) { 544 line.push(iter.next(index)); 545 } else { 546 if (predicate(line, iter.next(1).attributes || {}, i) === false) { 547 return; 548 } 549 i += 1; 550 line = new Delta(); 551 } 552 } 553 if (line.length() > 0) { 554 predicate(line, {}, i); 555 } 556 }; 557 558 Delta.prototype.transform = function (other, priority) { 559 priority = !!priority; 560 if (typeof other === 'number') { 561 return this.transformPosition(other, priority); 562 } 563 var thisIter = op.iterator(this.ops); 564 var otherIter = op.iterator(other.ops); 565 var delta = new Delta(); 566 while (thisIter.hasNext() || otherIter.hasNext()) { 567 if (thisIter.peekType() === 'insert' && (priority || otherIter.peekType() !== 'insert')) { 568 delta.retain(op.length(thisIter.next())); 569 } else if (otherIter.peekType() === 'insert') { 570 delta.push(otherIter.next()); 571 } else { 572 var length = Math.min(thisIter.peekLength(), otherIter.peekLength()); 573 var thisOp = thisIter.next(length); 574 var otherOp = otherIter.next(length); 575 if (thisOp['delete']) { 576 // Our delete either makes their delete redundant or removes their retain 577 continue; 578 } else if (otherOp['delete']) { 579 delta.push(otherOp); 580 } else { 581 // We retain either their retain or insert 582 delta.retain(length, op.attributes.transform(thisOp.attributes, otherOp.attributes, priority)); 583 } 584 } 585 } 586 return delta.chop(); 587 }; 588 589 Delta.prototype.transformPosition = function (index, priority) { 590 priority = !!priority; 591 var thisIter = op.iterator(this.ops); 592 var offset = 0; 593 while (thisIter.hasNext() && offset <= index) { 594 var length = thisIter.peekLength(); 595 var nextType = thisIter.peekType(); 596 thisIter.next(); 597 if (nextType === 'delete') { 598 index -= Math.min(length, index - offset); 599 continue; 600 } else if (nextType === 'insert' && (offset < index || !priority)) { 601 index += length; 602 } 603 offset += length; 604 } 605 return index; 606 }; 607 608 609 module.exports = Delta; 610 611 612 /***/ }), 613 /* 3 */ 614 /***/ (function(module, exports) { 615 616 'use strict'; 617 618 var hasOwn = Object.prototype.hasOwnProperty; 619 var toStr = Object.prototype.toString; 620 621 var isArray = function isArray(arr) { 622 if (typeof Array.isArray === 'function') { 623 return Array.isArray(arr); 624 } 625 626 return toStr.call(arr) === '[object Array]'; 627 }; 628 629 var isPlainObject = function isPlainObject(obj) { 630 if (!obj || toStr.call(obj) !== '[object Object]') { 631 return false; 632 } 633 634 var hasOwnConstructor = hasOwn.call(obj, 'constructor'); 635 var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); 636 // Not own constructor property must be Object 637 if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { 638 return false; 639 } 640 641 // Own properties are enumerated firstly, so to speed up, 642 // if last one is own, then all properties are own. 643 var key; 644 for (key in obj) { /**/ } 645 646 return typeof key === 'undefined' || hasOwn.call(obj, key); 647 }; 648 649 module.exports = function extend() { 650 var options, name, src, copy, copyIsArray, clone; 651 var target = arguments[0]; 652 var i = 1; 653 var length = arguments.length; 654 var deep = false; 655 656 // Handle a deep copy situation 657 if (typeof target === 'boolean') { 658 deep = target; 659 target = arguments[1] || {}; 660 // skip the boolean and the target 661 i = 2; 662 } 663 if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { 664 target = {}; 665 } 666 667 for (; i < length; ++i) { 668 options = arguments[i]; 669 // Only deal with non-null/undefined values 670 if (options != null) { 671 // Extend the base object 672 for (name in options) { 673 src = target[name]; 674 copy = options[name]; 675 676 // Prevent never-ending loop 677 if (target !== copy) { 678 // Recurse if we're merging plain objects or arrays 679 if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { 680 if (copyIsArray) { 681 copyIsArray = false; 682 clone = src && isArray(src) ? src : []; 683 } else { 684 clone = src && isPlainObject(src) ? src : {}; 685 } 686 687 // Never move original objects, clone them 688 target[name] = extend(deep, clone, copy); 689 690 // Don't bring in undefined values 691 } else if (typeof copy !== 'undefined') { 692 target[name] = copy; 693 } 694 } 695 } 696 } 697 } 698 699 // Return the modified object 700 return target; 701 }; 702 703 704 /***/ }), 705 /* 4 */ 706 /***/ (function(module, exports, __webpack_require__) { 707 708 "use strict"; 709 710 711 Object.defineProperty(exports, "__esModule", { 712 value: true 713 }); 714 exports.default = exports.BlockEmbed = exports.bubbleFormats = undefined; 715 716 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 717 718 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 719 720 var _extend = __webpack_require__(3); 721 722 var _extend2 = _interopRequireDefault(_extend); 723 724 var _quillDelta = __webpack_require__(2); 725 726 var _quillDelta2 = _interopRequireDefault(_quillDelta); 727 728 var _parchment = __webpack_require__(0); 729 730 var _parchment2 = _interopRequireDefault(_parchment); 731 732 var _break = __webpack_require__(16); 733 734 var _break2 = _interopRequireDefault(_break); 735 736 var _inline = __webpack_require__(6); 737 738 var _inline2 = _interopRequireDefault(_inline); 739 740 var _text = __webpack_require__(7); 741 742 var _text2 = _interopRequireDefault(_text); 743 744 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 745 746 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 747 748 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 749 750 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 751 752 var NEWLINE_LENGTH = 1; 753 754 var BlockEmbed = function (_Parchment$Embed) { 755 _inherits(BlockEmbed, _Parchment$Embed); 756 757 function BlockEmbed() { 758 _classCallCheck(this, BlockEmbed); 759 760 return _possibleConstructorReturn(this, (BlockEmbed.__proto__ || Object.getPrototypeOf(BlockEmbed)).apply(this, arguments)); 761 } 762 763 _createClass(BlockEmbed, [{ 764 key: 'attach', 765 value: function attach() { 766 _get(BlockEmbed.prototype.__proto__ || Object.getPrototypeOf(BlockEmbed.prototype), 'attach', this).call(this); 767 this.attributes = new _parchment2.default.Attributor.Store(this.domNode); 768 } 769 }, { 770 key: 'delta', 771 value: function delta() { 772 return new _quillDelta2.default().insert(this.value(), (0, _extend2.default)(this.formats(), this.attributes.values())); 773 } 774 }, { 775 key: 'format', 776 value: function format(name, value) { 777 var attribute = _parchment2.default.query(name, _parchment2.default.Scope.BLOCK_ATTRIBUTE); 778 if (attribute != null) { 779 this.attributes.attribute(attribute, value); 780 } 781 } 782 }, { 783 key: 'formatAt', 784 value: function formatAt(index, length, name, value) { 785 this.format(name, value); 786 } 787 }, { 788 key: 'insertAt', 789 value: function insertAt(index, value, def) { 790 if (typeof value === 'string' && value.endsWith('\n')) { 791 var block = _parchment2.default.create(Block.blotName); 792 this.parent.insertBefore(block, index === 0 ? this : this.next); 793 block.insertAt(0, value.slice(0, -1)); 794 } else { 795 _get(BlockEmbed.prototype.__proto__ || Object.getPrototypeOf(BlockEmbed.prototype), 'insertAt', this).call(this, index, value, def); 796 } 797 } 798 }]); 799 800 return BlockEmbed; 801 }(_parchment2.default.Embed); 802 803 BlockEmbed.scope = _parchment2.default.Scope.BLOCK_BLOT; 804// It is important for cursor behavior BlockEmbeds use tags that are block level elements 805 806 807 var Block = function (_Parchment$Block) { 808 _inherits(Block, _Parchment$Block); 809 810 function Block(domNode) { 811 _classCallCheck(this, Block); 812 813 var _this2 = _possibleConstructorReturn(this, (Block.__proto__ || Object.getPrototypeOf(Block)).call(this, domNode)); 814 815 _this2.cache = {}; 816 return _this2; 817 } 818 819 _createClass(Block, [{ 820 key: 'delta', 821 value: function delta() { 822 if (this.cache.delta == null) { 823 this.cache.delta = this.descendants(_parchment2.default.Leaf).reduce(function (delta, leaf) { 824 if (leaf.length() === 0) { 825 return delta; 826 } else { 827 return delta.insert(leaf.value(), bubbleFormats(leaf)); 828 } 829 }, new _quillDelta2.default()).insert('\n', bubbleFormats(this)); 830 } 831 return this.cache.delta; 832 } 833 }, { 834 key: 'deleteAt', 835 value: function deleteAt(index, length) { 836 _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'deleteAt', this).call(this, index, length); 837 this.cache = {}; 838 } 839 }, { 840 key: 'formatAt', 841 value: function formatAt(index, length, name, value) { 842 if (length <= 0) return; 843 if (_parchment2.default.query(name, _parchment2.default.Scope.BLOCK)) { 844 if (index + length === this.length()) { 845 this.format(name, value); 846 } 847 } else { 848 _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'formatAt', this).call(this, index, Math.min(length, this.length() - index - 1), name, value); 849 } 850 this.cache = {}; 851 } 852 }, { 853 key: 'insertAt', 854 value: function insertAt(index, value, def) { 855 if (def != null) return _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'insertAt', this).call(this, index, value, def); 856 if (value.length === 0) return; 857 var lines = value.split('\n'); 858 var text = lines.shift(); 859 if (text.length > 0) { 860 if (index < this.length() - 1 || this.children.tail == null) { 861 _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'insertAt', this).call(this, Math.min(index, this.length() - 1), text); 862 } else { 863 this.children.tail.insertAt(this.children.tail.length(), text); 864 } 865 this.cache = {}; 866 } 867 var block = this; 868 lines.reduce(function (index, line) { 869 block = block.split(index, true); 870 block.insertAt(0, line); 871 return line.length; 872 }, index + text.length); 873 } 874 }, { 875 key: 'insertBefore', 876 value: function insertBefore(blot, ref) { 877 var head = this.children.head; 878 _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'insertBefore', this).call(this, blot, ref); 879 if (head instanceof _break2.default) { 880 head.remove(); 881 } 882 this.cache = {}; 883 } 884 }, { 885 key: 'length', 886 value: function length() { 887 if (this.cache.length == null) { 888 this.cache.length = _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'length', this).call(this) + NEWLINE_LENGTH; 889 } 890 return this.cache.length; 891 } 892 }, { 893 key: 'moveChildren', 894 value: function moveChildren(target, ref) { 895 _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'moveChildren', this).call(this, target, ref); 896 this.cache = {}; 897 } 898 }, { 899 key: 'optimize', 900 value: function optimize(context) { 901 _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'optimize', this).call(this, context); 902 this.cache = {}; 903 } 904 }, { 905 key: 'path', 906 value: function path(index) { 907 return _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'path', this).call(this, index, true); 908 } 909 }, { 910 key: 'removeChild', 911 value: function removeChild(child) { 912 _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'removeChild', this).call(this, child); 913 this.cache = {}; 914 } 915 }, { 916 key: 'split', 917 value: function split(index) { 918 var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 919 920 if (force && (index === 0 || index >= this.length() - NEWLINE_LENGTH)) { 921 var clone = this.clone(); 922 if (index === 0) { 923 this.parent.insertBefore(clone, this); 924 return this; 925 } else { 926 this.parent.insertBefore(clone, this.next); 927 return clone; 928 } 929 } else { 930 var next = _get(Block.prototype.__proto__ || Object.getPrototypeOf(Block.prototype), 'split', this).call(this, index, force); 931 this.cache = {}; 932 return next; 933 } 934 } 935 }]); 936 937 return Block; 938 }(_parchment2.default.Block); 939 940 Block.blotName = 'block'; 941 Block.tagName = 'P'; 942 Block.defaultChild = 'break'; 943 Block.allowedChildren = [_inline2.default, _parchment2.default.Embed, _text2.default]; 944 945 function bubbleFormats(blot) { 946 var formats = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 947 948 if (blot == null) return formats; 949 if (typeof blot.formats === 'function') { 950 formats = (0, _extend2.default)(formats, blot.formats()); 951 } 952 if (blot.parent == null || blot.parent.blotName == 'scroll' || blot.parent.statics.scope !== blot.statics.scope) { 953 return formats; 954 } 955 return bubbleFormats(blot.parent, formats); 956 } 957 958 exports.bubbleFormats = bubbleFormats; 959 exports.BlockEmbed = BlockEmbed; 960 exports.default = Block; 961 962 /***/ }), 963 /* 5 */ 964 /***/ (function(module, exports, __webpack_require__) { 965 966 "use strict"; 967 968 969 Object.defineProperty(exports, "__esModule", { 970 value: true 971 }); 972 exports.default = exports.overload = exports.expandConfig = undefined; 973 974 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 975 976 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 977 978 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 979 980 __webpack_require__(50); 981 982 var _quillDelta = __webpack_require__(2); 983 984 var _quillDelta2 = _interopRequireDefault(_quillDelta); 985 986 var _editor = __webpack_require__(14); 987 988 var _editor2 = _interopRequireDefault(_editor); 989 990 var _emitter3 = __webpack_require__(8); 991 992 var _emitter4 = _interopRequireDefault(_emitter3); 993 994 var _module = __webpack_require__(9); 995 996 var _module2 = _interopRequireDefault(_module); 997 998 var _parchment = __webpack_require__(0); 999 1000 var _parchment2 = _interopRequireDefault(_parchment); 1001 1002 var _selection = __webpack_require__(15); 1003 1004 var _selection2 = _interopRequireDefault(_selection); 1005 1006 var _extend = __webpack_require__(3); 1007 1008 var _extend2 = _interopRequireDefault(_extend); 1009 1010 var _logger = __webpack_require__(10); 1011 1012 var _logger2 = _interopRequireDefault(_logger); 1013 1014 var _theme = __webpack_require__(34); 1015 1016 var _theme2 = _interopRequireDefault(_theme); 1017 1018 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 1019 1020 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } 1021 1022 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 1023 1024 var debug = (0, _logger2.default)('quill'); 1025 1026 var Quill = function () { 1027 _createClass(Quill, null, [{ 1028 key: 'debug', 1029 value: function debug(limit) { 1030 if (limit === true) { 1031 limit = 'log'; 1032 } 1033 _logger2.default.level(limit); 1034 } 1035 }, { 1036 key: 'find', 1037 value: function find(node) { 1038 return node.__quill || _parchment2.default.find(node); 1039 } 1040 }, { 1041 key: 'import', 1042 value: function _import(name) { 1043 if (this.imports[name] == null) { 1044 debug.error('Cannot import ' + name + '. Are you sure it was registered?'); 1045 } 1046 return this.imports[name]; 1047 } 1048 }, { 1049 key: 'register', 1050 value: function register(path, target) { 1051 var _this = this; 1052 1053 var overwrite = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 1054 1055 if (typeof path !== 'string') { 1056 var name = path.attrName || path.blotName; 1057 if (typeof name === 'string') { 1058 // register(Blot | Attributor, overwrite) 1059 this.register('formats/' + name, path, target); 1060 } else { 1061 Object.keys(path).forEach(function (key) { 1062 _this.register(key, path[key], target); 1063 }); 1064 } 1065 } else { 1066 if (this.imports[path] != null && !overwrite) { 1067 debug.warn('Overwriting ' + path + ' with', target); 1068 } 1069 this.imports[path] = target; 1070 if ((path.startsWith('blots/') || path.startsWith('formats/')) && target.blotName !== 'abstract') { 1071 _parchment2.default.register(target); 1072 } else if (path.startsWith('modules') && typeof target.register === 'function') { 1073 target.register(); 1074 } 1075 } 1076 } 1077 }]); 1078 1079 function Quill(container) { 1080 var _this2 = this; 1081 1082 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 1083 1084 _classCallCheck(this, Quill); 1085 1086 this.options = expandConfig(container, options); 1087 this.container = this.options.container; 1088 if (this.container == null) { 1089 return debug.error('Invalid Quill container', container); 1090 } 1091 if (this.options.debug) { 1092 Quill.debug(this.options.debug); 1093 } 1094 var html = this.container.innerHTML.trim(); 1095 this.container.classList.add('ql-container'); 1096 this.container.innerHTML = ''; 1097 this.container.__quill = this; 1098 this.root = this.addContainer('ql-editor'); 1099 this.root.classList.add('ql-blank'); 1100 this.root.setAttribute('data-gramm', false); 1101 this.scrollingContainer = this.options.scrollingContainer || this.root; 1102 this.emitter = new _emitter4.default(); 1103 this.scroll = _parchment2.default.create(this.root, { 1104 emitter: this.emitter, 1105 whitelist: this.options.formats 1106 }); 1107 this.editor = new _editor2.default(this.scroll); 1108 this.selection = new _selection2.default(this.scroll, this.emitter); 1109 this.theme = new this.options.theme(this, this.options); 1110 this.keyboard = this.theme.addModule('keyboard'); 1111 this.clipboard = this.theme.addModule('clipboard'); 1112 this.history = this.theme.addModule('history'); 1113 this.theme.init(); 1114 this.emitter.on(_emitter4.default.events.EDITOR_CHANGE, function (type) { 1115 if (type === _emitter4.default.events.TEXT_CHANGE) { 1116 _this2.root.classList.toggle('ql-blank', _this2.editor.isBlank()); 1117 } 1118 }); 1119 this.emitter.on(_emitter4.default.events.SCROLL_UPDATE, function (source, mutations) { 1120 var range = _this2.selection.lastRange; 1121 var index = range && range.length === 0 ? range.index : undefined; 1122 modify.call(_this2, function () { 1123 return _this2.editor.update(null, mutations, index); 1124 }, source); 1125 }); 1126 var contents = this.clipboard.convert('<div class=\'ql-editor\' style="white-space: normal;">' + html + '<p><br></p></div>'); 1127 this.setContents(contents); 1128 this.history.clear(); 1129 if (this.options.placeholder) { 1130 this.root.setAttribute('data-placeholder', this.options.placeholder); 1131 } 1132 if (this.options.readOnly) { 1133 this.disable(); 1134 } 1135 } 1136 1137 _createClass(Quill, [{ 1138 key: 'addContainer', 1139 value: function addContainer(container) { 1140 var refNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 1141 1142 if (typeof container === 'string') { 1143 var className = container; 1144 container = document.createElement('div'); 1145 container.classList.add(className); 1146 } 1147 this.container.insertBefore(container, refNode); 1148 return container; 1149 } 1150 }, { 1151 key: 'blur', 1152 value: function blur() { 1153 this.selection.setRange(null); 1154 } 1155 }, { 1156 key: 'deleteText', 1157 value: function deleteText(index, length, source) { 1158 var _this3 = this; 1159 1160 var _overload = overload(index, length, source); 1161 1162 var _overload2 = _slicedToArray(_overload, 4); 1163 1164 index = _overload2[0]; 1165 length = _overload2[1]; 1166 source = _overload2[3]; 1167 1168 return modify.call(this, function () { 1169 return _this3.editor.deleteText(index, length); 1170 }, source, index, -1 * length); 1171 } 1172 }, { 1173 key: 'disable', 1174 value: function disable() { 1175 this.enable(false); 1176 } 1177 }, { 1178 key: 'enable', 1179 value: function enable() { 1180 var enabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; 1181 1182 this.scroll.enable(enabled); 1183 this.container.classList.toggle('ql-disabled', !enabled); 1184 } 1185 }, { 1186 key: 'focus', 1187 value: function focus() { 1188 var scrollTop = this.scrollingContainer.scrollTop; 1189 this.selection.focus(); 1190 this.scrollingContainer.scrollTop = scrollTop; 1191 this.scrollIntoView(); 1192 } 1193 }, { 1194 key: 'format', 1195 value: function format(name, value) { 1196 var _this4 = this; 1197 1198 var source = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _emitter4.default.sources.API; 1199 1200 return modify.call(this, function () { 1201 var range = _this4.getSelection(true); 1202 var change = new _quillDelta2.default(); 1203 if (range == null) { 1204 return change; 1205 } else if (_parchment2.default.query(name, _parchment2.default.Scope.BLOCK)) { 1206 change = _this4.editor.formatLine(range.index, range.length, _defineProperty({}, name, value)); 1207 } else if (range.length === 0) { 1208 _this4.selection.format(name, value); 1209 return change; 1210 } else { 1211 change = _this4.editor.formatText(range.index, range.length, _defineProperty({}, name, value)); 1212 } 1213 _this4.setSelection(range, _emitter4.default.sources.SILENT); 1214 return change; 1215 }, source); 1216 } 1217 }, { 1218 key: 'formatLine', 1219 value: function formatLine(index, length, name, value, source) { 1220 var _this5 = this; 1221 1222 var formats = void 0; 1223 1224 var _overload3 = overload(index, length, name, value, source); 1225 1226 var _overload4 = _slicedToArray(_overload3, 4); 1227 1228 index = _overload4[0]; 1229 length = _overload4[1]; 1230 formats = _overload4[2]; 1231 source = _overload4[3]; 1232 1233 return modify.call(this, function () { 1234 return _this5.editor.formatLine(index, length, formats); 1235 }, source, index, 0); 1236 } 1237 }, { 1238 key: 'formatText', 1239 value: function formatText(index, length, name, value, source) { 1240 var _this6 = this; 1241 1242 var formats = void 0; 1243 1244 var _overload5 = overload(index, length, name, value, source); 1245 1246 var _overload6 = _slicedToArray(_overload5, 4); 1247 1248 index = _overload6[0]; 1249 length = _overload6[1]; 1250 formats = _overload6[2]; 1251 source = _overload6[3]; 1252 1253 return modify.call(this, function () { 1254 return _this6.editor.formatText(index, length, formats); 1255 }, source, index, 0); 1256 } 1257 }, { 1258 key: 'getBounds', 1259 value: function getBounds(index) { 1260 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 1261 1262 var bounds = void 0; 1263 if (typeof index === 'number') { 1264 bounds = this.selection.getBounds(index, length); 1265 } else { 1266 bounds = this.selection.getBounds(index.index, index.length); 1267 } 1268 var containerBounds = this.container.getBoundingClientRect(); 1269 return { 1270 bottom: bounds.bottom - containerBounds.top, 1271 height: bounds.height, 1272 left: bounds.left - containerBounds.left, 1273 right: bounds.right - containerBounds.left, 1274 top: bounds.top - containerBounds.top, 1275 width: bounds.width 1276 }; 1277 } 1278 }, { 1279 key: 'getContents', 1280 value: function getContents() { 1281 var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; 1282 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getLength() - index; 1283 1284 var _overload7 = overload(index, length); 1285 1286 var _overload8 = _slicedToArray(_overload7, 2); 1287 1288 index = _overload8[0]; 1289 length = _overload8[1]; 1290 1291 return this.editor.getContents(index, length); 1292 } 1293 }, { 1294 key: 'getFormat', 1295 value: function getFormat() { 1296 var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getSelection(true); 1297 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 1298 1299 if (typeof index === 'number') { 1300 return this.editor.getFormat(index, length); 1301 } else { 1302 return this.editor.getFormat(index.index, index.length); 1303 } 1304 } 1305 }, { 1306 key: 'getIndex', 1307 value: function getIndex(blot) { 1308 return blot.offset(this.scroll); 1309 } 1310 }, { 1311 key: 'getLength', 1312 value: function getLength() { 1313 return this.scroll.length(); 1314 } 1315 }, { 1316 key: 'getLeaf', 1317 value: function getLeaf(index) { 1318 return this.scroll.leaf(index); 1319 } 1320 }, { 1321 key: 'getLine', 1322 value: function getLine(index) { 1323 return this.scroll.line(index); 1324 } 1325 }, { 1326 key: 'getLines', 1327 value: function getLines() { 1328 var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; 1329 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.MAX_VALUE; 1330 1331 if (typeof index !== 'number') { 1332 return this.scroll.lines(index.index, index.length); 1333 } else { 1334 return this.scroll.lines(index, length); 1335 } 1336 } 1337 }, { 1338 key: 'getModule', 1339 value: function getModule(name) { 1340 return this.theme.modules[name]; 1341 } 1342 }, { 1343 key: 'getSelection', 1344 value: function getSelection() { 1345 var focus = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; 1346 1347 if (focus) this.focus(); 1348 this.update(); // Make sure we access getRange with editor in consistent state 1349 return this.selection.getRange()[0]; 1350 } 1351 }, { 1352 key: 'getText', 1353 value: function getText() { 1354 var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; 1355 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getLength() - index; 1356 1357 var _overload9 = overload(index, length); 1358 1359 var _overload10 = _slicedToArray(_overload9, 2); 1360 1361 index = _overload10[0]; 1362 length = _overload10[1]; 1363 1364 return this.editor.getText(index, length); 1365 } 1366 }, { 1367 key: 'hasFocus', 1368 value: function hasFocus() { 1369 return this.selection.hasFocus(); 1370 } 1371 }, { 1372 key: 'insertEmbed', 1373 value: function insertEmbed(index, embed, value) { 1374 var _this7 = this; 1375 1376 var source = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : Quill.sources.API; 1377 1378 return modify.call(this, function () { 1379 return _this7.editor.insertEmbed(index, embed, value); 1380 }, source, index); 1381 } 1382 }, { 1383 key: 'insertText', 1384 value: function insertText(index, text, name, value, source) { 1385 var _this8 = this; 1386 1387 var formats = void 0; 1388 1389 var _overload11 = overload(index, 0, name, value, source); 1390 1391 var _overload12 = _slicedToArray(_overload11, 4); 1392 1393 index = _overload12[0]; 1394 formats = _overload12[2]; 1395 source = _overload12[3]; 1396 1397 return modify.call(this, function () { 1398 return _this8.editor.insertText(index, text, formats); 1399 }, source, index, text.length); 1400 } 1401 }, { 1402 key: 'isEnabled', 1403 value: function isEnabled() { 1404 return !this.container.classList.contains('ql-disabled'); 1405 } 1406 }, { 1407 key: 'off', 1408 value: function off() { 1409 return this.emitter.off.apply(this.emitter, arguments); 1410 } 1411 }, { 1412 key: 'on', 1413 value: function on() { 1414 return this.emitter.on.apply(this.emitter, arguments); 1415 } 1416 }, { 1417 key: 'once', 1418 value: function once() { 1419 return this.emitter.once.apply(this.emitter, arguments); 1420 } 1421 }, { 1422 key: 'pasteHTML', 1423 value: function pasteHTML(index, html, source) { 1424 this.clipboard.dangerouslyPasteHTML(index, html, source); 1425 } 1426 }, { 1427 key: 'removeFormat', 1428 value: function removeFormat(index, length, source) { 1429 var _this9 = this; 1430 1431 var _overload13 = overload(index, length, source); 1432 1433 var _overload14 = _slicedToArray(_overload13, 4); 1434 1435 index = _overload14[0]; 1436 length = _overload14[1]; 1437 source = _overload14[3]; 1438 1439 return modify.call(this, function () { 1440 return _this9.editor.removeFormat(index, length); 1441 }, source, index); 1442 } 1443 }, { 1444 key: 'scrollIntoView', 1445 value: function scrollIntoView() { 1446 this.selection.scrollIntoView(this.scrollingContainer); 1447 } 1448 }, { 1449 key: 'setContents', 1450 value: function setContents(delta) { 1451 var _this10 = this; 1452 1453 var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _emitter4.default.sources.API; 1454 1455 return modify.call(this, function () { 1456 delta = new _quillDelta2.default(delta); 1457 var length = _this10.getLength(); 1458 var deleted = _this10.editor.deleteText(0, length); 1459 var applied = _this10.editor.applyDelta(delta); 1460 var lastOp = applied.ops[applied.ops.length - 1]; 1461 if (lastOp != null && typeof lastOp.insert === 'string' && lastOp.insert[lastOp.insert.length - 1] === '\n') { 1462 _this10.editor.deleteText(_this10.getLength() - 1, 1); 1463 applied.delete(1); 1464 } 1465 var ret = deleted.compose(applied); 1466 return ret; 1467 }, source); 1468 } 1469 }, { 1470 key: 'setSelection', 1471 value: function setSelection(index, length, source) { 1472 if (index == null) { 1473 this.selection.setRange(null, length || Quill.sources.API); 1474 } else { 1475 var _overload15 = overload(index, length, source); 1476 1477 var _overload16 = _slicedToArray(_overload15, 4); 1478 1479 index = _overload16[0]; 1480 length = _overload16[1]; 1481 source = _overload16[3]; 1482 1483 this.selection.setRange(new _selection.Range(index, length), source); 1484 if (source !== _emitter4.default.sources.SILENT) { 1485 this.selection.scrollIntoView(this.scrollingContainer); 1486 } 1487 } 1488 } 1489 }, { 1490 key: 'setText', 1491 value: function setText(text) { 1492 var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _emitter4.default.sources.API; 1493 1494 var delta = new _quillDelta2.default().insert(text); 1495 return this.setContents(delta, source); 1496 } 1497 }, { 1498 key: 'update', 1499 value: function update() { 1500 var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _emitter4.default.sources.USER; 1501 1502 var change = this.scroll.update(source); // Will update selection before selection.update() does if text changes 1503 this.selection.update(source); 1504 return change; 1505 } 1506 }, { 1507 key: 'updateContents', 1508 value: function updateContents(delta) { 1509 var _this11 = this; 1510 1511 var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _emitter4.default.sources.API; 1512 1513 return modify.call(this, function () { 1514 delta = new _quillDelta2.default(delta); 1515 return _this11.editor.applyDelta(delta, source); 1516 }, source, true); 1517 } 1518 }]); 1519 1520 return Quill; 1521 }(); 1522 1523 Quill.DEFAULTS = { 1524 bounds: null, 1525 formats: null, 1526 modules: {}, 1527 placeholder: '', 1528 readOnly: false, 1529 scrollingContainer: null, 1530 strict: true, 1531 theme: 'default' 1532 }; 1533 Quill.events = _emitter4.default.events; 1534 Quill.sources = _emitter4.default.sources; 1535// eslint-disable-next-line no-undef 1536 Quill.version = false ? 'dev' : "1.3.6"; 1537 1538 Quill.imports = { 1539 'delta': _quillDelta2.default, 1540 'parchment': _parchment2.default, 1541 'core/module': _module2.default, 1542 'core/theme': _theme2.default 1543 }; 1544 1545 function expandConfig(container, userConfig) { 1546 userConfig = (0, _extend2.default)(true, { 1547 container: container, 1548 modules: { 1549 clipboard: true, 1550 keyboard: true, 1551 history: true 1552 } 1553 }, userConfig); 1554 if (!userConfig.theme || userConfig.theme === Quill.DEFAULTS.theme) { 1555 userConfig.theme = _theme2.default; 1556 } else { 1557 userConfig.theme = Quill.import('themes/' + userConfig.theme); 1558 if (userConfig.theme == null) { 1559 throw new Error('Invalid theme ' + userConfig.theme + '. Did you register it?'); 1560 } 1561 } 1562 var themeConfig = (0, _extend2.default)(true, {}, userConfig.theme.DEFAULTS); 1563 [themeConfig, userConfig].forEach(function (config) { 1564 config.modules = config.modules || {}; 1565 Object.keys(config.modules).forEach(function (module) { 1566 if (config.modules[module] === true) { 1567 config.modules[module] = {}; 1568 } 1569 }); 1570 }); 1571 var moduleNames = Object.keys(themeConfig.modules).concat(Object.keys(userConfig.modules)); 1572 var moduleConfig = moduleNames.reduce(function (config, name) { 1573 var moduleClass = Quill.import('modules/' + name); 1574 if (moduleClass == null) { 1575 debug.error('Cannot load ' + name + ' module. Are you sure you registered it?'); 1576 } else { 1577 config[name] = moduleClass.DEFAULTS || {}; 1578 } 1579 return config; 1580 }, {}); 1581 // Special case toolbar shorthand 1582 if (userConfig.modules != null && userConfig.modules.toolbar && userConfig.modules.toolbar.constructor !== Object) { 1583 userConfig.modules.toolbar = { 1584 container: userConfig.modules.toolbar 1585 }; 1586 } 1587 userConfig = (0, _extend2.default)(true, {}, Quill.DEFAULTS, { modules: moduleConfig }, themeConfig, userConfig); 1588 ['bounds', 'container', 'scrollingContainer'].forEach(function (key) { 1589 if (typeof userConfig[key] === 'string') { 1590 userConfig[key] = document.querySelector(userConfig[key]); 1591 } 1592 }); 1593 userConfig.modules = Object.keys(userConfig.modules).reduce(function (config, name) { 1594 if (userConfig.modules[name]) { 1595 config[name] = userConfig.modules[name]; 1596 } 1597 return config; 1598 }, {}); 1599 return userConfig; 1600 } 1601 1602// Handle selection preservation and TEXT_CHANGE emission 1603// common to modification APIs 1604 function modify(modifier, source, index, shift) { 1605 if (this.options.strict && !this.isEnabled() && source === _emitter4.default.sources.USER) { 1606 return new _quillDelta2.default(); 1607 } 1608 var range = index == null ? null : this.getSelection(); 1609 var oldDelta = this.editor.delta; 1610 var change = modifier(); 1611 if (range != null) { 1612 if (index === true) index = range.index; 1613 if (shift == null) { 1614 range = shiftRange(range, change, source); 1615 } else if (shift !== 0) { 1616 range = shiftRange(range, index, shift, source); 1617 } 1618 this.setSelection(range, _emitter4.default.sources.SILENT); 1619 } 1620 if (change.length() > 0) { 1621 var _emitter; 1622 1623 var args = [_emitter4.default.events.TEXT_CHANGE, change, oldDelta, source]; 1624 (_emitter = this.emitter).emit.apply(_emitter, [_emitter4.default.events.EDITOR_CHANGE].concat(args)); 1625 if (source !== _emitter4.default.sources.SILENT) { 1626 var _emitter2; 1627 1628 (_emitter2 = this.emitter).emit.apply(_emitter2, args); 1629 } 1630 } 1631 return change; 1632 } 1633 1634 function overload(index, length, name, value, source) { 1635 var formats = {}; 1636 if (typeof index.index === 'number' && typeof index.length === 'number') { 1637 // Allow for throwaway end (used by insertText/insertEmbed) 1638 if (typeof length !== 'number') { 1639 source = value, value = name, name = length, length = index.length, index = index.index; 1640 } else { 1641 length = index.length, index = index.index; 1642 } 1643 } else if (typeof length !== 'number') { 1644 source = value, value = name, name = length, length = 0; 1645 } 1646 // Handle format being object, two format name/value strings or excluded 1647 if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') { 1648 formats = name; 1649 source = value; 1650 } else if (typeof name === 'string') { 1651 if (value != null) { 1652 formats[name] = value; 1653 } else { 1654 source = name; 1655 } 1656 } 1657 // Handle optional source 1658 source = source || _emitter4.default.sources.API; 1659 return [index, length, formats, source]; 1660 } 1661 1662 function shiftRange(range, index, length, source) { 1663 if (range == null) return null; 1664 var start = void 0, 1665 end = void 0; 1666 if (index instanceof _quillDelta2.default) { 1667 var _map = [range.index, range.index + range.length].map(function (pos) { 1668 return index.transformPosition(pos, source !== _emitter4.default.sources.USER); 1669 }); 1670 1671 var _map2 = _slicedToArray(_map, 2); 1672 1673 start = _map2[0]; 1674 end = _map2[1]; 1675 } else { 1676 var _map3 = [range.index, range.index + range.length].map(function (pos) { 1677 if (pos < index || pos === index && source === _emitter4.default.sources.USER) return pos; 1678 if (length >= 0) { 1679 return pos + length; 1680 } else { 1681 return Math.max(index, pos + length); 1682 } 1683 }); 1684 1685 var _map4 = _slicedToArray(_map3, 2); 1686 1687 start = _map4[0]; 1688 end = _map4[1]; 1689 } 1690 return new _selection.Range(start, end - start); 1691 } 1692 1693 exports.expandConfig = expandConfig; 1694 exports.overload = overload; 1695 exports.default = Quill; 1696 1697 /***/ }), 1698 /* 6 */ 1699 /***/ (function(module, exports, __webpack_require__) { 1700 1701 "use strict"; 1702 1703 1704 Object.defineProperty(exports, "__esModule", { 1705 value: true 1706 }); 1707 1708 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 1709 1710 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 1711 1712 var _text = __webpack_require__(7); 1713 1714 var _text2 = _interopRequireDefault(_text); 1715 1716 var _parchment = __webpack_require__(0); 1717 1718 var _parchment2 = _interopRequireDefault(_parchment); 1719 1720 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 1721 1722 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 1723 1724 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 1725 1726 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 1727 1728 var Inline = function (_Parchment$Inline) { 1729 _inherits(Inline, _Parchment$Inline); 1730 1731 function Inline() { 1732 _classCallCheck(this, Inline); 1733 1734 return _possibleConstructorReturn(this, (Inline.__proto__ || Object.getPrototypeOf(Inline)).apply(this, arguments)); 1735 } 1736 1737 _createClass(Inline, [{ 1738 key: 'formatAt', 1739 value: function formatAt(index, length, name, value) { 1740 if (Inline.compare(this.statics.blotName, name) < 0 && _parchment2.default.query(name, _parchment2.default.Scope.BLOT)) { 1741 var blot = this.isolate(index, length); 1742 if (value) { 1743 blot.wrap(name, value); 1744 } 1745 } else { 1746 _get(Inline.prototype.__proto__ || Object.getPrototypeOf(Inline.prototype), 'formatAt', this).call(this, index, length, name, value); 1747 } 1748 } 1749 }, { 1750 key: 'optimize', 1751 value: function optimize(context) { 1752 _get(Inline.prototype.__proto__ || Object.getPrototypeOf(Inline.prototype), 'optimize', this).call(this, context); 1753 if (this.parent instanceof Inline && Inline.compare(this.statics.blotName, this.parent.statics.blotName) > 0) { 1754 var parent = this.parent.isolate(this.offset(), this.length()); 1755 this.moveChildren(parent); 1756 parent.wrap(this); 1757 } 1758 } 1759 }], [{ 1760 key: 'compare', 1761 value: function compare(self, other) { 1762 var selfIndex = Inline.order.indexOf(self); 1763 var otherIndex = Inline.order.indexOf(other); 1764 if (selfIndex >= 0 || otherIndex >= 0) { 1765 return selfIndex - otherIndex; 1766 } else if (self === other) { 1767 return 0; 1768 } else if (self < other) { 1769 return -1; 1770 } else { 1771 return 1; 1772 } 1773 } 1774 }]); 1775 1776 return Inline; 1777 }(_parchment2.default.Inline); 1778 1779 Inline.allowedChildren = [Inline, _parchment2.default.Embed, _text2.default]; 1780// Lower index means deeper in the DOM tree, since not found (-1) is for embeds 1781 Inline.order = ['cursor', 'inline', // Must be lower 1782 'underline', 'strike', 'italic', 'bold', 'script', 'link', 'code' // Must be higher 1783 ]; 1784 1785 exports.default = Inline; 1786 1787 /***/ }), 1788 /* 7 */ 1789 /***/ (function(module, exports, __webpack_require__) { 1790 1791 "use strict"; 1792 1793 1794 Object.defineProperty(exports, "__esModule", { 1795 value: true 1796 }); 1797 1798 var _parchment = __webpack_require__(0); 1799 1800 var _parchment2 = _interopRequireDefault(_parchment); 1801 1802 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 1803 1804 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 1805 1806 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 1807 1808 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 1809 1810 var TextBlot = function (_Parchment$Text) { 1811 _inherits(TextBlot, _Parchment$Text); 1812 1813 function TextBlot() { 1814 _classCallCheck(this, TextBlot); 1815 1816 return _possibleConstructorReturn(this, (TextBlot.__proto__ || Object.getPrototypeOf(TextBlot)).apply(this, arguments)); 1817 } 1818 1819 return TextBlot; 1820 }(_parchment2.default.Text); 1821 1822 exports.default = TextBlot; 1823 1824 /***/ }), 1825 /* 8 */ 1826 /***/ (function(module, exports, __webpack_require__) { 1827 1828 "use strict"; 1829 1830 1831 Object.defineProperty(exports, "__esModule", { 1832 value: true 1833 }); 1834 1835 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 1836 1837 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 1838 1839 var _eventemitter = __webpack_require__(54); 1840 1841 var _eventemitter2 = _interopRequireDefault(_eventemitter); 1842 1843 var _logger = __webpack_require__(10); 1844 1845 var _logger2 = _interopRequireDefault(_logger); 1846 1847 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 1848 1849 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 1850 1851 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 1852 1853 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 1854 1855 var debug = (0, _logger2.default)('quill:events'); 1856 1857 var EVENTS = ['selectionchange', 'mousedown', 'mouseup', 'click']; 1858 1859 EVENTS.forEach(function (eventName) { 1860 document.addEventListener(eventName, function () { 1861 for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { 1862 args[_key] = arguments[_key]; 1863 } 1864 1865 [].slice.call(document.querySelectorAll('.ql-container')).forEach(function (node) { 1866 // TODO use WeakMap 1867 if (node.__quill && node.__quill.emitter) { 1868 var _node$__quill$emitter; 1869 1870 (_node$__quill$emitter = node.__quill.emitter).handleDOM.apply(_node$__quill$emitter, args); 1871 } 1872 }); 1873 }); 1874 }); 1875 1876 var Emitter = function (_EventEmitter) { 1877 _inherits(Emitter, _EventEmitter); 1878 1879 function Emitter() { 1880 _classCallCheck(this, Emitter); 1881 1882 var _this = _possibleConstructorReturn(this, (Emitter.__proto__ || Object.getPrototypeOf(Emitter)).call(this)); 1883 1884 _this.listeners = {}; 1885 _this.on('error', debug.error); 1886 return _this; 1887 } 1888 1889 _createClass(Emitter, [{ 1890 key: 'emit', 1891 value: function emit() { 1892 debug.log.apply(debug, arguments); 1893 _get(Emitter.prototype.__proto__ || Object.getPrototypeOf(Emitter.prototype), 'emit', this).apply(this, arguments); 1894 } 1895 }, { 1896 key: 'handleDOM', 1897 value: function handleDOM(event) { 1898 for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 1899 args[_key2 - 1] = arguments[_key2]; 1900 } 1901 1902 (this.listeners[event.type] || []).forEach(function (_ref) { 1903 var node = _ref.node, 1904 handler = _ref.handler; 1905 1906 if (event.target === node || node.contains(event.target)) { 1907 handler.apply(undefined, [event].concat(args)); 1908 } 1909 }); 1910 } 1911 }, { 1912 key: 'listenDOM', 1913 value: function listenDOM(eventName, node, handler) { 1914 if (!this.listeners[eventName]) { 1915 this.listeners[eventName] = []; 1916 } 1917 this.listeners[eventName].push({ node: node, handler: handler }); 1918 } 1919 }]); 1920 1921 return Emitter; 1922 }(_eventemitter2.default); 1923 1924 Emitter.events = { 1925 EDITOR_CHANGE: 'editor-change', 1926 SCROLL_BEFORE_UPDATE: 'scroll-before-update', 1927 SCROLL_OPTIMIZE: 'scroll-optimize', 1928 SCROLL_UPDATE: 'scroll-update', 1929 SELECTION_CHANGE: 'selection-change', 1930 TEXT_CHANGE: 'text-change' 1931 }; 1932 Emitter.sources = { 1933 API: 'api', 1934 SILENT: 'silent', 1935 USER: 'user' 1936 }; 1937 1938 exports.default = Emitter; 1939 1940 /***/ }), 1941 /* 9 */ 1942 /***/ (function(module, exports, __webpack_require__) { 1943 1944 "use strict"; 1945 1946 1947 Object.defineProperty(exports, "__esModule", { 1948 value: true 1949 }); 1950 1951 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 1952 1953 var Module = function Module(quill) { 1954 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 1955 1956 _classCallCheck(this, Module); 1957 1958 this.quill = quill; 1959 this.options = options; 1960 }; 1961 1962 Module.DEFAULTS = {}; 1963 1964 exports.default = Module; 1965 1966 /***/ }), 1967 /* 10 */ 1968 /***/ (function(module, exports, __webpack_require__) { 1969 1970 "use strict"; 1971 1972 1973 Object.defineProperty(exports, "__esModule", { 1974 value: true 1975 }); 1976 var levels = ['error', 'warn', 'log', 'info']; 1977 var level = 'warn'; 1978 1979 function debug(method) { 1980 if (levels.indexOf(method) <= levels.indexOf(level)) { 1981 var _console; 1982 1983 for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 1984 args[_key - 1] = arguments[_key]; 1985 } 1986 1987 (_console = console)[method].apply(_console, args); // eslint-disable-line no-console 1988 } 1989 } 1990 1991 function namespace(ns) { 1992 return levels.reduce(function (logger, method) { 1993 logger[method] = debug.bind(console, method, ns); 1994 return logger; 1995 }, {}); 1996 } 1997 1998 debug.level = namespace.level = function (newLevel) { 1999 level = newLevel; 2000 }; 2001 2002 exports.default = namespace; 2003 2004 /***/ }), 2005 /* 11 */ 2006 /***/ (function(module, exports, __webpack_require__) { 2007 2008 var pSlice = Array.prototype.slice; 2009 var objectKeys = __webpack_require__(52); 2010 var isArguments = __webpack_require__(53); 2011 2012 var deepEqual = module.exports = function (actual, expected, opts) { 2013 if (!opts) opts = {}; 2014 // 7.1. All identical values are equivalent, as determined by ===. 2015 if (actual === expected) { 2016 return true; 2017 2018 } else if (actual instanceof Date && expected instanceof Date) { 2019 return actual.getTime() === expected.getTime(); 2020 2021 // 7.3. Other pairs that do not both pass typeof value == 'object', 2022 // equivalence is determined by ==. 2023 } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') { 2024 return opts.strict ? actual === expected : actual == expected; 2025 2026 // 7.4. For all other Object pairs, including Array objects, equivalence is 2027 // determined by having the same number of owned properties (as verified 2028 // with Object.prototype.hasOwnProperty.call), the same set of keys 2029 // (although not necessarily the same order), equivalent values for every 2030 // corresponding key, and an identical 'prototype' property. Note: this 2031 // accounts for both named and indexed properties on Arrays. 2032 } else { 2033 return objEquiv(actual, expected, opts); 2034 } 2035 } 2036 2037 function isUndefinedOrNull(value) { 2038 return value === null || value === undefined; 2039 } 2040 2041 function isBuffer (x) { 2042 if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false; 2043 if (typeof x.copy !== 'function' || typeof x.slice !== 'function') { 2044 return false; 2045 } 2046 if (x.length > 0 && typeof x[0] !== 'number') return false; 2047 return true; 2048 } 2049 2050 function objEquiv(a, b, opts) { 2051 var i, key; 2052 if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) 2053 return false; 2054 // an identical 'prototype' property. 2055 if (a.prototype !== b.prototype) return false; 2056 //~~~I've managed to break Object.keys through screwy arguments passing. 2057 // Converting to array solves the problem. 2058 if (isArguments(a)) { 2059 if (!isArguments(b)) { 2060 return false; 2061 } 2062 a = pSlice.call(a); 2063 b = pSlice.call(b); 2064 return deepEqual(a, b, opts); 2065 } 2066 if (isBuffer(a)) { 2067 if (!isBuffer(b)) { 2068 return false; 2069 } 2070 if (a.length !== b.length) return false; 2071 for (i = 0; i < a.length; i++) { 2072 if (a[i] !== b[i]) return false; 2073 } 2074 return true; 2075 } 2076 try { 2077 var ka = objectKeys(a), 2078 kb = objectKeys(b); 2079 } catch (e) {//happens when one is a string literal and the other isn't 2080 return false; 2081 } 2082 // having the same number of owned properties (keys incorporates 2083 // hasOwnProperty) 2084 if (ka.length != kb.length) 2085 return false; 2086 //the same set of keys (although not necessarily the same order), 2087 ka.sort(); 2088 kb.sort(); 2089 //~~~cheap key test 2090 for (i = ka.length - 1; i >= 0; i--) { 2091 if (ka[i] != kb[i]) 2092 return false; 2093 } 2094 //equivalent values for every corresponding key, and 2095 //~~~possibly expensive deep test 2096 for (i = ka.length - 1; i >= 0; i--) { 2097 key = ka[i]; 2098 if (!deepEqual(a[key], b[key], opts)) return false; 2099 } 2100 return typeof a === typeof b; 2101 } 2102 2103 2104 /***/ }), 2105 /* 12 */ 2106 /***/ (function(module, exports, __webpack_require__) { 2107 2108 "use strict"; 2109 2110 Object.defineProperty(exports, "__esModule", { value: true }); 2111 var Registry = __webpack_require__(1); 2112 var Attributor = /** @class */ (function () { 2113 function Attributor(attrName, keyName, options) { 2114 if (options === void 0) { options = {}; } 2115 this.attrName = attrName; 2116 this.keyName = keyName; 2117 var attributeBit = Registry.Scope.TYPE & Registry.Scope.ATTRIBUTE; 2118 if (options.scope != null) { 2119 // Ignore type bits, force attribute bit 2120 this.scope = (options.scope & Registry.Scope.LEVEL) | attributeBit; 2121 } 2122 else { 2123 this.scope = Registry.Scope.ATTRIBUTE; 2124 } 2125 if (options.whitelist != null) 2126 this.whitelist = options.whitelist; 2127 } 2128 Attributor.keys = function (node) { 2129 return [].map.call(node.attributes, function (item) { 2130 return item.name; 2131 }); 2132 }; 2133 Attributor.prototype.add = function (node, value) { 2134 if (!this.canAdd(node, value)) 2135 return false; 2136 node.setAttribute(this.keyName, value); 2137 return true; 2138 }; 2139 Attributor.prototype.canAdd = function (node, value) { 2140 var match = Registry.query(node, Registry.Scope.BLOT & (this.scope | Registry.Scope.TYPE)); 2141 if (match == null) 2142 return false; 2143 if (this.whitelist == null) 2144 return true; 2145 if (typeof value === 'string') { 2146 return this.whitelist.indexOf(value.replace(/["']/g, '')) > -1; 2147 } 2148 else { 2149 return this.whitelist.indexOf(value) > -1; 2150 } 2151 }; 2152 Attributor.prototype.remove = function (node) { 2153 node.removeAttribute(this.keyName); 2154 }; 2155 Attributor.prototype.value = function (node) { 2156 var value = node.getAttribute(this.keyName); 2157 if (this.canAdd(node, value) && value) { 2158 return value; 2159 } 2160 return ''; 2161 }; 2162 return Attributor; 2163 }()); 2164 exports.default = Attributor; 2165 2166 2167 /***/ }), 2168 /* 13 */ 2169 /***/ (function(module, exports, __webpack_require__) { 2170 2171 "use strict"; 2172 2173 2174 Object.defineProperty(exports, "__esModule", { 2175 value: true 2176 }); 2177 exports.default = exports.Code = undefined; 2178 2179 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 2180 2181 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 2182 2183 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 2184 2185 var _quillDelta = __webpack_require__(2); 2186 2187 var _quillDelta2 = _interopRequireDefault(_quillDelta); 2188 2189 var _parchment = __webpack_require__(0); 2190 2191 var _parchment2 = _interopRequireDefault(_parchment); 2192 2193 var _block = __webpack_require__(4); 2194 2195 var _block2 = _interopRequireDefault(_block); 2196 2197 var _inline = __webpack_require__(6); 2198 2199 var _inline2 = _interopRequireDefault(_inline); 2200 2201 var _text = __webpack_require__(7); 2202 2203 var _text2 = _interopRequireDefault(_text); 2204 2205 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 2206 2207 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 2208 2209 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 2210 2211 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 2212 2213 var Code = function (_Inline) { 2214 _inherits(Code, _Inline); 2215 2216 function Code() { 2217 _classCallCheck(this, Code); 2218 2219 return _possibleConstructorReturn(this, (Code.__proto__ || Object.getPrototypeOf(Code)).apply(this, arguments)); 2220 } 2221 2222 return Code; 2223 }(_inline2.default); 2224 2225 Code.blotName = 'code'; 2226 Code.tagName = 'CODE'; 2227 2228 var CodeBlock = function (_Block) { 2229 _inherits(CodeBlock, _Block); 2230 2231 function CodeBlock() { 2232 _classCallCheck(this, CodeBlock); 2233 2234 return _possibleConstructorReturn(this, (CodeBlock.__proto__ || Object.getPrototypeOf(CodeBlock)).apply(this, arguments)); 2235 } 2236 2237 _createClass(CodeBlock, [{ 2238 key: 'delta', 2239 value: function delta() { 2240 var _this3 = this; 2241 2242 var text = this.domNode.textContent; 2243 if (text.endsWith('\n')) { 2244 // Should always be true 2245 text = text.slice(0, -1); 2246 } 2247 return text.split('\n').reduce(function (delta, frag) { 2248 return delta.insert(frag).insert('\n', _this3.formats()); 2249 }, new _quillDelta2.default()); 2250 } 2251 }, { 2252 key: 'format', 2253 value: function format(name, value) { 2254 if (name === this.statics.blotName && value) return; 2255 2256 var _descendant = this.descendant(_text2.default, this.length() - 1), 2257 _descendant2 = _slicedToArray(_descendant, 1), 2258 text = _descendant2[0]; 2259 2260 if (text != null) { 2261 text.deleteAt(text.length() - 1, 1); 2262 } 2263 _get(CodeBlock.prototype.__proto__ || Object.getPrototypeOf(CodeBlock.prototype), 'format', this).call(this, name, value); 2264 } 2265 }, { 2266 key: 'formatAt', 2267 value: function formatAt(index, length, name, value) { 2268 if (length === 0) return; 2269 if (_parchment2.default.query(name, _parchment2.default.Scope.BLOCK) == null || name === this.statics.blotName && value === this.statics.formats(this.domNode)) { 2270 return; 2271 } 2272 var nextNewline = this.newlineIndex(index); 2273 if (nextNewline < 0 || nextNewline >= index + length) return; 2274 var prevNewline = this.newlineIndex(index, true) + 1; 2275 var isolateLength = nextNewline - prevNewline + 1; 2276 var blot = this.isolate(prevNewline, isolateLength); 2277 var next = blot.next; 2278 blot.format(name, value); 2279 if (next instanceof CodeBlock) { 2280 next.formatAt(0, index - prevNewline + length - isolateLength, name, value); 2281 } 2282 } 2283 }, { 2284 key: 'insertAt', 2285 value: function insertAt(index, value, def) { 2286 if (def != null) return; 2287 2288 var _descendant3 = this.descendant(_text2.default, index), 2289 _descendant4 = _slicedToArray(_descendant3, 2), 2290 text = _descendant4[0], 2291 offset = _descendant4[1]; 2292 2293 text.insertAt(offset, value); 2294 } 2295 }, { 2296 key: 'length', 2297 value: function length() { 2298 var length = this.domNode.textContent.length; 2299 if (!this.domNode.textContent.endsWith('\n')) { 2300 return length + 1; 2301 } 2302 return length; 2303 } 2304 }, { 2305 key: 'newlineIndex', 2306 value: function newlineIndex(searchIndex) { 2307 var reverse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 2308 2309 if (!reverse) { 2310 var offset = this.domNode.textContent.slice(searchIndex).indexOf('\n'); 2311 return offset > -1 ? searchIndex + offset : -1; 2312 } else { 2313 return this.domNode.textContent.slice(0, searchIndex).lastIndexOf('\n'); 2314 } 2315 } 2316 }, { 2317 key: 'optimize', 2318 value: function optimize(context) { 2319 if (!this.domNode.textContent.endsWith('\n')) { 2320 this.appendChild(_parchment2.default.create('text', '\n')); 2321 } 2322 _get(CodeBlock.prototype.__proto__ || Object.getPrototypeOf(CodeBlock.prototype), 'optimize', this).call(this, context); 2323 var next = this.next; 2324 if (next != null && next.prev === this && next.statics.blotName === this.statics.blotName && this.statics.formats(this.domNode) === next.statics.formats(next.domNode)) { 2325 next.optimize(context); 2326 next.moveChildren(this); 2327 next.remove(); 2328 } 2329 } 2330 }, { 2331 key: 'replace', 2332 value: function replace(target) { 2333 _get(CodeBlock.prototype.__proto__ || Object.getPrototypeOf(CodeBlock.prototype), 'replace', this).call(this, target); 2334 [].slice.call(this.domNode.querySelectorAll('*')).forEach(function (node) { 2335 var blot = _parchment2.default.find(node); 2336 if (blot == null) { 2337 node.parentNode.removeChild(node); 2338 } else if (blot instanceof _parchment2.default.Embed) { 2339 blot.remove(); 2340 } else { 2341 blot.unwrap(); 2342 } 2343 }); 2344 } 2345 }], [{ 2346 key: 'create', 2347 value: function create(value) { 2348 var domNode = _get(CodeBlock.__proto__ || Object.getPrototypeOf(CodeBlock), 'create', this).call(this, value); 2349 domNode.setAttribute('spellcheck', false); 2350 return domNode; 2351 } 2352 }, { 2353 key: 'formats', 2354 value: function formats() { 2355 return true; 2356 } 2357 }]); 2358 2359 return CodeBlock; 2360 }(_block2.default); 2361 2362 CodeBlock.blotName = 'code-block'; 2363 CodeBlock.tagName = 'PRE'; 2364 CodeBlock.TAB = ' '; 2365 2366 exports.Code = Code; 2367 exports.default = CodeBlock; 2368 2369 /***/ }), 2370 /* 14 */ 2371 /***/ (function(module, exports, __webpack_require__) { 2372 2373 "use strict"; 2374 2375 2376 Object.defineProperty(exports, "__esModule", { 2377 value: true 2378 }); 2379 2380 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 2381 2382 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 2383 2384 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 2385 2386 var _quillDelta = __webpack_require__(2); 2387 2388 var _quillDelta2 = _interopRequireDefault(_quillDelta); 2389 2390 var _op = __webpack_require__(20); 2391 2392 var _op2 = _interopRequireDefault(_op); 2393 2394 var _parchment = __webpack_require__(0); 2395 2396 var _parchment2 = _interopRequireDefault(_parchment); 2397 2398 var _code = __webpack_require__(13); 2399 2400 var _code2 = _interopRequireDefault(_code); 2401 2402 var _cursor = __webpack_require__(24); 2403 2404 var _cursor2 = _interopRequireDefault(_cursor); 2405 2406 var _block = __webpack_require__(4); 2407 2408 var _block2 = _interopRequireDefault(_block); 2409 2410 var _break = __webpack_require__(16); 2411 2412 var _break2 = _interopRequireDefault(_break); 2413 2414 var _clone = __webpack_require__(21); 2415 2416 var _clone2 = _interopRequireDefault(_clone); 2417 2418 var _deepEqual = __webpack_require__(11); 2419 2420 var _deepEqual2 = _interopRequireDefault(_deepEqual); 2421 2422 var _extend = __webpack_require__(3); 2423 2424 var _extend2 = _interopRequireDefault(_extend); 2425 2426 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 2427 2428 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } 2429 2430 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 2431 2432 var ASCII = /^[ -~]*$/; 2433 2434 var Editor = function () { 2435 function Editor(scroll) { 2436 _classCallCheck(this, Editor); 2437 2438 this.scroll = scroll; 2439 this.delta = this.getDelta(); 2440 } 2441 2442 _createClass(Editor, [{ 2443 key: 'applyDelta', 2444 value: function applyDelta(delta) { 2445 var _this = this; 2446 2447 var consumeNextNewline = false; 2448 this.scroll.update(); 2449 var scrollLength = this.scroll.length(); 2450 this.scroll.batchStart(); 2451 delta = normalizeDelta(delta); 2452 delta.reduce(function (index, op) { 2453 var length = op.retain || op.delete || op.insert.length || 1; 2454 var attributes = op.attributes || {}; 2455 if (op.insert != null) { 2456 if (typeof op.insert === 'string') { 2457 var text = op.insert; 2458 if (text.endsWith('\n') && consumeNextNewline) { 2459 consumeNextNewline = false; 2460 text = text.slice(0, -1); 2461 } 2462 if (index >= scrollLength && !text.endsWith('\n')) { 2463 consumeNextNewline = true; 2464 } 2465 _this.scroll.insertAt(index, text); 2466 2467 var _scroll$line = _this.scroll.line(index), 2468 _scroll$line2 = _slicedToArray(_scroll$line, 2), 2469 line = _scroll$line2[0], 2470 offset = _scroll$line2[1]; 2471 2472 var formats = (0, _extend2.default)({}, (0, _block.bubbleFormats)(line)); 2473 if (line instanceof _block2.default) { 2474 var _line$descendant = line.descendant(_parchment2.default.Leaf, offset), 2475 _line$descendant2 = _slicedToArray(_line$descendant, 1), 2476 leaf = _line$descendant2[0]; 2477 2478 formats = (0, _extend2.default)(formats, (0, _block.bubbleFormats)(leaf)); 2479 } 2480 attributes = _op2.default.attributes.diff(formats, attributes) || {}; 2481 } else if (_typeof(op.insert) === 'object') { 2482 var key = Object.keys(op.insert)[0]; // There should only be one key 2483 if (key == null) return index; 2484 _this.scroll.insertAt(index, key, op.insert[key]); 2485 } 2486 scrollLength += length; 2487 } 2488 Object.keys(attributes).forEach(function (name) { 2489 _this.scroll.formatAt(index, length, name, attributes[name]); 2490 }); 2491 return index + length; 2492 }, 0); 2493 delta.reduce(function (index, op) { 2494 if (typeof op.delete === 'number') { 2495 _this.scroll.deleteAt(index, op.delete); 2496 return index; 2497 } 2498 return index + (op.retain || op.insert.length || 1); 2499 }, 0); 2500 this.scroll.batchEnd(); 2501 return this.update(delta); 2502 } 2503 }, { 2504 key: 'deleteText', 2505 value: function deleteText(index, length) { 2506 this.scroll.deleteAt(index, length); 2507 return this.update(new _quillDelta2.default().retain(index).delete(length)); 2508 } 2509 }, { 2510 key: 'formatLine', 2511 value: function formatLine(index, length) { 2512 var _this2 = this; 2513 2514 var formats = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 2515 2516 this.scroll.update(); 2517 Object.keys(formats).forEach(function (format) { 2518 if (_this2.scroll.whitelist != null && !_this2.scroll.whitelist[format]) return; 2519 var lines = _this2.scroll.lines(index, Math.max(length, 1)); 2520 var lengthRemaining = length; 2521 lines.forEach(function (line) { 2522 var lineLength = line.length(); 2523 if (!(line instanceof _code2.default)) { 2524 line.format(format, formats[format]); 2525 } else { 2526 var codeIndex = index - line.offset(_this2.scroll); 2527 var codeLength = line.newlineIndex(codeIndex + lengthRemaining) - codeIndex + 1; 2528 line.formatAt(codeIndex, codeLength, format, formats[format]); 2529 } 2530 lengthRemaining -= lineLength; 2531 }); 2532 }); 2533 this.scroll.optimize(); 2534 return this.update(new _quillDelta2.default().retain(index).retain(length, (0, _clone2.default)(formats))); 2535 } 2536 }, { 2537 key: 'formatText', 2538 value: function formatText(index, length) { 2539 var _this3 = this; 2540 2541 var formats = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 2542 2543 Object.keys(formats).forEach(function (format) { 2544 _this3.scroll.formatAt(index, length, format, formats[format]); 2545 }); 2546 return this.update(new _quillDelta2.default().retain(index).retain(length, (0, _clone2.default)(formats))); 2547 } 2548 }, { 2549 key: 'getContents', 2550 value: function getContents(index, length) { 2551 return this.delta.slice(index, index + length); 2552 } 2553 }, { 2554 key: 'getDelta', 2555 value: function getDelta() { 2556 return this.scroll.lines().reduce(function (delta, line) { 2557 return delta.concat(line.delta()); 2558 }, new _quillDelta2.default()); 2559 } 2560 }, { 2561 key: 'getFormat', 2562 value: function getFormat(index) { 2563 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 2564 2565 var lines = [], 2566 leaves = []; 2567 if (length === 0) { 2568 this.scroll.path(index).forEach(function (path) { 2569 var _path = _slicedToArray(path, 1), 2570 blot = _path[0]; 2571 2572 if (blot instanceof _block2.default) { 2573 lines.push(blot); 2574 } else if (blot instanceof _parchment2.default.Leaf) { 2575 leaves.push(blot); 2576 } 2577 }); 2578 } else { 2579 lines = this.scroll.lines(index, length); 2580 leaves = this.scroll.descendants(_parchment2.default.Leaf, index, length); 2581 } 2582 var formatsArr = [lines, leaves].map(function (blots) { 2583 if (blots.length === 0) return {}; 2584 var formats = (0, _block.bubbleFormats)(blots.shift()); 2585 while (Object.keys(formats).length > 0) { 2586 var blot = blots.shift(); 2587 if (blot == null) return formats; 2588 formats = combineFormats((0, _block.bubbleFormats)(blot), formats); 2589 } 2590 return formats; 2591 }); 2592 return _extend2.default.apply(_extend2.default, formatsArr); 2593 } 2594 }, { 2595 key: 'getText', 2596 value: function getText(index, length) { 2597 return this.getContents(index, length).filter(function (op) { 2598 return typeof op.insert === 'string'; 2599 }).map(function (op) { 2600 return op.insert; 2601 }).join(''); 2602 } 2603 }, { 2604 key: 'insertEmbed', 2605 value: function insertEmbed(index, embed, value) { 2606 this.scroll.insertAt(index, embed, value); 2607 return this.update(new _quillDelta2.default().retain(index).insert(_defineProperty({}, embed, value))); 2608 } 2609 }, { 2610 key: 'insertText', 2611 value: function insertText(index, text) { 2612 var _this4 = this; 2613 2614 var formats = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 2615 2616 text = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n'); 2617 this.scroll.insertAt(index, text); 2618 Object.keys(formats).forEach(function (format) { 2619 _this4.scroll.formatAt(index, text.length, format, formats[format]); 2620 }); 2621 return this.update(new _quillDelta2.default().retain(index).insert(text, (0, _clone2.default)(formats))); 2622 } 2623 }, { 2624 key: 'isBlank', 2625 value: function isBlank() { 2626 if (this.scroll.children.length == 0) return true; 2627 if (this.scroll.children.length > 1) return false; 2628 var block = this.scroll.children.head; 2629 if (block.statics.blotName !== _block2.default.blotName) return false; 2630 if (block.children.length > 1) return false; 2631 return block.children.head instanceof _break2.default; 2632 } 2633 }, { 2634 key: 'removeFormat', 2635 value: function removeFormat(index, length) { 2636 var text = this.getText(index, length); 2637 2638 var _scroll$line3 = this.scroll.line(index + length), 2639 _scroll$line4 = _slicedToArray(_scroll$line3, 2), 2640 line = _scroll$line4[0], 2641 offset = _scroll$line4[1]; 2642 2643 var suffixLength = 0, 2644 suffix = new _quillDelta2.default(); 2645 if (line != null) { 2646 if (!(line instanceof _code2.default)) { 2647 suffixLength = line.length() - offset; 2648 } else { 2649 suffixLength = line.newlineIndex(offset) - offset + 1; 2650 } 2651 suffix = line.delta().slice(offset, offset + suffixLength - 1).insert('\n'); 2652 } 2653 var contents = this.getContents(index, length + suffixLength); 2654 var diff = contents.diff(new _quillDelta2.default().insert(text).concat(suffix)); 2655 var delta = new _quillDelta2.default().retain(index).concat(diff); 2656 return this.applyDelta(delta); 2657 } 2658 }, { 2659 key: 'update', 2660 value: function update(change) { 2661 var mutations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 2662 var cursorIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined; 2663 2664 var oldDelta = this.delta; 2665 if (mutations.length === 1 && mutations[0].type === 'characterData' && mutations[0].target.data.match(ASCII) && _parchment2.default.find(mutations[0].target)) { 2666 // Optimization for character changes 2667 var textBlot = _parchment2.default.find(mutations[0].target); 2668 var formats = (0, _block.bubbleFormats)(textBlot); 2669 var index = textBlot.offset(this.scroll); 2670 var oldValue = mutations[0].oldValue.replace(_cursor2.default.CONTENTS, ''); 2671 var oldText = new _quillDelta2.default().insert(oldValue); 2672 var newText = new _quillDelta2.default().insert(textBlot.value()); 2673 var diffDelta = new _quillDelta2.default().retain(index).concat(oldText.diff(newText, cursorIndex)); 2674 change = diffDelta.reduce(function (delta, op) { 2675 if (op.insert) { 2676 return delta.insert(op.insert, formats); 2677 } else { 2678 return delta.push(op); 2679 } 2680 }, new _quillDelta2.default()); 2681 this.delta = oldDelta.compose(change); 2682 } else { 2683 this.delta = this.getDelta(); 2684 if (!change || !(0, _deepEqual2.default)(oldDelta.compose(change), this.delta)) { 2685 change = oldDelta.diff(this.delta, cursorIndex); 2686 } 2687 } 2688 return change; 2689 } 2690 }]); 2691 2692 return Editor; 2693 }(); 2694 2695 function combineFormats(formats, combined) { 2696 return Object.keys(combined).reduce(function (merged, name) { 2697 if (formats[name] == null) return merged; 2698 if (combined[name] === formats[name]) { 2699 merged[name] = combined[name]; 2700 } else if (Array.isArray(combined[name])) { 2701 if (combined[name].indexOf(formats[name]) < 0) { 2702 merged[name] = combined[name].concat([formats[name]]); 2703 } 2704 } else { 2705 merged[name] = [combined[name], formats[name]]; 2706 } 2707 return merged; 2708 }, {}); 2709 } 2710 2711 function normalizeDelta(delta) { 2712 return delta.reduce(function (delta, op) { 2713 if (op.insert === 1) { 2714 var attributes = (0, _clone2.default)(op.attributes); 2715 delete attributes['image']; 2716 return delta.insert({ image: op.attributes.image }, attributes); 2717 } 2718 if (op.attributes != null && (op.attributes.list === true || op.attributes.bullet === true)) { 2719 op = (0, _clone2.default)(op); 2720 if (op.attributes.list) { 2721 op.attributes.list = 'ordered'; 2722 } else { 2723 op.attributes.list = 'bullet'; 2724 delete op.attributes.bullet; 2725 } 2726 } 2727 if (typeof op.insert === 'string') { 2728 var text = op.insert.replace(/\r\n/g, '\n').replace(/\r/g, '\n'); 2729 return delta.insert(text, op.attributes); 2730 } 2731 return delta.push(op); 2732 }, new _quillDelta2.default()); 2733 } 2734 2735 exports.default = Editor; 2736 2737 /***/ }), 2738 /* 15 */ 2739 /***/ (function(module, exports, __webpack_require__) { 2740 2741 "use strict"; 2742 2743 2744 Object.defineProperty(exports, "__esModule", { 2745 value: true 2746 }); 2747 exports.default = exports.Range = undefined; 2748 2749 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 2750 2751 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 2752 2753 var _parchment = __webpack_require__(0); 2754 2755 var _parchment2 = _interopRequireDefault(_parchment); 2756 2757 var _clone = __webpack_require__(21); 2758 2759 var _clone2 = _interopRequireDefault(_clone); 2760 2761 var _deepEqual = __webpack_require__(11); 2762 2763 var _deepEqual2 = _interopRequireDefault(_deepEqual); 2764 2765 var _emitter3 = __webpack_require__(8); 2766 2767 var _emitter4 = _interopRequireDefault(_emitter3); 2768 2769 var _logger = __webpack_require__(10); 2770 2771 var _logger2 = _interopRequireDefault(_logger); 2772 2773 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 2774 2775 function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } 2776 2777 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 2778 2779 var debug = (0, _logger2.default)('quill:selection'); 2780 2781 var Range = function Range(index) { 2782 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 2783 2784 _classCallCheck(this, Range); 2785 2786 this.index = index; 2787 this.length = length; 2788 }; 2789 2790 var Selection = function () { 2791 function Selection(scroll, emitter) { 2792 var _this = this; 2793 2794 _classCallCheck(this, Selection); 2795 2796 this.emitter = emitter; 2797 this.scroll = scroll; 2798 this.composing = false; 2799 this.mouseDown = false; 2800 this.root = this.scroll.domNode; 2801 this.cursor = _parchment2.default.create('cursor', this); 2802 // savedRange is last non-null range 2803 this.lastRange = this.savedRange = new Range(0, 0); 2804 this.handleComposition(); 2805 this.handleDragging(); 2806 this.emitter.listenDOM('selectionchange', document, function () { 2807 if (!_this.mouseDown) { 2808 setTimeout(_this.update.bind(_this, _emitter4.default.sources.USER), 1); 2809 } 2810 }); 2811 this.emitter.on(_emitter4.default.events.EDITOR_CHANGE, function (type, delta) { 2812 if (type === _emitter4.default.events.TEXT_CHANGE && delta.length() > 0) { 2813 _this.update(_emitter4.default.sources.SILENT); 2814 } 2815 }); 2816 this.emitter.on(_emitter4.default.events.SCROLL_BEFORE_UPDATE, function () { 2817 if (!_this.hasFocus()) return; 2818 var native = _this.getNativeRange(); 2819 if (native == null) return; 2820 if (native.start.node === _this.cursor.textNode) return; // cursor.restore() will handle 2821 // TODO unclear if this has negative side effects 2822 _this.emitter.once(_emitter4.default.events.SCROLL_UPDATE, function () { 2823 try { 2824 _this.setNativeRange(native.start.node, native.start.offset, native.end.node, native.end.offset); 2825 } catch (ignored) {} 2826 }); 2827 }); 2828 this.emitter.on(_emitter4.default.events.SCROLL_OPTIMIZE, function (mutations, context) { 2829 if (context.range) { 2830 var _context$range = context.range, 2831 startNode = _context$range.startNode, 2832 startOffset = _context$range.startOffset, 2833 endNode = _context$range.endNode, 2834 endOffset = _context$range.endOffset; 2835 2836 _this.setNativeRange(startNode, startOffset, endNode, endOffset); 2837 } 2838 }); 2839 this.update(_emitter4.default.sources.SILENT); 2840 } 2841 2842 _createClass(Selection, [{ 2843 key: 'handleComposition', 2844 value: function handleComposition() { 2845 var _this2 = this; 2846 2847 this.root.addEventListener('compositionstart', function () { 2848 _this2.composing = true; 2849 }); 2850 this.root.addEventListener('compositionend', function () { 2851 _this2.composing = false; 2852 if (_this2.cursor.parent) { 2853 var range = _this2.cursor.restore(); 2854 if (!range) return; 2855 setTimeout(function () { 2856 _this2.setNativeRange(range.startNode, range.startOffset, range.endNode, range.endOffset); 2857 }, 1); 2858 } 2859 }); 2860 } 2861 }, { 2862 key: 'handleDragging', 2863 value: function handleDragging() { 2864 var _this3 = this; 2865 2866 this.emitter.listenDOM('mousedown', document.body, function () { 2867 _this3.mouseDown = true; 2868 }); 2869 this.emitter.listenDOM('mouseup', document.body, function () { 2870 _this3.mouseDown = false; 2871 _this3.update(_emitter4.default.sources.USER); 2872 }); 2873 } 2874 }, { 2875 key: 'focus', 2876 value: function focus() { 2877 if (this.hasFocus()) return; 2878 this.root.focus(); 2879 this.setRange(this.savedRange); 2880 } 2881 }, { 2882 key: 'format', 2883 value: function format(_format, value) { 2884 if (this.scroll.whitelist != null && !this.scroll.whitelist[_format]) return; 2885 this.scroll.update(); 2886 var nativeRange = this.getNativeRange(); 2887 if (nativeRange == null || !nativeRange.native.collapsed || _parchment2.default.query(_format, _parchment2.default.Scope.BLOCK)) return; 2888 if (nativeRange.start.node !== this.cursor.textNode) { 2889 var blot = _parchment2.default.find(nativeRange.start.node, false); 2890 if (blot == null) return; 2891 // TODO Give blot ability to not split 2892 if (blot instanceof _parchment2.default.Leaf) { 2893 var after = blot.split(nativeRange.start.offset); 2894 blot.parent.insertBefore(this.cursor, after); 2895 } else { 2896 blot.insertBefore(this.cursor, nativeRange.start.node); // Should never happen 2897 } 2898 this.cursor.attach(); 2899 } 2900 this.cursor.format(_format, value); 2901 this.scroll.optimize(); 2902 this.setNativeRange(this.cursor.textNode, this.cursor.textNode.data.length); 2903 this.update(); 2904 } 2905 }, { 2906 key: 'getBounds', 2907 value: function getBounds(index) { 2908 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 2909 2910 var scrollLength = this.scroll.length(); 2911 index = Math.min(index, scrollLength - 1); 2912 length = Math.min(index + length, scrollLength - 1) - index; 2913 var node = void 0, 2914 _scroll$leaf = this.scroll.leaf(index), 2915 _scroll$leaf2 = _slicedToArray(_scroll$leaf, 2), 2916 leaf = _scroll$leaf2[0], 2917 offset = _scroll$leaf2[1]; 2918 if (leaf == null) return null; 2919 2920 var _leaf$position = leaf.position(offset, true); 2921 2922 var _leaf$position2 = _slicedToArray(_leaf$position, 2); 2923 2924 node = _leaf$position2[0]; 2925 offset = _leaf$position2[1]; 2926 2927 var range = document.createRange(); 2928 if (length > 0) { 2929 range.setStart(node, offset); 2930 2931 var _scroll$leaf3 = this.scroll.leaf(index + length); 2932 2933 var _scroll$leaf4 = _slicedToArray(_scroll$leaf3, 2); 2934 2935 leaf = _scroll$leaf4[0]; 2936 offset = _scroll$leaf4[1]; 2937 2938 if (leaf == null) return null; 2939 2940 var _leaf$position3 = leaf.position(offset, true); 2941 2942 var _leaf$position4 = _slicedToArray(_leaf$position3, 2); 2943 2944 node = _leaf$position4[0]; 2945 offset = _leaf$position4[1]; 2946 2947 range.setEnd(node, offset); 2948 return range.getBoundingClientRect(); 2949 } else { 2950 var side = 'left'; 2951 var rect = void 0; 2952 if (node instanceof Text) { 2953 if (offset < node.data.length) { 2954 range.setStart(node, offset); 2955 range.setEnd(node, offset + 1); 2956 } else { 2957 range.setStart(node, offset - 1); 2958 range.setEnd(node, offset); 2959 side = 'right'; 2960 } 2961 rect = range.getBoundingClientRect(); 2962 } else { 2963 rect = leaf.domNode.getBoundingClientRect(); 2964 if (offset > 0) side = 'right'; 2965 } 2966 return { 2967 bottom: rect.top + rect.height, 2968 height: rect.height, 2969 left: rect[side], 2970 right: rect[side], 2971 top: rect.top, 2972 width: 0 2973 }; 2974 } 2975 } 2976 }, { 2977 key: 'getNativeRange', 2978 value: function getNativeRange() { 2979 var selection = document.getSelection(); 2980 if (selection == null || selection.rangeCount <= 0) return null; 2981 var nativeRange = selection.getRangeAt(0); 2982 if (nativeRange == null) return null; 2983 var range = this.normalizeNative(nativeRange); 2984 debug.info('getNativeRange', range); 2985 return range; 2986 } 2987 }, { 2988 key: 'getRange', 2989 value: function getRange() { 2990 var normalized = this.getNativeRange(); 2991 if (normalized == null) return [null, null]; 2992 var range = this.normalizedToRange(normalized); 2993 return [range, normalized]; 2994 } 2995 }, { 2996 key: 'hasFocus', 2997 value: function hasFocus() { 2998 return document.activeElement === this.root; 2999 } 3000 }, { 3001 key: 'normalizedToRange', 3002 value: function normalizedToRange(range) { 3003 var _this4 = this; 3004 3005 var positions = [[range.start.node, range.start.offset]]; 3006 if (!range.native.collapsed) { 3007 positions.push([range.end.node, range.end.offset]); 3008 } 3009 var indexes = positions.map(function (position) { 3010 var _position = _slicedToArray(position, 2), 3011 node = _position[0], 3012 offset = _position[1]; 3013 3014 var blot = _parchment2.default.find(node, true); 3015 var index = blot.offset(_this4.scroll); 3016 if (offset === 0) { 3017 return index; 3018 } else if (blot instanceof _parchment2.default.Container) { 3019 return index + blot.length(); 3020 } else { 3021 return index + blot.index(node, offset); 3022 } 3023 }); 3024 var end = Math.min(Math.max.apply(Math, _toConsumableArray(indexes)), this.scroll.length() - 1); 3025 var start = Math.min.apply(Math, [end].concat(_toConsumableArray(indexes))); 3026 return new Range(start, end - start); 3027 } 3028 }, { 3029 key: 'normalizeNative', 3030 value: function normalizeNative(nativeRange) { 3031 if (!contains(this.root, nativeRange.startContainer) || !nativeRange.collapsed && !contains(this.root, nativeRange.endContainer)) { 3032 return null; 3033 } 3034 var range = { 3035 start: { node: nativeRange.startContainer, offset: nativeRange.startOffset }, 3036 end: { node: nativeRange.endContainer, offset: nativeRange.endOffset }, 3037 native: nativeRange 3038 }; 3039 [range.start, range.end].forEach(function (position) { 3040 var node = position.node, 3041 offset = position.offset; 3042 while (!(node instanceof Text) && node.childNodes.length > 0) { 3043 if (node.childNodes.length > offset) { 3044 node = node.childNodes[offset]; 3045 offset = 0; 3046 } else if (node.childNodes.length === offset) { 3047 node = node.lastChild; 3048 offset = node instanceof Text ? node.data.length : node.childNodes.length + 1; 3049 } else { 3050 break; 3051 } 3052 } 3053 position.node = node, position.offset = offset; 3054 }); 3055 return range; 3056 } 3057 }, { 3058 key: 'rangeToNative', 3059 value: function rangeToNative(range) { 3060 var _this5 = this; 3061 3062 var indexes = range.collapsed ? [range.index] : [range.index, range.index + range.length]; 3063 var args = []; 3064 var scrollLength = this.scroll.length(); 3065 indexes.forEach(function (index, i) { 3066 index = Math.min(scrollLength - 1, index); 3067 var node = void 0, 3068 _scroll$leaf5 = _this5.scroll.leaf(index), 3069 _scroll$leaf6 = _slicedToArray(_scroll$leaf5, 2), 3070 leaf = _scroll$leaf6[0], 3071 offset = _scroll$leaf6[1]; 3072 var _leaf$position5 = leaf.position(offset, i !== 0); 3073 3074 var _leaf$position6 = _slicedToArray(_leaf$position5, 2); 3075 3076 node = _leaf$position6[0]; 3077 offset = _leaf$position6[1]; 3078 3079 args.push(node, offset); 3080 }); 3081 if (args.length < 2) { 3082 args = args.concat(args); 3083 } 3084 return args; 3085 } 3086 }, { 3087 key: 'scrollIntoView', 3088 value: function scrollIntoView(scrollingContainer) { 3089 var range = this.lastRange; 3090 if (range == null) return; 3091 var bounds = this.getBounds(range.index, range.length); 3092 if (bounds == null) return; 3093 var limit = this.scroll.length() - 1; 3094 3095 var _scroll$line = this.scroll.line(Math.min(range.index, limit)), 3096 _scroll$line2 = _slicedToArray(_scroll$line, 1), 3097 first = _scroll$line2[0]; 3098 3099 var last = first; 3100 if (range.length > 0) { 3101 var _scroll$line3 = this.scroll.line(Math.min(range.index + range.length, limit)); 3102 3103 var _scroll$line4 = _slicedToArray(_scroll$line3, 1); 3104 3105 last = _scroll$line4[0]; 3106 } 3107 if (first == null || last == null) return; 3108 var scrollBounds = scrollingContainer.getBoundingClientRect(); 3109 if (bounds.top < scrollBounds.top) { 3110 scrollingContainer.scrollTop -= scrollBounds.top - bounds.top; 3111 } else if (bounds.bottom > scrollBounds.bottom) { 3112 scrollingContainer.scrollTop += bounds.bottom - scrollBounds.bottom; 3113 } 3114 } 3115 }, { 3116 key: 'setNativeRange', 3117 value: function setNativeRange(startNode, startOffset) { 3118 var endNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : startNode; 3119 var endOffset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : startOffset; 3120 var force = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; 3121 3122 debug.info('setNativeRange', startNode, startOffset, endNode, endOffset); 3123 if (startNode != null && (this.root.parentNode == null || startNode.parentNode == null || endNode.parentNode == null)) { 3124 return; 3125 } 3126 var selection = document.getSelection(); 3127 if (selection == null) return; 3128 if (startNode != null) { 3129 if (!this.hasFocus()) this.root.focus(); 3130 var native = (this.getNativeRange() || {}).native; 3131 if (native == null || force || startNode !== native.startContainer || startOffset !== native.startOffset || endNode !== native.endContainer || endOffset !== native.endOffset) { 3132 3133 if (startNode.tagName == "BR") { 3134 startOffset = [].indexOf.call(startNode.parentNode.childNodes, startNode); 3135 startNode = startNode.parentNode; 3136 } 3137 if (endNode.tagName == "BR") { 3138 endOffset = [].indexOf.call(endNode.parentNode.childNodes, endNode); 3139 endNode = endNode.parentNode; 3140 } 3141 var range = document.createRange(); 3142 range.setStart(startNode, startOffset); 3143 range.setEnd(endNode, endOffset); 3144 selection.removeAllRanges(); 3145 selection.addRange(range); 3146 } 3147 } else { 3148 selection.removeAllRanges(); 3149 this.root.blur(); 3150 document.body.focus(); // root.blur() not enough on IE11+Travis+SauceLabs (but not local VMs) 3151 } 3152 } 3153 }, { 3154 key: 'setRange', 3155 value: function setRange(range) { 3156 var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 3157 var source = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _emitter4.default.sources.API; 3158 3159 if (typeof force === 'string') { 3160 source = force; 3161 force = false; 3162 } 3163 debug.info('setRange', range); 3164 if (range != null) { 3165 var args = this.rangeToNative(range); 3166 this.setNativeRange.apply(this, _toConsumableArray(args).concat([force])); 3167 } else { 3168 this.setNativeRange(null); 3169 } 3170 this.update(source); 3171 } 3172 }, { 3173 key: 'update', 3174 value: function update() { 3175 var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _emitter4.default.sources.USER; 3176 3177 var oldRange = this.lastRange; 3178 3179 var _getRange = this.getRange(), 3180 _getRange2 = _slicedToArray(_getRange, 2), 3181 lastRange = _getRange2[0], 3182 nativeRange = _getRange2[1]; 3183 3184 this.lastRange = lastRange; 3185 if (this.lastRange != null) { 3186 this.savedRange = this.lastRange; 3187 } 3188 if (!(0, _deepEqual2.default)(oldRange, this.lastRange)) { 3189 var _emitter; 3190 3191 if (!this.composing && nativeRange != null && nativeRange.native.collapsed && nativeRange.start.node !== this.cursor.textNode) { 3192 this.cursor.restore(); 3193 } 3194 var args = [_emitter4.default.events.SELECTION_CHANGE, (0, _clone2.default)(this.lastRange), (0, _clone2.default)(oldRange), source]; 3195 (_emitter = this.emitter).emit.apply(_emitter, [_emitter4.default.events.EDITOR_CHANGE].concat(args)); 3196 if (source !== _emitter4.default.sources.SILENT) { 3197 var _emitter2; 3198 3199 (_emitter2 = this.emitter).emit.apply(_emitter2, args); 3200 } 3201 } 3202 } 3203 }]); 3204 3205 return Selection; 3206 }(); 3207 3208 function contains(parent, descendant) { 3209 try { 3210 // Firefox inserts inaccessible nodes around video elements 3211 descendant.parentNode; 3212 } catch (e) { 3213 return false; 3214 } 3215 // IE11 has bug with Text nodes 3216 // https://connect.microsoft.com/IE/feedback/details/780874/node-contains-is-incorrect 3217 if (descendant instanceof Text) { 3218 descendant = descendant.parentNode; 3219 } 3220 return parent.contains(descendant); 3221 } 3222 3223 exports.Range = Range; 3224 exports.default = Selection; 3225 3226 /***/ }), 3227 /* 16 */ 3228 /***/ (function(module, exports, __webpack_require__) { 3229 3230 "use strict"; 3231 3232 3233 Object.defineProperty(exports, "__esModule", { 3234 value: true 3235 }); 3236 3237 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 3238 3239 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 3240 3241 var _parchment = __webpack_require__(0); 3242 3243 var _parchment2 = _interopRequireDefault(_parchment); 3244 3245 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 3246 3247 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 3248 3249 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 3250 3251 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 3252 3253 var Break = function (_Parchment$Embed) { 3254 _inherits(Break, _Parchment$Embed); 3255 3256 function Break() { 3257 _classCallCheck(this, Break); 3258 3259 return _possibleConstructorReturn(this, (Break.__proto__ || Object.getPrototypeOf(Break)).apply(this, arguments)); 3260 } 3261 3262 _createClass(Break, [{ 3263 key: 'insertInto', 3264 value: function insertInto(parent, ref) { 3265 if (parent.children.length === 0) { 3266 _get(Break.prototype.__proto__ || Object.getPrototypeOf(Break.prototype), 'insertInto', this).call(this, parent, ref); 3267 } else { 3268 this.remove(); 3269 } 3270 } 3271 }, { 3272 key: 'length', 3273 value: function length() { 3274 return 0; 3275 } 3276 }, { 3277 key: 'value', 3278 value: function value() { 3279 return ''; 3280 } 3281 }], [{ 3282 key: 'value', 3283 value: function value() { 3284 return undefined; 3285 } 3286 }]); 3287 3288 return Break; 3289 }(_parchment2.default.Embed); 3290 3291 Break.blotName = 'break'; 3292 Break.tagName = 'BR'; 3293 3294 exports.default = Break; 3295 3296 /***/ }), 3297 /* 17 */ 3298 /***/ (function(module, exports, __webpack_require__) { 3299 3300 "use strict"; 3301 3302 var __extends = (this && this.__extends) || (function () { 3303 var extendStatics = Object.setPrototypeOf || 3304 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 3305 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 3306 return function (d, b) { 3307 extendStatics(d, b); 3308 function __() { this.constructor = d; } 3309 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 3310 }; 3311 })(); 3312 Object.defineProperty(exports, "__esModule", { value: true }); 3313 var linked_list_1 = __webpack_require__(44); 3314 var shadow_1 = __webpack_require__(30); 3315 var Registry = __webpack_require__(1); 3316 var ContainerBlot = /** @class */ (function (_super) { 3317 __extends(ContainerBlot, _super); 3318 function ContainerBlot(domNode) { 3319 var _this = _super.call(this, domNode) || this; 3320 _this.build(); 3321 return _this; 3322 } 3323 ContainerBlot.prototype.appendChild = function (other) { 3324 this.insertBefore(other); 3325 }; 3326 ContainerBlot.prototype.attach = function () { 3327 _super.prototype.attach.call(this); 3328 this.children.forEach(function (child) { 3329 child.attach(); 3330 }); 3331 }; 3332 ContainerBlot.prototype.build = function () { 3333 var _this = this; 3334 this.children = new linked_list_1.default(); 3335 // Need to be reversed for if DOM nodes already in order 3336 [].slice 3337 .call(this.domNode.childNodes) 3338 .reverse() 3339 .forEach(function (node) { 3340 try { 3341 var child = makeBlot(node); 3342 _this.insertBefore(child, _this.children.head || undefined); 3343 } 3344 catch (err) { 3345 if (err instanceof Registry.ParchmentError) 3346 return; 3347 else 3348 throw err; 3349 } 3350 }); 3351 }; 3352 ContainerBlot.prototype.deleteAt = function (index, length) { 3353 if (index === 0 && length === this.length()) { 3354 return this.remove(); 3355 } 3356 this.children.forEachAt(index, length, function (child, offset, length) { 3357 child.deleteAt(offset, length); 3358 }); 3359 }; 3360 ContainerBlot.prototype.descendant = function (criteria, index) { 3361 var _a = this.children.find(index), child = _a[0], offset = _a[1]; 3362 if ((criteria.blotName == null && criteria(child)) || 3363 (criteria.blotName != null && child instanceof criteria)) { 3364 return [child, offset]; 3365 } 3366 else if (child instanceof ContainerBlot) { 3367 return child.descendant(criteria, offset); 3368 } 3369 else { 3370 return [null, -1]; 3371 } 3372 }; 3373 ContainerBlot.prototype.descendants = function (criteria, index, length) { 3374 if (index === void 0) { index = 0; } 3375 if (length === void 0) { length = Number.MAX_VALUE; } 3376 var descendants = []; 3377 var lengthLeft = length; 3378 this.children.forEachAt(index, length, function (child, index, length) { 3379 if ((criteria.blotName == null && criteria(child)) || 3380 (criteria.blotName != null && child instanceof criteria)) { 3381 descendants.push(child); 3382 } 3383 if (child instanceof ContainerBlot) { 3384 descendants = descendants.concat(child.descendants(criteria, index, lengthLeft)); 3385 } 3386 lengthLeft -= length; 3387 }); 3388 return descendants; 3389 }; 3390 ContainerBlot.prototype.detach = function () { 3391 this.children.forEach(function (child) { 3392 child.detach(); 3393 }); 3394 _super.prototype.detach.call(this); 3395 }; 3396 ContainerBlot.prototype.formatAt = function (index, length, name, value) { 3397 this.children.forEachAt(index, length, function (child, offset, length) { 3398 child.formatAt(offset, length, name, value); 3399 }); 3400 }; 3401 ContainerBlot.prototype.insertAt = function (index, value, def) { 3402 var _a = this.children.find(index), child = _a[0], offset = _a[1]; 3403 if (child) { 3404 child.insertAt(offset, value, def); 3405 } 3406 else { 3407 var blot = def == null ? Registry.create('text', value) : Registry.create(value, def); 3408 this.appendChild(blot); 3409 } 3410 }; 3411 ContainerBlot.prototype.insertBefore = function (childBlot, refBlot) { 3412 if (this.statics.allowedChildren != null && 3413 !this.statics.allowedChildren.some(function (child) { 3414 return childBlot instanceof child; 3415 })) { 3416 throw new Registry.ParchmentError("Cannot insert " + childBlot.statics.blotName + " into " + this.statics.blotName); 3417 } 3418 childBlot.insertInto(this, refBlot); 3419 }; 3420 ContainerBlot.prototype.length = function () { 3421 return this.children.reduce(function (memo, child) { 3422 return memo + child.length(); 3423 }, 0); 3424 }; 3425 ContainerBlot.prototype.moveChildren = function (targetParent, refNode) { 3426 this.children.forEach(function (child) { 3427 targetParent.insertBefore(child, refNode); 3428 }); 3429 }; 3430 ContainerBlot.prototype.optimize = function (context) { 3431 _super.prototype.optimize.call(this, context); 3432 if (this.children.length === 0) { 3433 if (this.statics.defaultChild != null) { 3434 var child = Registry.create(this.statics.defaultChild); 3435 this.appendChild(child); 3436 child.optimize(context); 3437 } 3438 else { 3439 this.remove(); 3440 } 3441 } 3442 }; 3443 ContainerBlot.prototype.path = function (index, inclusive) { 3444 if (inclusive === void 0) { inclusive = false; } 3445 var _a = this.children.find(index, inclusive), child = _a[0], offset = _a[1]; 3446 var position = [[this, index]]; 3447 if (child instanceof ContainerBlot) { 3448 return position.concat(child.path(offset, inclusive)); 3449 } 3450 else if (child != null) { 3451 position.push([child, offset]); 3452 } 3453 return position; 3454 }; 3455 ContainerBlot.prototype.removeChild = function (child) { 3456 this.children.remove(child); 3457 }; 3458 ContainerBlot.prototype.replace = function (target) { 3459 if (target instanceof ContainerBlot) { 3460 target.moveChildren(this); 3461 } 3462 _super.prototype.replace.call(this, target); 3463 }; 3464 ContainerBlot.prototype.split = function (index, force) { 3465 if (force === void 0) { force = false; } 3466 if (!force) { 3467 if (index === 0) 3468 return this; 3469 if (index === this.length()) 3470 return this.next; 3471 } 3472 var after = this.clone(); 3473 this.parent.insertBefore(after, this.next); 3474 this.children.forEachAt(index, this.length(), function (child, offset, length) { 3475 child = child.split(offset, force); 3476 after.appendChild(child); 3477 }); 3478 return after; 3479 }; 3480 ContainerBlot.prototype.unwrap = function () { 3481 this.moveChildren(this.parent, this.next); 3482 this.remove(); 3483 }; 3484 ContainerBlot.prototype.update = function (mutations, context) { 3485 var _this = this; 3486 var addedNodes = []; 3487 var removedNodes = []; 3488 mutations.forEach(function (mutation) { 3489 if (mutation.target === _this.domNode && mutation.type === 'childList') { 3490 addedNodes.push.apply(addedNodes, mutation.addedNodes); 3491 removedNodes.push.apply(removedNodes, mutation.removedNodes); 3492 } 3493 }); 3494 removedNodes.forEach(function (node) { 3495 // Check node has actually been removed 3496 // One exception is Chrome does not immediately remove IFRAMEs 3497 // from DOM but MutationRecord is correct in its reported removal 3498 if (node.parentNode != null && 3499 // @ts-ignore 3500 node.tagName !== 'IFRAME' && 3501 document.body.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) { 3502 return; 3503 } 3504 var blot = Registry.find(node); 3505 if (blot == null) 3506 return; 3507 if (blot.domNode.parentNode == null || blot.domNode.parentNode === _this.domNode) { 3508 blot.detach(); 3509 } 3510 }); 3511 addedNodes 3512 .filter(function (node) { 3513 return node.parentNode == _this.domNode; 3514 }) 3515 .sort(function (a, b) { 3516 if (a === b) 3517 return 0; 3518 if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) { 3519 return 1; 3520 } 3521 return -1; 3522 }) 3523 .forEach(function (node) { 3524 var refBlot = null; 3525 if (node.nextSibling != null) { 3526 refBlot = Registry.find(node.nextSibling); 3527 } 3528 var blot = makeBlot(node); 3529 if (blot.next != refBlot || blot.next == null) { 3530 if (blot.parent != null) { 3531 blot.parent.removeChild(_this); 3532 } 3533 _this.insertBefore(blot, refBlot || undefined); 3534 } 3535 }); 3536 }; 3537 return ContainerBlot; 3538 }(shadow_1.default)); 3539 function makeBlot(node) { 3540 var blot = Registry.find(node); 3541 if (blot == null) { 3542 try { 3543 blot = Registry.create(node); 3544 } 3545 catch (e) { 3546 blot = Registry.create(Registry.Scope.INLINE); 3547 [].slice.call(node.childNodes).forEach(function (child) { 3548 // @ts-ignore 3549 blot.domNode.appendChild(child); 3550 }); 3551 if (node.parentNode) { 3552 node.parentNode.replaceChild(blot.domNode, node); 3553 } 3554 blot.attach(); 3555 } 3556 } 3557 return blot; 3558 } 3559 exports.default = ContainerBlot; 3560 3561 3562 /***/ }), 3563 /* 18 */ 3564 /***/ (function(module, exports, __webpack_require__) { 3565 3566 "use strict"; 3567 3568 var __extends = (this && this.__extends) || (function () { 3569 var extendStatics = Object.setPrototypeOf || 3570 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 3571 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 3572 return function (d, b) { 3573 extendStatics(d, b); 3574 function __() { this.constructor = d; } 3575 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 3576 }; 3577 })(); 3578 Object.defineProperty(exports, "__esModule", { value: true }); 3579 var attributor_1 = __webpack_require__(12); 3580 var store_1 = __webpack_require__(31); 3581 var container_1 = __webpack_require__(17); 3582 var Registry = __webpack_require__(1); 3583 var FormatBlot = /** @class */ (function (_super) { 3584 __extends(FormatBlot, _super); 3585 function FormatBlot(domNode) { 3586 var _this = _super.call(this, domNode) || this; 3587 _this.attributes = new store_1.default(_this.domNode); 3588 return _this; 3589 } 3590 FormatBlot.formats = function (domNode) { 3591 if (typeof this.tagName === 'string') { 3592 return true; 3593 } 3594 else if (Array.isArray(this.tagName)) { 3595 return domNode.tagName.toLowerCase(); 3596 } 3597 return undefined; 3598 }; 3599 FormatBlot.prototype.format = function (name, value) { 3600 var format = Registry.query(name); 3601 if (format instanceof attributor_1.default) { 3602 this.attributes.attribute(format, value); 3603 } 3604 else if (value) { 3605 if (format != null && (name !== this.statics.blotName || this.formats()[name] !== value)) { 3606 this.replaceWith(name, value); 3607 } 3608 } 3609 }; 3610 FormatBlot.prototype.formats = function () { 3611 var formats = this.attributes.values(); 3612 var format = this.statics.formats(this.domNode); 3613 if (format != null) { 3614 formats[this.statics.blotName] = format; 3615 } 3616 return formats; 3617 }; 3618 FormatBlot.prototype.replaceWith = function (name, value) { 3619 var replacement = _super.prototype.replaceWith.call(this, name, value); 3620 this.attributes.copy(replacement); 3621 return replacement; 3622 }; 3623 FormatBlot.prototype.update = function (mutations, context) { 3624 var _this = this; 3625 _super.prototype.update.call(this, mutations, context); 3626 if (mutations.some(function (mutation) { 3627 return mutation.target === _this.domNode && mutation.type === 'attributes'; 3628 })) { 3629 this.attributes.build(); 3630 } 3631 }; 3632 FormatBlot.prototype.wrap = function (name, value) { 3633 var wrapper = _super.prototype.wrap.call(this, name, value); 3634 if (wrapper instanceof FormatBlot && wrapper.statics.scope === this.statics.scope) { 3635 this.attributes.move(wrapper); 3636 } 3637 return wrapper; 3638 }; 3639 return FormatBlot; 3640 }(container_1.default)); 3641 exports.default = FormatBlot; 3642 3643 3644 /***/ }), 3645 /* 19 */ 3646 /***/ (function(module, exports, __webpack_require__) { 3647 3648 "use strict"; 3649 3650 var __extends = (this && this.__extends) || (function () { 3651 var extendStatics = Object.setPrototypeOf || 3652 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 3653 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 3654 return function (d, b) { 3655 extendStatics(d, b); 3656 function __() { this.constructor = d; } 3657 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 3658 }; 3659 })(); 3660 Object.defineProperty(exports, "__esModule", { value: true }); 3661 var shadow_1 = __webpack_require__(30); 3662 var Registry = __webpack_require__(1); 3663 var LeafBlot = /** @class */ (function (_super) { 3664 __extends(LeafBlot, _super); 3665 function LeafBlot() { 3666 return _super !== null && _super.apply(this, arguments) || this; 3667 } 3668 LeafBlot.value = function (domNode) { 3669 return true; 3670 }; 3671 LeafBlot.prototype.index = function (node, offset) { 3672 if (this.domNode === node || 3673 this.domNode.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) { 3674 return Math.min(offset, 1); 3675 } 3676 return -1; 3677 }; 3678 LeafBlot.prototype.position = function (index, inclusive) { 3679 var offset = [].indexOf.call(this.parent.domNode.childNodes, this.domNode); 3680 if (index > 0) 3681 offset += 1; 3682 return [this.parent.domNode, offset]; 3683 }; 3684 LeafBlot.prototype.value = function () { 3685 return _a = {}, _a[this.statics.blotName] = this.statics.value(this.domNode) || true, _a; 3686 var _a; 3687 }; 3688 LeafBlot.scope = Registry.Scope.INLINE_BLOT; 3689 return LeafBlot; 3690 }(shadow_1.default)); 3691 exports.default = LeafBlot; 3692 3693 3694 /***/ }), 3695 /* 20 */ 3696 /***/ (function(module, exports, __webpack_require__) { 3697 3698 var equal = __webpack_require__(11); 3699 var extend = __webpack_require__(3); 3700 3701 3702 var lib = { 3703 attributes: { 3704 compose: function (a, b, keepNull) { 3705 if (typeof a !== 'object') a = {}; 3706 if (typeof b !== 'object') b = {}; 3707 var attributes = extend(true, {}, b); 3708 if (!keepNull) { 3709 attributes = Object.keys(attributes).reduce(function (copy, key) { 3710 if (attributes[key] != null) { 3711 copy[key] = attributes[key]; 3712 } 3713 return copy; 3714 }, {}); 3715 } 3716 for (var key in a) { 3717 if (a[key] !== undefined && b[key] === undefined) { 3718 attributes[key] = a[key]; 3719 } 3720 } 3721 return Object.keys(attributes).length > 0 ? attributes : undefined; 3722 }, 3723 3724 diff: function(a, b) { 3725 if (typeof a !== 'object') a = {}; 3726 if (typeof b !== 'object') b = {}; 3727 var attributes = Object.keys(a).concat(Object.keys(b)).reduce(function (attributes, key) { 3728 if (!equal(a[key], b[key])) { 3729 attributes[key] = b[key] === undefined ? null : b[key]; 3730 } 3731 return attributes; 3732 }, {}); 3733 return Object.keys(attributes).length > 0 ? attributes : undefined; 3734 }, 3735 3736 transform: function (a, b, priority) { 3737 if (typeof a !== 'object') return b; 3738 if (typeof b !== 'object') return undefined; 3739 if (!priority) return b; // b simply overwrites us without priority 3740 var attributes = Object.keys(b).reduce(function (attributes, key) { 3741 if (a[key] === undefined) attributes[key] = b[key]; // null is a valid value 3742 return attributes; 3743 }, {}); 3744 return Object.keys(attributes).length > 0 ? attributes : undefined; 3745 } 3746 }, 3747 3748 iterator: function (ops) { 3749 return new Iterator(ops); 3750 }, 3751 3752 length: function (op) { 3753 if (typeof op['delete'] === 'number') { 3754 return op['delete']; 3755 } else if (typeof op.retain === 'number') { 3756 return op.retain; 3757 } else { 3758 return typeof op.insert === 'string' ? op.insert.length : 1; 3759 } 3760 } 3761 }; 3762 3763 3764 function Iterator(ops) { 3765 this.ops = ops; 3766 this.index = 0; 3767 this.offset = 0; 3768 }; 3769 3770 Iterator.prototype.hasNext = function () { 3771 return this.peekLength() < Infinity; 3772 }; 3773 3774 Iterator.prototype.next = function (length) { 3775 if (!length) length = Infinity; 3776 var nextOp = this.ops[this.index]; 3777 if (nextOp) { 3778 var offset = this.offset; 3779 var opLength = lib.length(nextOp) 3780 if (length >= opLength - offset) { 3781 length = opLength - offset; 3782 this.index += 1; 3783 this.offset = 0; 3784 } else { 3785 this.offset += length; 3786 } 3787 if (typeof nextOp['delete'] === 'number') { 3788 return { 'delete': length }; 3789 } else { 3790 var retOp = {}; 3791 if (nextOp.attributes) { 3792 retOp.attributes = nextOp.attributes; 3793 } 3794 if (typeof nextOp.retain === 'number') { 3795 retOp.retain = length; 3796 } else if (typeof nextOp.insert === 'string') { 3797 retOp.insert = nextOp.insert.substr(offset, length); 3798 } else { 3799 // offset should === 0, length should === 1 3800 retOp.insert = nextOp.insert; 3801 } 3802 return retOp; 3803 } 3804 } else { 3805 return { retain: Infinity }; 3806 } 3807 }; 3808 3809 Iterator.prototype.peek = function () { 3810 return this.ops[this.index]; 3811 }; 3812 3813 Iterator.prototype.peekLength = function () { 3814 if (this.ops[this.index]) { 3815 // Should never return 0 if our index is being managed correctly 3816 return lib.length(this.ops[this.index]) - this.offset; 3817 } else { 3818 return Infinity; 3819 } 3820 }; 3821 3822 Iterator.prototype.peekType = function () { 3823 if (this.ops[this.index]) { 3824 if (typeof this.ops[this.index]['delete'] === 'number') { 3825 return 'delete'; 3826 } else if (typeof this.ops[this.index].retain === 'number') { 3827 return 'retain'; 3828 } else { 3829 return 'insert'; 3830 } 3831 } 3832 return 'retain'; 3833 }; 3834 3835 3836 module.exports = lib; 3837 3838 3839 /***/ }), 3840 /* 21 */ 3841 /***/ (function(module, exports) { 3842 3843 var clone = (function() { 3844 'use strict'; 3845 3846 function _instanceof(obj, type) { 3847 return type != null && obj instanceof type; 3848 } 3849 3850 var nativeMap; 3851 try { 3852 nativeMap = Map; 3853 } catch(_) { 3854 // maybe a reference error because no `Map`. Give it a dummy value that no 3855 // value will ever be an instanceof. 3856 nativeMap = function() {}; 3857 } 3858 3859 var nativeSet; 3860 try { 3861 nativeSet = Set; 3862 } catch(_) { 3863 nativeSet = function() {}; 3864 } 3865 3866 var nativePromise; 3867 try { 3868 nativePromise = Promise; 3869 } catch(_) { 3870 nativePromise = function() {}; 3871 } 3872 3873 /** 3874 * Clones (copies) an Object using deep copying. 3875 * 3876 * This function supports circular references by default, but if you are certain 3877 * there are no circular references in your object, you can save some CPU time 3878 * by calling clone(obj, false). 3879 * 3880 * Caution: if `circular` is false and `parent` contains circular references, 3881 * your program may enter an infinite loop and crash. 3882 * 3883 * @param `parent` - the object to be cloned 3884 * @param `circular` - set to true if the object to be cloned may contain 3885 * circular references. (optional - true by default) 3886 * @param `depth` - set to a number if the object is only to be cloned to 3887 * a particular depth. (optional - defaults to Infinity) 3888 * @param `prototype` - sets the prototype to be used when cloning an object. 3889 * (optional - defaults to parent prototype). 3890 * @param `includeNonEnumerable` - set to true if the non-enumerable properties 3891 * should be cloned as well. Non-enumerable properties on the prototype 3892 * chain will be ignored. (optional - false by default) 3893 */ 3894 function clone(parent, circular, depth, prototype, includeNonEnumerable) { 3895 if (typeof circular === 'object') { 3896 depth = circular.depth; 3897 prototype = circular.prototype; 3898 includeNonEnumerable = circular.includeNonEnumerable; 3899 circular = circular.circular; 3900 } 3901 // maintain two arrays for circular references, where corresponding parents 3902 // and children have the same index 3903 var allParents = []; 3904 var allChildren = []; 3905 3906 var useBuffer = typeof Buffer != 'undefined'; 3907 3908 if (typeof circular == 'undefined') 3909 circular = true; 3910 3911 if (typeof depth == 'undefined') 3912 depth = Infinity; 3913 3914 // recurse this function so we don't reset allParents and allChildren 3915 function _clone(parent, depth) { 3916 // cloning null always returns null 3917 if (parent === null) 3918 return null; 3919 3920 if (depth === 0) 3921 return parent; 3922 3923 var child; 3924 var proto; 3925 if (typeof parent != 'object') { 3926 return parent; 3927 } 3928 3929 if (_instanceof(parent, nativeMap)) { 3930 child = new nativeMap(); 3931 } else if (_instanceof(parent, nativeSet)) { 3932 child = new nativeSet(); 3933 } else if (_instanceof(parent, nativePromise)) { 3934 child = new nativePromise(function (resolve, reject) { 3935 parent.then(function(value) { 3936 resolve(_clone(value, depth - 1)); 3937 }, function(err) { 3938 reject(_clone(err, depth - 1)); 3939 }); 3940 }); 3941 } else if (clone.__isArray(parent)) { 3942 child = []; 3943 } else if (clone.__isRegExp(parent)) { 3944 child = new RegExp(parent.source, __getRegExpFlags(parent)); 3945 if (parent.lastIndex) child.lastIndex = parent.lastIndex; 3946 } else if (clone.__isDate(parent)) { 3947 child = new Date(parent.getTime()); 3948 } else if (useBuffer && Buffer.isBuffer(parent)) { 3949 child = new Buffer(parent.length); 3950 parent.copy(child); 3951 return child; 3952 } else if (_instanceof(parent, Error)) { 3953 child = Object.create(parent); 3954 } else { 3955 if (typeof prototype == 'undefined') { 3956 proto = Object.getPrototypeOf(parent); 3957 child = Object.create(proto); 3958 } 3959 else { 3960 child = Object.create(prototype); 3961 proto = prototype; 3962 } 3963 } 3964 3965 if (circular) { 3966 var index = allParents.indexOf(parent); 3967 3968 if (index != -1) { 3969 return allChildren[index]; 3970 } 3971 allParents.push(parent); 3972 allChildren.push(child); 3973 } 3974 3975 if (_instanceof(parent, nativeMap)) { 3976 parent.forEach(function(value, key) { 3977 var keyChild = _clone(key, depth - 1); 3978 var valueChild = _clone(value, depth - 1); 3979 child.set(keyChild, valueChild); 3980 }); 3981 } 3982 if (_instanceof(parent, nativeSet)) { 3983 parent.forEach(function(value) { 3984 var entryChild = _clone(value, depth - 1); 3985 child.add(entryChild); 3986 }); 3987 } 3988 3989 for (var i in parent) { 3990 var attrs; 3991 if (proto) { 3992 attrs = Object.getOwnPropertyDescriptor(proto, i); 3993 } 3994 3995 if (attrs && attrs.set == null) { 3996 continue; 3997 } 3998 child[i] = _clone(parent[i], depth - 1); 3999 } 4000 4001 if (Object.getOwnPropertySymbols) { 4002 var symbols = Object.getOwnPropertySymbols(parent); 4003 for (var i = 0; i < symbols.length; i++) { 4004 // Don't need to worry about cloning a symbol because it is a primitive, 4005 // like a number or string. 4006 var symbol = symbols[i]; 4007 var descriptor = Object.getOwnPropertyDescriptor(parent, symbol); 4008 if (descriptor && !descriptor.enumerable && !includeNonEnumerable) { 4009 continue; 4010 } 4011 child[symbol] = _clone(parent[symbol], depth - 1); 4012 if (!descriptor.enumerable) { 4013 Object.defineProperty(child, symbol, { 4014 enumerable: false 4015 }); 4016 } 4017 } 4018 } 4019 4020 if (includeNonEnumerable) { 4021 var allPropertyNames = Object.getOwnPropertyNames(parent); 4022 for (var i = 0; i < allPropertyNames.length; i++) { 4023 var propertyName = allPropertyNames[i]; 4024 var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName); 4025 if (descriptor && descriptor.enumerable) { 4026 continue; 4027 } 4028 child[propertyName] = _clone(parent[propertyName], depth - 1); 4029 Object.defineProperty(child, propertyName, { 4030 enumerable: false 4031 }); 4032 } 4033 } 4034 4035 return child; 4036 } 4037 4038 return _clone(parent, depth); 4039 } 4040 4041 /** 4042 * Simple flat clone using prototype, accepts only objects, usefull for property 4043 * override on FLAT configuration object (no nested props). 4044 * 4045 * USE WITH CAUTION! This may not behave as you wish if you do not know how this 4046 * works. 4047 */ 4048 clone.clonePrototype = function clonePrototype(parent) { 4049 if (parent === null) 4050 return null; 4051 4052 var c = function () {}; 4053 c.prototype = parent; 4054 return new c(); 4055 }; 4056 4057// private utility functions 4058 4059 function __objToStr(o) { 4060 return Object.prototype.toString.call(o); 4061 } 4062 clone.__objToStr = __objToStr; 4063 4064 function __isDate(o) { 4065 return typeof o === 'object' && __objToStr(o) === '[object Date]'; 4066 } 4067 clone.__isDate = __isDate; 4068 4069 function __isArray(o) { 4070 return typeof o === 'object' && __objToStr(o) === '[object Array]'; 4071 } 4072 clone.__isArray = __isArray; 4073 4074 function __isRegExp(o) { 4075 return typeof o === 'object' && __objToStr(o) === '[object RegExp]'; 4076 } 4077 clone.__isRegExp = __isRegExp; 4078 4079 function __getRegExpFlags(re) { 4080 var flags = ''; 4081 if (re.global) flags += 'g'; 4082 if (re.ignoreCase) flags += 'i'; 4083 if (re.multiline) flags += 'm'; 4084 return flags; 4085 } 4086 clone.__getRegExpFlags = __getRegExpFlags; 4087 4088 return clone; 4089 })(); 4090 4091 if (typeof module === 'object' && module.exports) { 4092 module.exports = clone; 4093 } 4094 4095 4096 /***/ }), 4097 /* 22 */ 4098 /***/ (function(module, exports, __webpack_require__) { 4099 4100 "use strict"; 4101 4102 4103 Object.defineProperty(exports, "__esModule", { 4104 value: true 4105 }); 4106 4107 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 4108 4109 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 4110 4111 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 4112 4113 var _parchment = __webpack_require__(0); 4114 4115 var _parchment2 = _interopRequireDefault(_parchment); 4116 4117 var _emitter = __webpack_require__(8); 4118 4119 var _emitter2 = _interopRequireDefault(_emitter); 4120 4121 var _block = __webpack_require__(4); 4122 4123 var _block2 = _interopRequireDefault(_block); 4124 4125 var _break = __webpack_require__(16); 4126 4127 var _break2 = _interopRequireDefault(_break); 4128 4129 var _code = __webpack_require__(13); 4130 4131 var _code2 = _interopRequireDefault(_code); 4132 4133 var _container = __webpack_require__(25); 4134 4135 var _container2 = _interopRequireDefault(_container); 4136 4137 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 4138 4139 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 4140 4141 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 4142 4143 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 4144 4145 function isLine(blot) { 4146 return blot instanceof _block2.default || blot instanceof _block.BlockEmbed; 4147 } 4148 4149 var Scroll = function (_Parchment$Scroll) { 4150 _inherits(Scroll, _Parchment$Scroll); 4151 4152 function Scroll(domNode, config) { 4153 _classCallCheck(this, Scroll); 4154 4155 var _this = _possibleConstructorReturn(this, (Scroll.__proto__ || Object.getPrototypeOf(Scroll)).call(this, domNode)); 4156 4157 _this.emitter = config.emitter; 4158 if (Array.isArray(config.whitelist)) { 4159 _this.whitelist = config.whitelist.reduce(function (whitelist, format) { 4160 whitelist[format] = true; 4161 return whitelist; 4162 }, {}); 4163 } 4164 // Some reason fixes composition issues with character languages in Windows/Chrome, Safari 4165 _this.domNode.addEventListener('DOMNodeInserted', function () {}); 4166 _this.optimize(); 4167 _this.enable(); 4168 return _this; 4169 } 4170 4171 _createClass(Scroll, [{ 4172 key: 'batchStart', 4173 value: function batchStart() { 4174 this.batch = true; 4175 } 4176 }, { 4177 key: 'batchEnd', 4178 value: function batchEnd() { 4179 this.batch = false; 4180 this.optimize(); 4181 } 4182 }, { 4183 key: 'deleteAt', 4184 value: function deleteAt(index, length) { 4185 var _line = this.line(index), 4186 _line2 = _slicedToArray(_line, 2), 4187 first = _line2[0], 4188 offset = _line2[1]; 4189 4190 var _line3 = this.line(index + length), 4191 _line4 = _slicedToArray(_line3, 1), 4192 last = _line4[0]; 4193 4194 _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'deleteAt', this).call(this, index, length); 4195 if (last != null && first !== last && offset > 0) { 4196 if (first instanceof _block.BlockEmbed || last instanceof _block.BlockEmbed) { 4197 this.optimize(); 4198 return; 4199 } 4200 if (first instanceof _code2.default) { 4201 var newlineIndex = first.newlineIndex(first.length(), true); 4202 if (newlineIndex > -1) { 4203 first = first.split(newlineIndex + 1); 4204 if (first === last) { 4205 this.optimize(); 4206 return; 4207 } 4208 } 4209 } else if (last instanceof _code2.default) { 4210 var _newlineIndex = last.newlineIndex(0); 4211 if (_newlineIndex > -1) { 4212 last.split(_newlineIndex + 1); 4213 } 4214 } 4215 var ref = last.children.head instanceof _break2.default ? null : last.children.head; 4216 first.moveChildren(last, ref); 4217 first.remove(); 4218 } 4219 this.optimize(); 4220 } 4221 }, { 4222 key: 'enable', 4223 value: function enable() { 4224 var enabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; 4225 4226 this.domNode.setAttribute('contenteditable', enabled); 4227 } 4228 }, { 4229 key: 'formatAt', 4230 value: function formatAt(index, length, format, value) { 4231 if (this.whitelist != null && !this.whitelist[format]) return; 4232 _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'formatAt', this).call(this, index, length, format, value); 4233 this.optimize(); 4234 } 4235 }, { 4236 key: 'insertAt', 4237 value: function insertAt(index, value, def) { 4238 if (def != null && this.whitelist != null && !this.whitelist[value]) return; 4239 if (index >= this.length()) { 4240 if (def == null || _parchment2.default.query(value, _parchment2.default.Scope.BLOCK) == null) { 4241 var blot = _parchment2.default.create(this.statics.defaultChild); 4242 this.appendChild(blot); 4243 if (def == null && value.endsWith('\n')) { 4244 value = value.slice(0, -1); 4245 } 4246 blot.insertAt(0, value, def); 4247 } else { 4248 var embed = _parchment2.default.create(value, def); 4249 this.appendChild(embed); 4250 } 4251 } else { 4252 _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'insertAt', this).call(this, index, value, def); 4253 } 4254 this.optimize(); 4255 } 4256 }, { 4257 key: 'insertBefore', 4258 value: function insertBefore(blot, ref) { 4259 if (blot.statics.scope === _parchment2.default.Scope.INLINE_BLOT) { 4260 var wrapper = _parchment2.default.create(this.statics.defaultChild); 4261 wrapper.appendChild(blot); 4262 blot = wrapper; 4263 } 4264 _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'insertBefore', this).call(this, blot, ref); 4265 } 4266 }, { 4267 key: 'leaf', 4268 value: function leaf(index) { 4269 return this.path(index).pop() || [null, -1]; 4270 } 4271 }, { 4272 key: 'line', 4273 value: function line(index) { 4274 if (index === this.length()) { 4275 return this.line(index - 1); 4276 } 4277 return this.descendant(isLine, index); 4278 } 4279 }, { 4280 key: 'lines', 4281 value: function lines() { 4282 var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; 4283 var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.MAX_VALUE; 4284 4285 var getLines = function getLines(blot, index, length) { 4286 var lines = [], 4287 lengthLeft = length; 4288 blot.children.forEachAt(index, length, function (child, index, length) { 4289 if (isLine(child)) { 4290 lines.push(child); 4291 } else if (child instanceof _parchment2.default.Container) { 4292 lines = lines.concat(getLines(child, index, lengthLeft)); 4293 } 4294 lengthLeft -= length; 4295 }); 4296 return lines; 4297 }; 4298 return getLines(this, index, length); 4299 } 4300 }, { 4301 key: 'optimize', 4302 value: function optimize() { 4303 var mutations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; 4304 var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 4305 4306 if (this.batch === true) return; 4307 _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'optimize', this).call(this, mutations, context); 4308 if (mutations.length > 0) { 4309 this.emitter.emit(_emitter2.default.events.SCROLL_OPTIMIZE, mutations, context); 4310 } 4311 } 4312 }, { 4313 key: 'path', 4314 value: function path(index) { 4315 return _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'path', this).call(this, index).slice(1); // Exclude self 4316 } 4317 }, { 4318 key: 'update', 4319 value: function update(mutations) { 4320 if (this.batch === true) return; 4321 var source = _emitter2.default.sources.USER; 4322 if (typeof mutations === 'string') { 4323 source = mutations; 4324 } 4325 if (!Array.isArray(mutations)) { 4326 mutations = this.observer.takeRecords(); 4327 } 4328 if (mutations.length > 0) { 4329 this.emitter.emit(_emitter2.default.events.SCROLL_BEFORE_UPDATE, source, mutations); 4330 } 4331 _get(Scroll.prototype.__proto__ || Object.getPrototypeOf(Scroll.prototype), 'update', this).call(this, mutations.concat([])); // pass copy 4332 if (mutations.length > 0) { 4333 this.emitter.emit(_emitter2.default.events.SCROLL_UPDATE, source, mutations); 4334 } 4335 } 4336 }]); 4337 4338 return Scroll; 4339 }(_parchment2.default.Scroll); 4340 4341 Scroll.blotName = 'scroll'; 4342 Scroll.className = 'ql-editor'; 4343 Scroll.tagName = 'DIV'; 4344 Scroll.defaultChild = 'block'; 4345 Scroll.allowedChildren = [_block2.default, _block.BlockEmbed, _container2.default]; 4346 4347 exports.default = Scroll; 4348 4349 /***/ }), 4350 /* 23 */ 4351 /***/ (function(module, exports, __webpack_require__) { 4352 4353 "use strict"; 4354 4355 4356 Object.defineProperty(exports, "__esModule", { 4357 value: true 4358 }); 4359 exports.SHORTKEY = exports.default = undefined; 4360 4361 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 4362 4363 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 4364 4365 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 4366 4367 var _clone = __webpack_require__(21); 4368 4369 var _clone2 = _interopRequireDefault(_clone); 4370 4371 var _deepEqual = __webpack_require__(11); 4372 4373 var _deepEqual2 = _interopRequireDefault(_deepEqual); 4374 4375 var _extend = __webpack_require__(3); 4376 4377 var _extend2 = _interopRequireDefault(_extend); 4378 4379 var _quillDelta = __webpack_require__(2); 4380 4381 var _quillDelta2 = _interopRequireDefault(_quillDelta); 4382 4383 var _op = __webpack_require__(20); 4384 4385 var _op2 = _interopRequireDefault(_op); 4386 4387 var _parchment = __webpack_require__(0); 4388 4389 var _parchment2 = _interopRequireDefault(_parchment); 4390 4391 var _quill = __webpack_require__(5); 4392 4393 var _quill2 = _interopRequireDefault(_quill); 4394 4395 var _logger = __webpack_require__(10); 4396 4397 var _logger2 = _interopRequireDefault(_logger); 4398 4399 var _module = __webpack_require__(9); 4400 4401 var _module2 = _interopRequireDefault(_module); 4402 4403 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 4404 4405 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } 4406 4407 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 4408 4409 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 4410 4411 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 4412 4413 var debug = (0, _logger2.default)('quill:keyboard'); 4414 4415 var SHORTKEY = /Mac/i.test(navigator.platform) ? 'metaKey' : 'ctrlKey'; 4416 4417 var Keyboard = function (_Module) { 4418 _inherits(Keyboard, _Module); 4419 4420 _createClass(Keyboard, null, [{ 4421 key: 'match', 4422 value: function match(evt, binding) { 4423 binding = normalize(binding); 4424 if (['altKey', 'ctrlKey', 'metaKey', 'shiftKey'].some(function (key) { 4425 return !!binding[key] !== evt[key] && binding[key] !== null; 4426 })) { 4427 return false; 4428 } 4429 return binding.key === (evt.which || evt.keyCode); 4430 } 4431 }]); 4432 4433 function Keyboard(quill, options) { 4434 _classCallCheck(this, Keyboard); 4435 4436 var _this = _possibleConstructorReturn(this, (Keyboard.__proto__ || Object.getPrototypeOf(Keyboard)).call(this, quill, options)); 4437 4438 _this.bindings = {}; 4439 Object.keys(_this.options.bindings).forEach(function (name) { 4440 if (name === 'list autofill' && quill.scroll.whitelist != null && !quill.scroll.whitelist['list']) { 4441 return; 4442 } 4443 if (_this.options.bindings[name]) { 4444 _this.addBinding(_this.options.bindings[name]); 4445 } 4446 }); 4447 _this.addBinding({ key: Keyboard.keys.ENTER, shiftKey: null }, handleEnter); 4448 _this.addBinding({ key: Keyboard.keys.ENTER, metaKey: null, ctrlKey: null, altKey: null }, function () {}); 4449 if (/Firefox/i.test(navigator.userAgent)) { 4450 // Need to handle delete and backspace for Firefox in the general case #1171 4451 _this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: true }, handleBackspace); 4452 _this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: true }, handleDelete); 4453 } else { 4454 _this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: true, prefix: /^.?$/ }, handleBackspace); 4455 _this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: true, suffix: /^.?$/ }, handleDelete); 4456 } 4457 _this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: false }, handleDeleteRange); 4458 _this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: false }, handleDeleteRange); 4459 _this.addBinding({ key: Keyboard.keys.BACKSPACE, altKey: null, ctrlKey: null, metaKey: null, shiftKey: null }, { collapsed: true, offset: 0 }, handleBackspace); 4460 _this.listen(); 4461 return _this; 4462 } 4463 4464 _createClass(Keyboard, [{ 4465 key: 'addBinding', 4466 value: function addBinding(key) { 4467 var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 4468 var handler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 4469 4470 var binding = normalize(key); 4471 if (binding == null || binding.key == null) { 4472 return debug.warn('Attempted to add invalid keyboard binding', binding); 4473 } 4474 if (typeof context === 'function') { 4475 context = { handler: context }; 4476 } 4477 if (typeof handler === 'function') { 4478 handler = { handler: handler }; 4479 } 4480 binding = (0, _extend2.default)(binding, context, handler); 4481 this.bindings[binding.key] = this.bindings[binding.key] || []; 4482 this.bindings[binding.key].push(binding); 4483 } 4484 }, { 4485 key: 'listen', 4486 value: function listen() { 4487 var _this2 = this; 4488 4489 this.quill.root.addEventListener('keydown', function (evt) { 4490 if (evt.defaultPrevented) return; 4491 var which = evt.which || evt.keyCode; 4492 var bindings = (_this2.bindings[which] || []).filter(function (binding) { 4493 return Keyboard.match(evt, binding); 4494 }); 4495 if (bindings.length === 0) return; 4496 var range = _this2.quill.getSelection(); 4497 if (range == null || !_this2.quill.hasFocus()) return; 4498 4499 var _quill$getLine = _this2.quill.getLine(range.index), 4500 _quill$getLine2 = _slicedToArray(_quill$getLine, 2), 4501 line = _quill$getLine2[0], 4502 offset = _quill$getLine2[1]; 4503 4504 var _quill$getLeaf = _this2.quill.getLeaf(range.index), 4505 _quill$getLeaf2 = _slicedToArray(_quill$getLeaf, 2), 4506 leafStart = _quill$getLeaf2[0], 4507 offsetStart = _quill$getLeaf2[1]; 4508 4509 var _ref = range.length === 0 ? [leafStart, offsetStart] : _this2.quill.getLeaf(range.index + range.length), 4510 _ref2 = _slicedToArray(_ref, 2), 4511 leafEnd = _ref2[0], 4512 offsetEnd = _ref2[1]; 4513 4514 var prefixText = leafStart instanceof _parchment2.default.Text ? leafStart.value().slice(0, offsetStart) : ''; 4515 var suffixText = leafEnd instanceof _parchment2.default.Text ? leafEnd.value().slice(offsetEnd) : ''; 4516 var curContext = { 4517 collapsed: range.length === 0, 4518 empty: range.length === 0 && line.length() <= 1, 4519 format: _this2.quill.getFormat(range), 4520 offset: offset, 4521 prefix: prefixText, 4522 suffix: suffixText 4523 }; 4524 var prevented = bindings.some(function (binding) { 4525 if (binding.collapsed != null && binding.collapsed !== curContext.collapsed) return false; 4526 if (binding.empty != null && binding.empty !== curContext.empty) return false; 4527 if (binding.offset != null && binding.offset !== curContext.offset) return false; 4528 if (Array.isArray(binding.format)) { 4529 // any format is present 4530 if (binding.format.every(function (name) { 4531 return curContext.format[name] == null; 4532 })) { 4533 return false; 4534 } 4535 } else if (_typeof(binding.format) === 'object') { 4536 // all formats must match 4537 if (!Object.keys(binding.format).every(function (name) { 4538 if (binding.format[name] === true) return curContext.format[name] != null; 4539 if (binding.format[name] === false) return curContext.format[name] == null; 4540 return (0, _deepEqual2.default)(binding.format[name], curContext.format[name]); 4541 })) { 4542 return false; 4543 } 4544 } 4545 if (binding.prefix != null && !binding.prefix.test(curContext.prefix)) return false; 4546 if (binding.suffix != null && !binding.suffix.test(curContext.suffix)) return false; 4547 return binding.handler.call(_this2, range, curContext) !== true; 4548 }); 4549 if (prevented) { 4550 evt.preventDefault(); 4551 } 4552 }); 4553 } 4554 }]); 4555 4556 return Keyboard; 4557 }(_module2.default); 4558 4559 Keyboard.keys = { 4560 BACKSPACE: 8, 4561 TAB: 9, 4562 ENTER: 13, 4563 ESCAPE: 27, 4564 LEFT: 37, 4565 UP: 38, 4566 RIGHT: 39, 4567 DOWN: 40, 4568 DELETE: 46 4569 }; 4570 4571 Keyboard.DEFAULTS = { 4572 bindings: { 4573 'bold': makeFormatHandler('bold'), 4574 'italic': makeFormatHandler('italic'), 4575 'underline': makeFormatHandler('underline'), 4576 'indent': { 4577 // highlight tab or tab at beginning of list, indent or blockquote 4578 key: Keyboard.keys.TAB, 4579 format: ['blockquote', 'indent', 'list'], 4580 handler: function handler(range, context) { 4581 if (context.collapsed && context.offset !== 0) return true; 4582 this.quill.format('indent', '+1', _quill2.default.sources.USER); 4583 } 4584 }, 4585 'outdent': { 4586 key: Keyboard.keys.TAB, 4587 shiftKey: true, 4588 format: ['blockquote', 'indent', 'list'], 4589 // highlight tab or tab at beginning of list, indent or blockquote 4590 handler: function handler(range, context) { 4591 if (context.collapsed && context.offset !== 0) return true; 4592 this.quill.format('indent', '-1', _quill2.default.sources.USER); 4593 } 4594 }, 4595 'outdent backspace': { 4596 key: Keyboard.keys.BACKSPACE, 4597 collapsed: true, 4598 shiftKey: null, 4599 metaKey: null, 4600 ctrlKey: null, 4601 altKey: null, 4602 format: ['indent', 'list'], 4603 offset: 0, 4604 handler: function handler(range, context) { 4605 if (context.format.indent != null) { 4606 this.quill.format('indent', '-1', _quill2.default.sources.USER); 4607 } else if (context.format.list != null) { 4608 this.quill.format('list', false, _quill2.default.sources.USER); 4609 } 4610 } 4611 }, 4612 'indent code-block': makeCodeBlockHandler(true), 4613 'outdent code-block': makeCodeBlockHandler(false), 4614 'remove tab': { 4615 key: Keyboard.keys.TAB, 4616 shiftKey: true, 4617 collapsed: true, 4618 prefix: /\t$/, 4619 handler: function handler(range) { 4620 this.quill.deleteText(range.index - 1, 1, _quill2.default.sources.USER); 4621 } 4622 }, 4623 'tab': { 4624 key: Keyboard.keys.TAB, 4625 handler: function handler(range) { 4626 this.quill.history.cutoff(); 4627 var delta = new _quillDelta2.default().retain(range.index).delete(range.length).insert('\t'); 4628 this.quill.updateContents(delta, _quill2.default.sources.USER); 4629 this.quill.history.cutoff(); 4630 this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT); 4631 } 4632 }, 4633 'list empty enter': { 4634 key: Keyboard.keys.ENTER, 4635 collapsed: true, 4636 format: ['list'], 4637 empty: true, 4638 handler: function handler(range, context) { 4639 this.quill.format('list', false, _quill2.default.sources.USER); 4640 if (context.format.indent) { 4641 this.quill.format('indent', false, _quill2.default.sources.USER); 4642 } 4643 } 4644 }, 4645 'checklist enter': { 4646 key: Keyboard.keys.ENTER, 4647 collapsed: true, 4648 format: { list: 'checked' }, 4649 handler: function handler(range) { 4650 var _quill$getLine3 = this.quill.getLine(range.index), 4651 _quill$getLine4 = _slicedToArray(_quill$getLine3, 2), 4652 line = _quill$getLine4[0], 4653 offset = _quill$getLine4[1]; 4654 4655 var formats = (0, _extend2.default)({}, line.formats(), { list: 'checked' }); 4656 var delta = new _quillDelta2.default().retain(range.index).insert('\n', formats).retain(line.length() - offset - 1).retain(1, { list: 'unchecked' }); 4657 this.quill.updateContents(delta, _quill2.default.sources.USER); 4658 this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT); 4659 this.quill.scrollIntoView(); 4660 } 4661 }, 4662 'header enter': { 4663 key: Keyboard.keys.ENTER, 4664 collapsed: true, 4665 format: ['header'], 4666 suffix: /^$/, 4667 handler: function handler(range, context) { 4668 var _quill$getLine5 = this.quill.getLine(range.index), 4669 _quill$getLine6 = _slicedToArray(_quill$getLine5, 2), 4670 line = _quill$getLine6[0], 4671 offset = _quill$getLine6[1]; 4672 4673 var delta = new _quillDelta2.default().retain(range.index).insert('\n', context.format).retain(line.length() - offset - 1).retain(1, { header: null }); 4674 this.quill.updateContents(delta, _quill2.default.sources.USER); 4675 this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT); 4676 this.quill.scrollIntoView(); 4677 } 4678 }, 4679 'list autofill': { 4680 key: ' ', 4681 collapsed: true, 4682 format: { list: false }, 4683 prefix: /^\s*?(\d+\.|-|\*|\[ ?\]|\[x\])$/, 4684 handler: function handler(range, context) { 4685 var length = context.prefix.length; 4686 4687 var _quill$getLine7 = this.quill.getLine(range.index), 4688 _quill$getLine8 = _slicedToArray(_quill$getLine7, 2), 4689 line = _quill$getLine8[0], 4690 offset = _quill$getLine8[1]; 4691 4692 if (offset > length) return true; 4693 var value = void 0; 4694 switch (context.prefix.trim()) { 4695 case '[]':case '[ ]': 4696 value = 'unchecked'; 4697 break; 4698 case '[x]': 4699 value = 'checked'; 4700 break; 4701 case '-':case '*': 4702 value = 'bullet'; 4703 break; 4704 default: 4705 value = 'ordered'; 4706 } 4707 this.quill.insertText(range.index, ' ', _quill2.default.sources.USER); 4708 this.quill.history.cutoff(); 4709 var delta = new _quillDelta2.default().retain(range.index - offset).delete(length + 1).retain(line.length() - 2 - offset).retain(1, { list: value }); 4710 this.quill.updateContents(delta, _quill2.default.sources.USER); 4711 this.quill.history.cutoff(); 4712 this.quill.setSelection(range.index - length, _quill2.default.sources.SILENT); 4713 } 4714 }, 4715 'code exit': { 4716 key: Keyboard.keys.ENTER, 4717 collapsed: true, 4718 format: ['code-block'], 4719 prefix: /\n\n$/, 4720 suffix: /^\s+$/, 4721 handler: function handler(range) { 4722 var _quill$getLine9 = this.quill.getLine(range.index), 4723 _quill$getLine10 = _slicedToArray(_quill$getLine9, 2), 4724 line = _quill$getLine10[0], 4725 offset = _quill$getLine10[1]; 4726 4727 var delta = new _quillDelta2.default().retain(range.index + line.length() - offset - 2).retain(1, { 'code-block': null }).delete(1); 4728 this.quill.updateContents(delta, _quill2.default.sources.USER); 4729 } 4730 }, 4731 'embed left': makeEmbedArrowHandler(Keyboard.keys.LEFT, false), 4732 'embed left shift': makeEmbedArrowHandler(Keyboard.keys.LEFT, true), 4733 'embed right': makeEmbedArrowHandler(Keyboard.keys.RIGHT, false), 4734 'embed right shift': makeEmbedArrowHandler(Keyboard.keys.RIGHT, true) 4735 } 4736 }; 4737 4738 function makeEmbedArrowHandler(key, shiftKey) { 4739 var _ref3; 4740 4741 var where = key === Keyboard.keys.LEFT ? 'prefix' : 'suffix'; 4742 return _ref3 = { 4743 key: key, 4744 shiftKey: shiftKey, 4745 altKey: null 4746 }, _defineProperty(_ref3, where, /^$/), _defineProperty(_ref3, 'handler', function handler(range) { 4747 var index = range.index; 4748 if (key === Keyboard.keys.RIGHT) { 4749 index += range.length + 1; 4750 } 4751 4752 var _quill$getLeaf3 = this.quill.getLeaf(index), 4753 _quill$getLeaf4 = _slicedToArray(_quill$getLeaf3, 1), 4754 leaf = _quill$getLeaf4[0]; 4755 4756 if (!(leaf instanceof _parchment2.default.Embed)) return true; 4757 if (key === Keyboard.keys.LEFT) { 4758 if (shiftKey) { 4759 this.quill.setSelection(range.index - 1, range.length + 1, _quill2.default.sources.USER); 4760 } else { 4761 this.quill.setSelection(range.index - 1, _quill2.default.sources.USER); 4762 } 4763 } else { 4764 if (shiftKey) { 4765 this.quill.setSelection(range.index, range.length + 1, _quill2.default.sources.USER); 4766 } else { 4767 this.quill.setSelection(range.index + range.length + 1, _quill2.default.sources.USER); 4768 } 4769 } 4770 return false; 4771 }), _ref3; 4772 } 4773 4774 function handleBackspace(range, context) { 4775 if (range.index === 0 || this.quill.getLength() <= 1) return; 4776 4777 var _quill$getLine11 = this.quill.getLine(range.index), 4778 _quill$getLine12 = _slicedToArray(_quill$getLine11, 1), 4779 line = _quill$getLine12[0]; 4780 4781 var formats = {}; 4782 if (context.offset === 0) { 4783 var _quill$getLine13 = this.quill.getLine(range.index - 1), 4784 _quill$getLine14 = _slicedToArray(_quill$getLine13, 1), 4785 prev = _quill$getLine14[0]; 4786 4787 if (prev != null && prev.length() > 1) { 4788 var curFormats = line.formats(); 4789 var prevFormats = this.quill.getFormat(range.index - 1, 1); 4790 formats = _op2.default.attributes.diff(curFormats, prevFormats) || {}; 4791 } 4792 } 4793 // Check for astral symbols 4794 var length = /[\uD800-\uDBFF][\uDC00-\uDFFF]$/.test(context.prefix) ? 2 : 1; 4795 this.quill.deleteText(range.index - length, length, _quill2.default.sources.USER); 4796 if (Object.keys(formats).length > 0) { 4797 this.quill.formatLine(range.index - length, length, formats, _quill2.default.sources.USER); 4798 } 4799 this.quill.focus(); 4800 } 4801 4802 function handleDelete(range, context) { 4803 // Check for astral symbols 4804 var length = /^[\uD800-\uDBFF][\uDC00-\uDFFF]/.test(context.suffix) ? 2 : 1; 4805 if (range.index >= this.quill.getLength() - length) return; 4806 var formats = {}, 4807 nextLength = 0; 4808 4809 var _quill$getLine15 = this.quill.getLine(range.index), 4810 _quill$getLine16 = _slicedToArray(_quill$getLine15, 1), 4811 line = _quill$getLine16[0]; 4812 4813 if (context.offset >= line.length() - 1) { 4814 var _quill$getLine17 = this.quill.getLine(range.index + 1), 4815 _quill$getLine18 = _slicedToArray(_quill$getLine17, 1), 4816 next = _quill$getLine18[0]; 4817 4818 if (next) { 4819 var curFormats = line.formats(); 4820 var nextFormats = this.quill.getFormat(range.index, 1); 4821 formats = _op2.default.attributes.diff(curFormats, nextFormats) || {}; 4822 nextLength = next.length(); 4823 } 4824 } 4825 this.quill.deleteText(range.index, length, _quill2.default.sources.USER); 4826 if (Object.keys(formats).length > 0) { 4827 this.quill.formatLine(range.index + nextLength - 1, length, formats, _quill2.default.sources.USER); 4828 } 4829 } 4830 4831 function handleDeleteRange(range) { 4832 var lines = this.quill.getLines(range); 4833 var formats = {}; 4834 if (lines.length > 1) { 4835 var firstFormats = lines[0].formats(); 4836 var lastFormats = lines[lines.length - 1].formats(); 4837 formats = _op2.default.attributes.diff(lastFormats, firstFormats) || {}; 4838 } 4839 this.quill.deleteText(range, _quill2.default.sources.USER); 4840 if (Object.keys(formats).length > 0) { 4841 this.quill.formatLine(range.index, 1, formats, _quill2.default.sources.USER); 4842 } 4843 this.quill.setSelection(range.index, _quill2.default.sources.SILENT); 4844 this.quill.focus(); 4845 } 4846 4847 function handleEnter(range, context) { 4848 var _this3 = this; 4849 4850 if (range.length > 0) { 4851 this.quill.scroll.deleteAt(range.index, range.length); // So we do not trigger text-change 4852 } 4853 var lineFormats = Object.keys(context.format).reduce(function (lineFormats, format) { 4854 if (_parchment2.default.query(format, _parchment2.default.Scope.BLOCK) && !Array.isArray(context.format[format])) { 4855 lineFormats[format] = context.format[format]; 4856 } 4857 return lineFormats; 4858 }, {}); 4859 this.quill.insertText(range.index, '\n', lineFormats, _quill2.default.sources.USER); 4860 // Earlier scroll.deleteAt might have messed up our selection, 4861 // so insertText's built in selection preservation is not reliable 4862 this.quill.setSelection(range.index + 1, _quill2.default.sources.SILENT); 4863 this.quill.focus(); 4864 Object.keys(context.format).forEach(function (name) { 4865 if (lineFormats[name] != null) return; 4866 if (Array.isArray(context.format[name])) return; 4867 if (name === 'link') return; 4868 _this3.quill.format(name, context.format[name], _quill2.default.sources.USER); 4869 }); 4870 } 4871 4872 function makeCodeBlockHandler(indent) { 4873 return { 4874 key: Keyboard.keys.TAB, 4875 shiftKey: !indent, 4876 format: { 'code-block': true }, 4877 handler: function handler(range) { 4878 var CodeBlock = _parchment2.default.query('code-block'); 4879 var index = range.index, 4880 length = range.length; 4881 4882 var _quill$scroll$descend = this.quill.scroll.descendant(CodeBlock, index), 4883 _quill$scroll$descend2 = _slicedToArray(_quill$scroll$descend, 2), 4884 block = _quill$scroll$descend2[0], 4885 offset = _quill$scroll$descend2[1]; 4886 4887 if (block == null) return; 4888 var scrollIndex = this.quill.getIndex(block); 4889 var start = block.newlineIndex(offset, true) + 1; 4890 var end = block.newlineIndex(scrollIndex + offset + length); 4891 var lines = block.domNode.textContent.slice(start, end).split('\n'); 4892 offset = 0; 4893 lines.forEach(function (line, i) { 4894 if (indent) { 4895 block.insertAt(start + offset, CodeBlock.TAB); 4896 offset += CodeBlock.TAB.length; 4897 if (i === 0) { 4898 index += CodeBlock.TAB.length; 4899 } else { 4900 length += CodeBlock.TAB.length; 4901 } 4902 } else if (line.startsWith(CodeBlock.TAB)) { 4903 block.deleteAt(start + offset, CodeBlock.TAB.length); 4904 offset -= CodeBlock.TAB.length; 4905 if (i === 0) { 4906 index -= CodeBlock.TAB.length; 4907 } else { 4908 length -= CodeBlock.TAB.length; 4909 } 4910 } 4911 offset += line.length + 1; 4912 }); 4913 this.quill.update(_quill2.default.sources.USER); 4914 this.quill.setSelection(index, length, _quill2.default.sources.SILENT); 4915 } 4916 }; 4917 } 4918 4919 function makeFormatHandler(format) { 4920 return { 4921 key: format[0].toUpperCase(), 4922 shortKey: true, 4923 handler: function handler(range, context) { 4924 this.quill.format(format, !context.format[format], _quill2.default.sources.USER); 4925 } 4926 }; 4927 } 4928 4929 function normalize(binding) { 4930 if (typeof binding === 'string' || typeof binding === 'number') { 4931 return normalize({ key: binding }); 4932 } 4933 if ((typeof binding === 'undefined' ? 'undefined' : _typeof(binding)) === 'object') { 4934 binding = (0, _clone2.default)(binding, false); 4935 } 4936 if (typeof binding.key === 'string') { 4937 if (Keyboard.keys[binding.key.toUpperCase()] != null) { 4938 binding.key = Keyboard.keys[binding.key.toUpperCase()]; 4939 } else if (binding.key.length === 1) { 4940 binding.key = binding.key.toUpperCase().charCodeAt(0); 4941 } else { 4942 return null; 4943 } 4944 } 4945 if (binding.shortKey) { 4946 binding[SHORTKEY] = binding.shortKey; 4947 delete binding.shortKey; 4948 } 4949 return binding; 4950 } 4951 4952 exports.default = Keyboard; 4953 exports.SHORTKEY = SHORTKEY; 4954 4955 /***/ }), 4956 /* 24 */ 4957 /***/ (function(module, exports, __webpack_require__) { 4958 4959 "use strict"; 4960 4961 4962 Object.defineProperty(exports, "__esModule", { 4963 value: true 4964 }); 4965 4966 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 4967 4968 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 4969 4970 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 4971 4972 var _parchment = __webpack_require__(0); 4973 4974 var _parchment2 = _interopRequireDefault(_parchment); 4975 4976 var _text = __webpack_require__(7); 4977 4978 var _text2 = _interopRequireDefault(_text); 4979 4980 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 4981 4982 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 4983 4984 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 4985 4986 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 4987 4988 var Cursor = function (_Parchment$Embed) { 4989 _inherits(Cursor, _Parchment$Embed); 4990 4991 _createClass(Cursor, null, [{ 4992 key: 'value', 4993 value: function value() { 4994 return undefined; 4995 } 4996 }]); 4997 4998 function Cursor(domNode, selection) { 4999 _classCallCheck(this, Cursor); 5000 5001 var _this = _possibleConstructorReturn(this, (Cursor.__proto__ || Object.getPrototypeOf(Cursor)).call(this, domNode)); 5002 5003 _this.selection = selection; 5004 _this.textNode = document.createTextNode(Cursor.CONTENTS); 5005 _this.domNode.appendChild(_this.textNode); 5006 _this._length = 0; 5007 return _this; 5008 } 5009 5010 _createClass(Cursor, [{ 5011 key: 'detach', 5012 value: function detach() { 5013 // super.detach() will also clear domNode.__blot 5014 if (this.parent != null) this.parent.removeChild(this); 5015 } 5016 }, { 5017 key: 'format', 5018 value: function format(name, value) { 5019 if (this._length !== 0) { 5020 return _get(Cursor.prototype.__proto__ || Object.getPrototypeOf(Cursor.prototype), 'format', this).call(this, name, value); 5021 } 5022 var target = this, 5023 index = 0; 5024 while (target != null && target.statics.scope !== _parchment2.default.Scope.BLOCK_BLOT) { 5025 index += target.offset(target.parent); 5026 target = target.parent; 5027 } 5028 if (target != null) { 5029 this._length = Cursor.CONTENTS.length; 5030 target.optimize(); 5031 target.formatAt(index, Cursor.CONTENTS.length, name, value); 5032 this._length = 0; 5033 } 5034 } 5035 }, { 5036 key: 'index', 5037 value: function index(node, offset) { 5038 if (node === this.textNode) return 0; 5039 return _get(Cursor.prototype.__proto__ || Object.getPrototypeOf(Cursor.prototype), 'index', this).call(this, node, offset); 5040 } 5041 }, { 5042 key: 'length', 5043 value: function length() { 5044 return this._length; 5045 } 5046 }, { 5047 key: 'position', 5048 value: function position() { 5049 return [this.textNode, this.textNode.data.length]; 5050 } 5051 }, { 5052 key: 'remove', 5053 value: function remove() { 5054 _get(Cursor.prototype.__proto__ || Object.getPrototypeOf(Cursor.prototype), 'remove', this).call(this); 5055 this.parent = null; 5056 } 5057 }, { 5058 key: 'restore', 5059 value: function restore() { 5060 if (this.selection.composing || this.parent == null) return; 5061 var textNode = this.textNode; 5062 var range = this.selection.getNativeRange(); 5063 var restoreText = void 0, 5064 start = void 0, 5065 end = void 0; 5066 if (range != null && range.start.node === textNode && range.end.node === textNode) { 5067 var _ref = [textNode, range.start.offset, range.end.offset]; 5068 restoreText = _ref[0]; 5069 start = _ref[1]; 5070 end = _ref[2]; 5071 } 5072 // Link format will insert text outside of anchor tag 5073 while (this.domNode.lastChild != null && this.domNode.lastChild !== this.textNode) { 5074 this.domNode.parentNode.insertBefore(this.domNode.lastChild, this.domNode); 5075 } 5076 if (this.textNode.data !== Cursor.CONTENTS) { 5077 var text = this.textNode.data.split(Cursor.CONTENTS).join(''); 5078 if (this.next instanceof _text2.default) { 5079 restoreText = this.next.domNode; 5080 this.next.insertAt(0, text); 5081 this.textNode.data = Cursor.CONTENTS; 5082 } else { 5083 this.textNode.data = text; 5084 this.parent.insertBefore(_parchment2.default.create(this.textNode), this); 5085 this.textNode = document.createTextNode(Cursor.CONTENTS); 5086 this.domNode.appendChild(this.textNode); 5087 } 5088 } 5089 this.remove(); 5090 if (start != null) { 5091 var _map = [start, end].map(function (offset) { 5092 return Math.max(0, Math.min(restoreText.data.length, offset - 1)); 5093 }); 5094 5095 var _map2 = _slicedToArray(_map, 2); 5096 5097 start = _map2[0]; 5098 end = _map2[1]; 5099 5100 return { 5101 startNode: restoreText, 5102 startOffset: start, 5103 endNode: restoreText, 5104 endOffset: end 5105 }; 5106 } 5107 } 5108 }, { 5109 key: 'update', 5110 value: function update(mutations, context) { 5111 var _this2 = this; 5112 5113 if (mutations.some(function (mutation) { 5114 return mutation.type === 'characterData' && mutation.target === _this2.textNode; 5115 })) { 5116 var range = this.restore(); 5117 if (range) context.range = range; 5118 } 5119 } 5120 }, { 5121 key: 'value', 5122 value: function value() { 5123 return ''; 5124 } 5125 }]); 5126 5127 return Cursor; 5128 }(_parchment2.default.Embed); 5129 5130 Cursor.blotName = 'cursor'; 5131 Cursor.className = 'ql-cursor'; 5132 Cursor.tagName = 'span'; 5133 Cursor.CONTENTS = '\uFEFF'; // Zero width no break space 5134 5135 5136 exports.default = Cursor; 5137 5138 /***/ }), 5139 /* 25 */ 5140 /***/ (function(module, exports, __webpack_require__) { 5141 5142 "use strict"; 5143 5144 5145 Object.defineProperty(exports, "__esModule", { 5146 value: true 5147 }); 5148 5149 var _parchment = __webpack_require__(0); 5150 5151 var _parchment2 = _interopRequireDefault(_parchment); 5152 5153 var _block = __webpack_require__(4); 5154 5155 var _block2 = _interopRequireDefault(_block); 5156 5157 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 5158 5159 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 5160 5161 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 5162 5163 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 5164 5165 var Container = function (_Parchment$Container) { 5166 _inherits(Container, _Parchment$Container); 5167 5168 function Container() { 5169 _classCallCheck(this, Container); 5170 5171 return _possibleConstructorReturn(this, (Container.__proto__ || Object.getPrototypeOf(Container)).apply(this, arguments)); 5172 } 5173 5174 return Container; 5175 }(_parchment2.default.Container); 5176 5177 Container.allowedChildren = [_block2.default, _block.BlockEmbed, Container]; 5178 5179 exports.default = Container; 5180 5181 /***/ }), 5182 /* 26 */ 5183 /***/ (function(module, exports, __webpack_require__) { 5184 5185 "use strict"; 5186 5187 5188 Object.defineProperty(exports, "__esModule", { 5189 value: true 5190 }); 5191 exports.ColorStyle = exports.ColorClass = exports.ColorAttributor = undefined; 5192 5193 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 5194 5195 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 5196 5197 var _parchment = __webpack_require__(0); 5198 5199 var _parchment2 = _interopRequireDefault(_parchment); 5200 5201 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 5202 5203 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 5204 5205 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 5206 5207 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 5208 5209 var ColorAttributor = function (_Parchment$Attributor) { 5210 _inherits(ColorAttributor, _Parchment$Attributor); 5211 5212 function ColorAttributor() { 5213 _classCallCheck(this, ColorAttributor); 5214 5215 return _possibleConstructorReturn(this, (ColorAttributor.__proto__ || Object.getPrototypeOf(ColorAttributor)).apply(this, arguments)); 5216 } 5217 5218 _createClass(ColorAttributor, [{ 5219 key: 'value', 5220 value: function value(domNode) { 5221 var value = _get(ColorAttributor.prototype.__proto__ || Object.getPrototypeOf(ColorAttributor.prototype), 'value', this).call(this, domNo
vendor: 24,408 bytes, lines 5221-5709
5221de); 5222 if (!value.startsWith('rgb(')) return value; 5223 value = value.replace(/^[^\d]+/, '').replace(/[^\d]+$/, ''); 5224 return '#' + value.split(',').map(function (component) { 5225 return ('00' + parseInt(component).toString(16)).slice(-2); 5226 }).join(''); 5227 } 5228 }]); 5229 5230 return ColorAttributor; 5231 }(_parchment2.default.Attributor.Style); 5232 5233 var ColorClass = new _parchment2.default.Attributor.Class('color', 'ql-color', { 5234 scope: _parchment2.default.Scope.INLINE 5235 }); 5236 var ColorStyle = new ColorAttributor('color', 'color', { 5237 scope: _parchment2.default.Scope.INLINE 5238 }); 5239 5240 exports.ColorAttributor = ColorAttributor; 5241 exports.ColorClass = ColorClass; 5242 exports.ColorStyle = ColorStyle; 5243 5244 /***/ }), 5245 /* 27 */ 5246 /***/ (function(module, exports, __webpack_require__) { 5247 5248 "use strict"; 5249 5250 5251 Object.defineProperty(exports, "__esModule", { 5252 value: true 5253 }); 5254 exports.sanitize = exports.default = undefined; 5255 5256 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 5257 5258 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 5259 5260 var _inline = __webpack_require__(6); 5261 5262 var _inline2 = _interopRequireDefault(_inline); 5263 5264 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 5265 5266 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 5267 5268 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 5269 5270 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 5271 5272 var Link = function (_Inline) { 5273 _inherits(Link, _Inline); 5274 5275 function Link() { 5276 _classCallCheck(this, Link); 5277 5278 return _possibleConstructorReturn(this, (Link.__proto__ || Object.getPrototypeOf(Link)).apply(this, arguments)); 5279 } 5280 5281 _createClass(Link, [{ 5282 key: 'format', 5283 value: function format(name, value) { 5284 if (name !== this.statics.blotName || !value) return _get(Link.prototype.__proto__ || Object.getPrototypeOf(Link.prototype), 'format', this).call(this, name, value); 5285 value = this.constructor.sanitize(value); 5286 this.domNode.setAttribute('href', value); 5287 } 5288 }], [{ 5289 key: 'create', 5290 value: function create(value) { 5291 var node = _get(Link.__proto__ || Object.getPrototypeOf(Link), 'create', this).call(this, value); 5292 value = this.sanitize(value); 5293 node.setAttribute('href', value); 5294 node.setAttribute('target', '_blank'); 5295 return node; 5296 } 5297 }, { 5298 key: 'formats', 5299 value: function formats(domNode) { 5300 return domNode.getAttribute('href'); 5301 } 5302 }, { 5303 key: 'sanitize', 5304 value: function sanitize(url) { 5305 return _sanitize(url, this.PROTOCOL_WHITELIST) ? url : this.SANITIZED_URL; 5306 } 5307 }]); 5308 5309 return Link; 5310 }(_inline2.default); 5311 5312 Link.blotName = 'link'; 5313 Link.tagName = 'A'; 5314 Link.SANITIZED_URL = 'about:blank'; 5315 Link.PROTOCOL_WHITELIST = ['http', 'https', 'mailto', 'tel']; 5316 5317 function _sanitize(url, protocols) { 5318 var anchor = document.createElement('a'); 5319 anchor.href = url; 5320 var protocol = anchor.href.slice(0, anchor.href.indexOf(':')); 5321 return protocols.indexOf(protocol) > -1; 5322 } 5323 5324 exports.default = Link; 5325 exports.sanitize = _sanitize; 5326 5327 /***/ }), 5328 /* 28 */ 5329 /***/ (function(module, exports, __webpack_require__) { 5330 5331 "use strict"; 5332 5333 5334 Object.defineProperty(exports, "__esModule", { 5335 value: true 5336 }); 5337 5338 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 5339 5340 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 5341 5342 var _keyboard = __webpack_require__(23); 5343 5344 var _keyboard2 = _interopRequireDefault(_keyboard); 5345 5346 var _dropdown = __webpack_require__(107); 5347 5348 var _dropdown2 = _interopRequireDefault(_dropdown); 5349 5350 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 5351 5352 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 5353 5354 var optionsCounter = 0; 5355 5356 function toggleAriaAttribute(element, attribute) { 5357 element.setAttribute(attribute, !(element.getAttribute(attribute) === 'true')); 5358 } 5359 5360 var Picker = function () { 5361 function Picker(select) { 5362 var _this = this; 5363 5364 _classCallCheck(this, Picker); 5365 5366 this.select = select; 5367 this.container = document.createElement('span'); 5368 this.buildPicker(); 5369 this.select.style.display = 'none'; 5370 this.select.parentNode.insertBefore(this.container, this.select); 5371 5372 this.label.addEventListener('mousedown', function () { 5373 _this.togglePicker(); 5374 }); 5375 this.label.addEventListener('keydown', function (event) { 5376 switch (event.keyCode) { 5377 // Allows the "Enter" key to open the picker 5378 case _keyboard2.default.keys.ENTER: 5379 _this.togglePicker(); 5380 break; 5381 5382 // Allows the "Escape" key to close the picker 5383 case _keyboard2.default.keys.ESCAPE: 5384 _this.escape(); 5385 event.preventDefault(); 5386 break; 5387 default: 5388 } 5389 }); 5390 this.select.addEventListener('change', this.update.bind(this)); 5391 } 5392 5393 _createClass(Picker, [{ 5394 key: 'togglePicker', 5395 value: function togglePicker() { 5396 this.container.classList.toggle('ql-expanded'); 5397 // Toggle aria-expanded and aria-hidden to make the picker accessible 5398 toggleAriaAttribute(this.label, 'aria-expanded'); 5399 toggleAriaAttribute(this.options, 'aria-hidden'); 5400 } 5401 }, { 5402 key: 'buildItem', 5403 value: function buildItem(option) { 5404 var _this2 = this; 5405 5406 var item = document.createElement('span'); 5407 item.tabIndex = '0'; 5408 item.setAttribute('role', 'button'); 5409 5410 item.classList.add('ql-picker-item'); 5411 if (option.hasAttribute('value')) { 5412 item.setAttribute('data-value', option.getAttribute('value')); 5413 } 5414 if (option.textContent) { 5415 item.setAttribute('data-label', option.textContent); 5416 } 5417 item.addEventListener('click', function () { 5418 _this2.selectItem(item, true); 5419 }); 5420 item.addEventListener('keydown', function (event) { 5421 switch (event.keyCode) { 5422 // Allows the "Enter" key to select an item 5423 case _keyboard2.default.keys.ENTER: 5424 _this2.selectItem(item, true); 5425 event.preventDefault(); 5426 break; 5427 5428 // Allows the "Escape" key to close the picker 5429 case _keyboard2.default.keys.ESCAPE: 5430 _this2.escape(); 5431 event.preventDefault(); 5432 break; 5433 default: 5434 } 5435 }); 5436 5437 return item; 5438 } 5439 }, { 5440 key: 'buildLabel', 5441 value: function buildLabel() { 5442 var label = document.createElement('span'); 5443 label.classList.add('ql-picker-label'); 5444 label.innerHTML = _dropdown2.default; 5445 label.tabIndex = '0'; 5446 label.setAttribute('role', 'button'); 5447 label.setAttribute('aria-expanded', 'false'); 5448 this.container.appendChild(label); 5449 return label; 5450 } 5451 }, { 5452 key: 'buildOptions', 5453 value: function buildOptions() { 5454 var _this3 = this; 5455 5456 var options = document.createElement('span'); 5457 options.classList.add('ql-picker-options'); 5458 5459 // Don't want screen readers to read this until options are visible 5460 options.setAttribute('aria-hidden', 'true'); 5461 options.tabIndex = '-1'; 5462 5463 // Need a unique id for aria-controls 5464 options.id = 'ql-picker-options-' + optionsCounter; 5465 optionsCounter += 1; 5466 this.label.setAttribute('aria-controls', options.id); 5467 5468 this.options = options; 5469 5470 [].slice.call(this.select.options).forEach(function (option) { 5471 var item = _this3.buildItem(option); 5472 options.appendChild(item); 5473 if (option.selected === true) { 5474 _this3.selectItem(item); 5475 } 5476 }); 5477 this.container.appendChild(options); 5478 } 5479 }, { 5480 key: 'buildPicker', 5481 value: function buildPicker() { 5482 var _this4 = this; 5483 5484 [].slice.call(this.select.attributes).forEach(function (item) { 5485 _this4.container.setAttribute(item.name, item.value); 5486 }); 5487 this.container.classList.add('ql-picker'); 5488 this.label = this.buildLabel(); 5489 this.buildOptions(); 5490 } 5491 }, { 5492 key: 'escape', 5493 value: function escape() { 5494 var _this5 = this; 5495 5496 // Close menu and return focus to trigger label 5497 this.close(); 5498 // Need setTimeout for accessibility to ensure that the browser executes 5499 // focus on the next process thread and after any DOM content changes 5500 setTimeout(function () { 5501 return _this5.label.focus(); 5502 }, 1); 5503 } 5504 }, { 5505 key: 'close', 5506 value: function close() { 5507 this.container.classList.remove('ql-expanded'); 5508 this.label.setAttribute('aria-expanded', 'false'); 5509 this.options.setAttribute('aria-hidden', 'true'); 5510 } 5511 }, { 5512 key: 'selectItem', 5513 value: function selectItem(item) { 5514 var trigger = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 5515 5516 var selected = this.container.querySelector('.ql-selected'); 5517 if (item === selected) return; 5518 if (selected != null) { 5519 selected.classList.remove('ql-selected'); 5520 } 5521 if (item == null) return; 5522 item.classList.add('ql-selected'); 5523 this.select.selectedIndex = [].indexOf.call(item.parentNode.children, item); 5524 if (item.hasAttribute('data-value')) { 5525 this.label.setAttribute('data-value', item.getAttribute('data-value')); 5526 } else { 5527 this.label.removeAttribute('data-value'); 5528 } 5529 if (item.hasAttribute('data-label')) { 5530 this.label.setAttribute('data-label', item.getAttribute('data-label')); 5531 } else { 5532 this.label.removeAttribute('data-label'); 5533 } 5534 if (trigger) { 5535 if (typeof Event === 'function') { 5536 this.select.dispatchEvent(new Event('change')); 5537 } else if ((typeof Event === 'undefined' ? 'undefined' : _typeof(Event)) === 'object') { 5538 // IE11 5539 var event = document.createEvent('Event'); 5540 event.initEvent('change', true, true); 5541 this.select.dispatchEvent(event); 5542 } 5543 this.close(); 5544 } 5545 } 5546 }, { 5547 key: 'update', 5548 value: function update() { 5549 var option = void 0; 5550 if (this.select.selectedIndex > -1) { 5551 var item = this.container.querySelector('.ql-picker-options').children[this.select.selectedIndex]; 5552 option = this.select.options[this.select.selectedIndex]; 5553 this.selectItem(item); 5554 } else { 5555 this.selectItem(null); 5556 } 5557 var isActive = option != null && option !== this.select.querySelector('option[selected]'); 5558 this.label.classList.toggle('ql-active', isActive); 5559 } 5560 }]); 5561 5562 return Picker; 5563 }(); 5564 5565 exports.default = Picker; 5566 5567 /***/ }), 5568 /* 29 */ 5569 /***/ (function(module, exports, __webpack_require__) { 5570 5571 "use strict"; 5572 5573 5574 Object.defineProperty(exports, "__esModule", { 5575 value: true 5576 }); 5577 5578 var _parchment = __webpack_require__(0); 5579 5580 var _parchment2 = _interopRequireDefault(_parchment); 5581 5582 var _quill = __webpack_require__(5); 5583 5584 var _quill2 = _interopRequireDefault(_quill); 5585 5586 var _block = __webpack_require__(4); 5587 5588 var _block2 = _interopRequireDefault(_block); 5589 5590 var _break = __webpack_require__(16); 5591 5592 var _break2 = _interopRequireDefault(_break); 5593 5594 var _container = __webpack_require__(25); 5595 5596 var _container2 = _interopRequireDefault(_container); 5597 5598 var _cursor = __webpack_require__(24); 5599 5600 var _cursor2 = _interopRequireDefault(_cursor); 5601 5602 var _embed = __webpack_require__(35); 5603 5604 var _embed2 = _interopRequireDefault(_embed); 5605 5606 var _inline = __webpack_require__(6); 5607 5608 var _inline2 = _interopRequireDefault(_inline); 5609 5610 var _scroll = __webpack_require__(22); 5611 5612 var _scroll2 = _interopRequireDefault(_scroll); 5613 5614 var _text = __webpack_require__(7); 5615 5616 var _text2 = _interopRequireDefault(_text); 5617 5618 var _clipboard = __webpack_require__(55); 5619 5620 var _clipboard2 = _interopRequireDefault(_clipboard); 5621 5622 var _history = __webpack_require__(42); 5623 5624 var _history2 = _interopRequireDefault(_history); 5625 5626 var _keyboard = __webpack_require__(23); 5627 5628 var _keyboard2 = _interopRequireDefault(_keyboard); 5629 5630 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 5631 5632 _quill2.default.register({ 5633 'blots/block': _block2.default, 5634 'blots/block/embed': _block.BlockEmbed, 5635 'blots/break': _break2.default, 5636 'blots/container': _container2.default, 5637 'blots/cursor': _cursor2.default, 5638 'blots/embed': _embed2.default, 5639 'blots/inline': _inline2.default, 5640 'blots/scroll': _scroll2.default, 5641 'blots/text': _text2.default, 5642 5643 'modules/clipboard': _clipboard2.default, 5644 'modules/history': _history2.default, 5645 'modules/keyboard': _keyboard2.default 5646 }); 5647 5648 _parchment2.default.register(_block2.default, _break2.default, _cursor2.default, _inline2.default, _scroll2.default, _text2.default); 5649 5650 exports.default = _quill2.default; 5651 5652 /***/ }), 5653 /* 30 */ 5654 /***/ (function(module, exports, __webpack_require__) { 5655 5656 "use strict"; 5657 5658 Object.defineProperty(exports, "__esModule", { value: true }); 5659 var Registry = __webpack_require__(1); 5660 var ShadowBlot = /** @class */ (function () { 5661 function ShadowBlot(domNode) { 5662 this.domNode = domNode; 5663 // @ts-ignore 5664 this.domNode[Registry.DATA_KEY] = { blot: this }; 5665 } 5666 Object.defineProperty(ShadowBlot.prototype, "statics", { 5667 // Hack for accessing inherited static methods 5668 get: function () { 5669 return this.constructor; 5670 }, 5671 enumerable: true, 5672 configurable: true 5673 }); 5674 ShadowBlot.create = function (value) { 5675 if (this.tagName == null) { 5676 throw new Registry.ParchmentError('Blot definition missing tagName'); 5677 } 5678 var node; 5679 if (Array.isArray(this.tagName)) { 5680 if (typeof value === 'string') { 5681 value = value.toUpperCase(); 5682 if (parseInt(value).toString() === value) { 5683 value = parseInt(value); 5684 } 5685 } 5686 if (typeof value === 'number') { 5687 node = document.createElement(this.tagName[value - 1]); 5688 } 5689 else if (this.tagName.indexOf(value) > -1) { 5690 node = document.createElement(value); 5691 } 5692 else { 5693 node = document.createElement(this.tagName[0]); 5694 } 5695 } 5696 else { 5697 node = document.createElement(this.tagName); 5698 } 5699 if (this.className) { 5700 node.classList.add(this.className); 5701 } 5702 return node; 5703 }; 5704 ShadowBlot.prototype.attach = function () { 5705 if (this.parent != null) { 5706 this.scroll = this.parent.scroll; 5707 } 5708 }; 5709 ShadowBlot.prototype.clone = function () {
vendor: 31,480 bytes, lines 5710-6313
5710 var domNode = this.domNode.cloneNode(false); 5711 return Registry.create(domNode); 5712 }; 5713 ShadowBlot.prototype.detach = function () { 5714 if (this.parent != null) 5715 this.parent.removeChild(this); 5716 // @ts-ignore 5717 delete this.domNode[Registry.DATA_KEY]; 5718 }; 5719 ShadowBlot.prototype.deleteAt = function (index, length) { 5720 var blot = this.isolate(index, length); 5721 blot.remove(); 5722 }; 5723 ShadowBlot.prototype.formatAt = function (index, length, name, value) { 5724 var blot = this.isolate(index, length); 5725 if (Registry.query(name, Registry.Scope.BLOT) != null && value) { 5726 blot.wrap(name, value); 5727 } 5728 else if (Registry.query(name, Registry.Scope.ATTRIBUTE) != null) { 5729 var parent = Registry.create(this.statics.scope); 5730 blot.wrap(parent); 5731 parent.format(name, value); 5732 } 5733 }; 5734 ShadowBlot.prototype.insertAt = function (index, value, def) { 5735 var blot = def == null ? Registry.create('text', value) : Registry.create(value, def); 5736 var ref = this.split(index); 5737 this.parent.insertBefore(blot, ref); 5738 }; 5739 ShadowBlot.prototype.insertInto = function (parentBlot, refBlot) { 5740 if (refBlot === void 0) { refBlot = null; } 5741 if (this.parent != null) { 5742 this.parent.children.remove(this); 5743 } 5744 var refDomNode = null; 5745 parentBlot.children.insertBefore(this, refBlot); 5746 if (refBlot != null) { 5747 refDomNode = refBlot.domNode; 5748 } 5749 if (this.domNode.parentNode != parentBlot.domNode || 5750 this.domNode.nextSibling != refDomNode) { 5751 parentBlot.domNode.insertBefore(this.domNode, refDomNode); 5752 } 5753 this.parent = parentBlot; 5754 this.attach(); 5755 }; 5756 ShadowBlot.prototype.isolate = function (index, length) { 5757 var target = this.split(index); 5758 target.split(length); 5759 return target; 5760 }; 5761 ShadowBlot.prototype.length = function () { 5762 return 1; 5763 }; 5764 ShadowBlot.prototype.offset = function (root) { 5765 if (root === void 0) { root = this.parent; } 5766 if (this.parent == null || this == root) 5767 return 0; 5768 return this.parent.children.offset(this) + this.parent.offset(root); 5769 }; 5770 ShadowBlot.prototype.optimize = function (context) { 5771 // TODO clean up once we use WeakMap 5772 // @ts-ignore 5773 if (this.domNode[Registry.DATA_KEY] != null) { 5774 // @ts-ignore 5775 delete this.domNode[Registry.DATA_KEY].mutations; 5776 } 5777 }; 5778 ShadowBlot.prototype.remove = function () { 5779 if (this.domNode.parentNode != null) { 5780 this.domNode.parentNode.removeChild(this.domNode); 5781 } 5782 this.detach(); 5783 }; 5784 ShadowBlot.prototype.replace = function (target) { 5785 if (target.parent == null) 5786 return; 5787 target.parent.insertBefore(this, target.next); 5788 target.remove(); 5789 }; 5790 ShadowBlot.prototype.replaceWith = function (name, value) { 5791 var replacement = typeof name === 'string' ? Registry.create(name, value) : name; 5792 replacement.replace(this); 5793 return replacement; 5794 }; 5795 ShadowBlot.prototype.split = function (index, force) { 5796 return index === 0 ? this : this.next; 5797 }; 5798 ShadowBlot.prototype.update = function (mutations, context) { 5799 // Nothing to do by default 5800 }; 5801 ShadowBlot.prototype.wrap = function (name, value) { 5802 var wrapper = typeof name === 'string' ? Registry.create(name, value) : name; 5803 if (this.parent != null) { 5804 this.parent.insertBefore(wrapper, this.next); 5805 } 5806 wrapper.appendChild(this); 5807 return wrapper; 5808 }; 5809 ShadowBlot.blotName = 'abstract'; 5810 return ShadowBlot; 5811 }()); 5812 exports.default = ShadowBlot; 5813 5814 5815 /***/ }), 5816 /* 31 */ 5817 /***/ (function(module, exports, __webpack_require__) { 5818 5819 "use strict"; 5820 5821 Object.defineProperty(exports, "__esModule", { value: true }); 5822 var attributor_1 = __webpack_require__(12); 5823 var class_1 = __webpack_require__(32); 5824 var style_1 = __webpack_require__(33); 5825 var Registry = __webpack_require__(1); 5826 var AttributorStore = /** @class */ (function () { 5827 function AttributorStore(domNode) { 5828 this.attributes = {}; 5829 this.domNode = domNode; 5830 this.build(); 5831 } 5832 AttributorStore.prototype.attribute = function (attribute, value) { 5833 // verb 5834 if (value) { 5835 if (attribute.add(this.domNode, value)) { 5836 if (attribute.value(this.domNode) != null) { 5837 this.attributes[attribute.attrName] = attribute; 5838 } 5839 else { 5840 delete this.attributes[attribute.attrName]; 5841 } 5842 } 5843 } 5844 else { 5845 attribute.remove(this.domNode); 5846 delete this.attributes[attribute.attrName]; 5847 } 5848 }; 5849 AttributorStore.prototype.build = function () { 5850 var _this = this; 5851 this.attributes = {}; 5852 var attributes = attributor_1.default.keys(this.domNode); 5853 var classes = class_1.default.keys(this.domNode); 5854 var styles = style_1.default.keys(this.domNode); 5855 attributes 5856 .concat(classes) 5857 .concat(styles) 5858 .forEach(function (name) { 5859 var attr = Registry.query(name, Registry.Scope.ATTRIBUTE); 5860 if (attr instanceof attributor_1.default) { 5861 _this.attributes[attr.attrName] = attr; 5862 } 5863 }); 5864 }; 5865 AttributorStore.prototype.copy = function (target) { 5866 var _this = this; 5867 Object.keys(this.attributes).forEach(function (key) { 5868 var value = _this.attributes[key].value(_this.domNode); 5869 target.format(key, value); 5870 }); 5871 }; 5872 AttributorStore.prototype.move = function (target) { 5873 var _this = this; 5874 this.copy(target); 5875 Object.keys(this.attributes).forEach(function (key) { 5876 _this.attributes[key].remove(_this.domNode); 5877 }); 5878 this.attributes = {}; 5879 }; 5880 AttributorStore.prototype.values = function () { 5881 var _this = this; 5882 return Object.keys(this.attributes).reduce(function (attributes, name) { 5883 attributes[name] = _this.attributes[name].value(_this.domNode); 5884 return attributes; 5885 }, {}); 5886 }; 5887 return AttributorStore; 5888 }()); 5889 exports.default = AttributorStore; 5890 5891 5892 /***/ }), 5893 /* 32 */ 5894 /***/ (function(module, exports, __webpack_require__) { 5895 5896 "use strict"; 5897 5898 var __extends = (this && this.__extends) || (function () { 5899 var extendStatics = Object.setPrototypeOf || 5900 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 5901 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 5902 return function (d, b) { 5903 extendStatics(d, b); 5904 function __() { this.constructor = d; } 5905 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 5906 }; 5907 })(); 5908 Object.defineProperty(exports, "__esModule", { value: true }); 5909 var attributor_1 = __webpack_require__(12); 5910 function match(node, prefix) { 5911 var className = node.getAttribute('class') || ''; 5912 return className.split(/\s+/).filter(function (name) { 5913 return name.indexOf(prefix + "-") === 0; 5914 }); 5915 } 5916 var ClassAttributor = /** @class */ (function (_super) { 5917 __extends(ClassAttributor, _super); 5918 function ClassAttributor() { 5919 return _super !== null && _super.apply(this, arguments) || this; 5920 } 5921 ClassAttributor.keys = function (node) { 5922 return (node.getAttribute('class') || '').split(/\s+/).map(function (name) { 5923 return name 5924 .split('-') 5925 .slice(0, -1) 5926 .join('-'); 5927 }); 5928 }; 5929 ClassAttributor.prototype.add = function (node, value) { 5930 if (!this.canAdd(node, value)) 5931 return false; 5932 this.remove(node); 5933 node.classList.add(this.keyName + "-" + value); 5934 return true; 5935 }; 5936 ClassAttributor.prototype.remove = function (node) { 5937 var matches = match(node, this.keyName); 5938 matches.forEach(function (name) { 5939 node.classList.remove(name); 5940 }); 5941 if (node.classList.length === 0) { 5942 node.removeAttribute('class'); 5943 } 5944 }; 5945 ClassAttributor.prototype.value = function (node) { 5946 var result = match(node, this.keyName)[0] || ''; 5947 var value = result.slice(this.keyName.length + 1); // +1 for hyphen 5948 return this.canAdd(node, value) ? value : ''; 5949 }; 5950 return ClassAttributor; 5951 }(attributor_1.default)); 5952 exports.default = ClassAttributor; 5953 5954 5955 /***/ }), 5956 /* 33 */ 5957 /***/ (function(module, exports, __webpack_require__) { 5958 5959 "use strict"; 5960 5961 var __extends = (this && this.__extends) || (function () { 5962 var extendStatics = Object.setPrototypeOf || 5963 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 5964 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 5965 return function (d, b) { 5966 extendStatics(d, b); 5967 function __() { this.constructor = d; } 5968 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 5969 }; 5970 })(); 5971 Object.defineProperty(exports, "__esModule", { value: true }); 5972 var attributor_1 = __webpack_require__(12); 5973 function camelize(name) { 5974 var parts = name.split('-'); 5975 var rest = parts 5976 .slice(1) 5977 .map(function (part) { 5978 return part[0].toUpperCase() + part.slice(1); 5979 }) 5980 .join(''); 5981 return parts[0] + rest; 5982 } 5983 var StyleAttributor = /** @class */ (function (_super) { 5984 __extends(StyleAttributor, _super); 5985 function StyleAttributor() { 5986 return _super !== null && _super.apply(this, arguments) || this; 5987 } 5988 StyleAttributor.keys = function (node) { 5989 return (node.getAttribute('style') || '').split(';').map(function (value) { 5990 var arr = value.split(':'); 5991 return arr[0].trim(); 5992 }); 5993 }; 5994 StyleAttributor.prototype.add = function (node, value) { 5995 if (!this.canAdd(node, value)) 5996 return false; 5997 // @ts-ignore 5998 node.style[camelize(this.keyName)] = value; 5999 return true; 6000 }; 6001 StyleAttributor.prototype.remove = function (node) { 6002 // @ts-ignore 6003 node.style[camelize(this.keyName)] = ''; 6004 if (!node.getAttribute('style')) { 6005 node.removeAttribute('style'); 6006 } 6007 }; 6008 StyleAttributor.prototype.value = function (node) { 6009 // @ts-ignore 6010 var value = node.style[camelize(this.keyName)]; 6011 return this.canAdd(node, value) ? value : ''; 6012 }; 6013 return StyleAttributor; 6014 }(attributor_1.default)); 6015 exports.default = StyleAttributor; 6016 6017 6018 /***/ }), 6019 /* 34 */ 6020 /***/ (function(module, exports, __webpack_require__) { 6021 6022 "use strict"; 6023 6024 6025 Object.defineProperty(exports, "__esModule", { 6026 value: true 6027 }); 6028 6029 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 6030 6031 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 6032 6033 var Theme = function () { 6034 function Theme(quill, options) { 6035 _classCallCheck(this, Theme); 6036 6037 this.quill = quill; 6038 this.options = options; 6039 this.modules = {}; 6040 } 6041 6042 _createClass(Theme, [{ 6043 key: 'init', 6044 value: function init() { 6045 var _this = this; 6046 6047 Object.keys(this.options.modules).forEach(function (name) { 6048 if (_this.modules[name] == null) { 6049 _this.addModule(name); 6050 } 6051 }); 6052 } 6053 }, { 6054 key: 'addModule', 6055 value: function addModule(name) { 6056 var moduleClass = this.quill.constructor.import('modules/' + name); 6057 this.modules[name] = new moduleClass(this.quill, this.options.modules[name] || {}); 6058 return this.modules[name]; 6059 } 6060 }]); 6061 6062 return Theme; 6063 }(); 6064 6065 Theme.DEFAULTS = { 6066 modules: {} 6067 }; 6068 Theme.themes = { 6069 'default': Theme 6070 }; 6071 6072 exports.default = Theme; 6073 6074 /***/ }), 6075 /* 35 */ 6076 /***/ (function(module, exports, __webpack_require__) { 6077 6078 "use strict"; 6079 6080 6081 Object.defineProperty(exports, "__esModule", { 6082 value: true 6083 }); 6084 6085 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 6086 6087 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 6088 6089 var _parchment = __webpack_require__(0); 6090 6091 var _parchment2 = _interopRequireDefault(_parchment); 6092 6093 var _text = __webpack_require__(7); 6094 6095 var _text2 = _interopRequireDefault(_text); 6096 6097 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6098 6099 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 6100 6101 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 6102 6103 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 6104 6105 var GUARD_TEXT = '\uFEFF'; 6106 6107 var Embed = function (_Parchment$Embed) { 6108 _inherits(Embed, _Parchment$Embed); 6109 6110 function Embed(node) { 6111 _classCallCheck(this, Embed); 6112 6113 var _this = _possibleConstructorReturn(this, (Embed.__proto__ || Object.getPrototypeOf(Embed)).call(this, node)); 6114 6115 _this.contentNode = document.createElement('span'); 6116 _this.contentNode.setAttribute('contenteditable', false); 6117 [].slice.call(_this.domNode.childNodes).forEach(function (childNode) { 6118 _this.contentNode.appendChild(childNode); 6119 }); 6120 _this.leftGuard = document.createTextNode(GUARD_TEXT); 6121 _this.rightGuard = document.createTextNode(GUARD_TEXT); 6122 _this.domNode.appendChild(_this.leftGuard); 6123 _this.domNode.appendChild(_this.contentNode); 6124 _this.domNode.appendChild(_this.rightGuard); 6125 return _this; 6126 } 6127 6128 _createClass(Embed, [{ 6129 key: 'index', 6130 value: function index(node, offset) { 6131 if (node === this.leftGuard) return 0; 6132 if (node === this.rightGuard) return 1; 6133 return _get(Embed.prototype.__proto__ || Object.getPrototypeOf(Embed.prototype), 'index', this).call(this, node, offset); 6134 } 6135 }, { 6136 key: 'restore', 6137 value: function restore(node) { 6138 var range = void 0, 6139 textNode = void 0; 6140 var text = node.data.split(GUARD_TEXT).join(''); 6141 if (node === this.leftGuard) { 6142 if (this.prev instanceof _text2.default) { 6143 var prevLength = this.prev.length(); 6144 this.prev.insertAt(prevLength, text); 6145 range = { 6146 startNode: this.prev.domNode, 6147 startOffset: prevLength + text.length 6148 }; 6149 } else { 6150 textNode = document.createTextNode(text); 6151 this.parent.insertBefore(_parchment2.default.create(textNode), this); 6152 range = { 6153 startNode: textNode, 6154 startOffset: text.length 6155 }; 6156 } 6157 } else if (node === this.rightGuard) { 6158 if (this.next instanceof _text2.default) { 6159 this.next.insertAt(0, text); 6160 range = { 6161 startNode: this.next.domNode, 6162 startOffset: text.length 6163 }; 6164 } else { 6165 textNode = document.createTextNode(text); 6166 this.parent.insertBefore(_parchment2.default.create(textNode), this.next); 6167 range = { 6168 startNode: textNode, 6169 startOffset: text.length 6170 }; 6171 } 6172 } 6173 node.data = GUARD_TEXT; 6174 return range; 6175 } 6176 }, { 6177 key: 'update', 6178 value: function update(mutations, context) { 6179 var _this2 = this; 6180 6181 mutations.forEach(function (mutation) { 6182 if (mutation.type === 'characterData' && (mutation.target === _this2.leftGuard || mutation.target === _this2.rightGuard)) { 6183 var range = _this2.restore(mutation.target); 6184 if (range) context.range = range; 6185 } 6186 }); 6187 } 6188 }]); 6189 6190 return Embed; 6191 }(_parchment2.default.Embed); 6192 6193 exports.default = Embed; 6194 6195 /***/ }), 6196 /* 36 */ 6197 /***/ (function(module, exports, __webpack_require__) { 6198 6199 "use strict"; 6200 6201 6202 Object.defineProperty(exports, "__esModule", { 6203 value: true 6204 }); 6205 exports.AlignStyle = exports.AlignClass = exports.AlignAttribute = undefined; 6206 6207 var _parchment = __webpack_require__(0); 6208 6209 var _parchment2 = _interopRequireDefault(_parchment); 6210 6211 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6212 6213 var config = { 6214 scope: _parchment2.default.Scope.BLOCK, 6215 whitelist: ['right', 'center', 'justify'] 6216 }; 6217 6218 var AlignAttribute = new _parchment2.default.Attributor.Attribute('align', 'align', config); 6219 var AlignClass = new _parchment2.default.Attributor.Class('align', 'ql-align', config); 6220 var AlignStyle = new _parchment2.default.Attributor.Style('align', 'text-align', config); 6221 6222 exports.AlignAttribute = AlignAttribute; 6223 exports.AlignClass = AlignClass; 6224 exports.AlignStyle = AlignStyle; 6225 6226 /***/ }), 6227 /* 37 */ 6228 /***/ (function(module, exports, __webpack_require__) { 6229 6230 "use strict"; 6231 6232 6233 Object.defineProperty(exports, "__esModule", { 6234 value: true 6235 }); 6236 exports.BackgroundStyle = exports.BackgroundClass = undefined; 6237 6238 var _parchment = __webpack_require__(0); 6239 6240 var _parchment2 = _interopRequireDefault(_parchment); 6241 6242 var _color = __webpack_require__(26); 6243 6244 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6245 6246 var BackgroundClass = new _parchment2.default.Attributor.Class('background', 'ql-bg', { 6247 scope: _parchment2.default.Scope.INLINE 6248 }); 6249 var BackgroundStyle = new _color.ColorAttributor('background', 'background-color', { 6250 scope: _parchment2.default.Scope.INLINE 6251 }); 6252 6253 exports.BackgroundClass = BackgroundClass; 6254 exports.BackgroundStyle = BackgroundStyle; 6255 6256 /***/ }), 6257 /* 38 */ 6258 /***/ (function(module, exports, __webpack_require__) { 6259 6260 "use strict"; 6261 6262 6263 Object.defineProperty(exports, "__esModule", { 6264 value: true 6265 }); 6266 exports.DirectionStyle = exports.DirectionClass = exports.DirectionAttribute = undefined; 6267 6268 var _parchment = __webpack_require__(0); 6269 6270 var _parchment2 = _interopRequireDefault(_parchment); 6271 6272 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6273 6274 var config = { 6275 scope: _parchment2.default.Scope.BLOCK, 6276 whitelist: ['rtl'] 6277 }; 6278 6279 var DirectionAttribute = new _parchment2.default.Attributor.Attribute('direction', 'dir', config); 6280 var DirectionClass = new _parchment2.default.Attributor.Class('direction', 'ql-direction', config); 6281 var DirectionStyle = new _parchment2.default.Attributor.Style('direction', 'direction', config); 6282 6283 exports.DirectionAttribute = DirectionAttribute; 6284 exports.DirectionClass = DirectionClass; 6285 exports.DirectionStyle = DirectionStyle; 6286 6287 /***/ }), 6288 /* 39 */ 6289 /***/ (function(module, exports, __webpack_require__) { 6290 6291 "use strict"; 6292 6293 6294 Object.defineProperty(exports, "__esModule", { 6295 value: true 6296 }); 6297 exports.FontClass = exports.FontStyle = undefined; 6298 6299 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 6300 6301 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 6302 6303 var _parchment = __webpack_require__(0); 6304 6305 var _parchment2 = _interopRequireDefault(_parchment); 6306 6307 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6308 6309 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 6310 6311 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 6312 6313 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { c
vendor: 7,878 bytes, lines 6313-6473
6313onstructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 6314 6315 var config = { 6316 scope: _parchment2.default.Scope.INLINE, 6317 whitelist: ['serif', 'monospace'] 6318 }; 6319 6320 var FontClass = new _parchment2.default.Attributor.Class('font', 'ql-font', config); 6321 6322 var FontStyleAttributor = function (_Parchment$Attributor) { 6323 _inherits(FontStyleAttributor, _Parchment$Attributor); 6324 6325 function FontStyleAttributor() { 6326 _classCallCheck(this, FontStyleAttributor); 6327 6328 return _possibleConstructorReturn(this, (FontStyleAttributor.__proto__ || Object.getPrototypeOf(FontStyleAttributor)).apply(this, arguments)); 6329 } 6330 6331 _createClass(FontStyleAttributor, [{ 6332 key: 'value', 6333 value: function value(node) { 6334 return _get(FontStyleAttributor.prototype.__proto__ || Object.getPrototypeOf(FontStyleAttributor.prototype), 'value', this).call(this, node).replace(/["']/g, ''); 6335 } 6336 }]); 6337 6338 return FontStyleAttributor; 6339 }(_parchment2.default.Attributor.Style); 6340 6341 var FontStyle = new FontStyleAttributor('font', 'font-family', config); 6342 6343 exports.FontStyle = FontStyle; 6344 exports.FontClass = FontClass; 6345 6346 /***/ }), 6347 /* 40 */ 6348 /***/ (function(module, exports, __webpack_require__) { 6349 6350 "use strict"; 6351 6352 6353 Object.defineProperty(exports, "__esModule", { 6354 value: true 6355 }); 6356 exports.SizeStyle = exports.SizeClass = undefined; 6357 6358 var _parchment = __webpack_require__(0); 6359 6360 var _parchment2 = _interopRequireDefault(_parchment); 6361 6362 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6363 6364 var SizeClass = new _parchment2.default.Attributor.Class('size', 'ql-size', { 6365 scope: _parchment2.default.Scope.INLINE, 6366 whitelist: ['small', 'large', 'huge'] 6367 }); 6368 var SizeStyle = new _parchment2.default.Attributor.Style('size', 'font-size', { 6369 scope: _parchment2.default.Scope.INLINE, 6370 whitelist: ['10px', '18px', '32px'] 6371 }); 6372 6373 exports.SizeClass = SizeClass; 6374 exports.SizeStyle = SizeStyle; 6375 6376 /***/ }), 6377 /* 41 */ 6378 /***/ (function(module, exports, __webpack_require__) { 6379 6380 "use strict"; 6381 6382 6383 module.exports = { 6384 'align': { 6385 '': __webpack_require__(76), 6386 'center': __webpack_require__(77), 6387 'right': __webpack_require__(78), 6388 'justify': __webpack_require__(79) 6389 }, 6390 'background': __webpack_require__(80), 6391 'blockquote': __webpack_require__(81), 6392 'bold': __webpack_require__(82), 6393 'clean': __webpack_require__(83), 6394 'code': __webpack_require__(58), 6395 'code-block': __webpack_require__(58), 6396 'color': __webpack_require__(84), 6397 'direction': { 6398 '': __webpack_require__(85), 6399 'rtl': __webpack_require__(86) 6400 }, 6401 'float': { 6402 'center': __webpack_require__(87), 6403 'full': __webpack_require__(88), 6404 'left': __webpack_require__(89), 6405 'right': __webpack_require__(90) 6406 }, 6407 'formula': __webpack_require__(91), 6408 'header': { 6409 '1': __webpack_require__(92), 6410 '2': __webpack_require__(93) 6411 }, 6412 'italic': __webpack_require__(94), 6413 'image': __webpack_require__(95), 6414 'indent': { 6415 '+1': __webpack_require__(96), 6416 '-1': __webpack_require__(97) 6417 }, 6418 'link': __webpack_require__(98), 6419 'list': { 6420 'ordered': __webpack_require__(99), 6421 'bullet': __webpack_require__(100), 6422 'check': __webpack_require__(101) 6423 }, 6424 'script': { 6425 'sub': __webpack_require__(102), 6426 'super': __webpack_require__(103) 6427 }, 6428 'strike': __webpack_require__(104), 6429 'underline': __webpack_require__(105), 6430 'video': __webpack_require__(106) 6431 }; 6432 6433 /***/ }), 6434 /* 42 */ 6435 /***/ (function(module, exports, __webpack_require__) { 6436 6437 "use strict"; 6438 6439 6440 Object.defineProperty(exports, "__esModule", { 6441 value: true 6442 }); 6443 exports.getLastChangeIndex = exports.default = undefined; 6444 6445 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 6446 6447 var _parchment = __webpack_require__(0); 6448 6449 var _parchment2 = _interopRequireDefault(_parchment); 6450 6451 var _quill = __webpack_require__(5); 6452 6453 var _quill2 = _interopRequireDefault(_quill); 6454 6455 var _module = __webpack_require__(9); 6456 6457 var _module2 = _interopRequireDefault(_module); 6458 6459 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6460 6461 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 6462 6463 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 6464 6465 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 6466 6467 var History = function (_Module) { 6468 _inherits(History, _Module); 6469 6470 function History(quill, options) { 6471 _classCallCheck(this, History); 6472 6473 var _this = _possibleConstructorReturn(this, (History.__proto__ || Object.getPrototypeOf(History)
vendor: 9,660 bytes, lines 6473-6659
6473).call(this, quill, options)); 6474 6475 _this.lastRecorded = 0; 6476 _this.ignoreChange = false; 6477 _this.clear(); 6478 _this.quill.on(_quill2.default.events.EDITOR_CHANGE, function (eventName, delta, oldDelta, source) { 6479 if (eventName !== _quill2.default.events.TEXT_CHANGE || _this.ignoreChange) return; 6480 if (!_this.options.userOnly || source === _quill2.default.sources.USER) { 6481 _this.record(delta, oldDelta); 6482 } else { 6483 _this.transform(delta); 6484 } 6485 }); 6486 _this.quill.keyboard.addBinding({ key: 'Z', shortKey: true }, _this.undo.bind(_this)); 6487 _this.quill.keyboard.addBinding({ key: 'Z', shortKey: true, shiftKey: true }, _this.redo.bind(_this)); 6488 if (/Win/i.test(navigator.platform)) { 6489 _this.quill.keyboard.addBinding({ key: 'Y', shortKey: true }, _this.redo.bind(_this)); 6490 } 6491 return _this; 6492 } 6493 6494 _createClass(History, [{ 6495 key: 'change', 6496 value: function change(source, dest) { 6497 if (this.stack[source].length === 0) return; 6498 var delta = this.stack[source].pop(); 6499 this.stack[dest].push(delta); 6500 this.lastRecorded = 0; 6501 this.ignoreChange = true; 6502 this.quill.updateContents(delta[source], _quill2.default.sources.USER); 6503 this.ignoreChange = false; 6504 var index = getLastChangeIndex(delta[source]); 6505 this.quill.setSelection(index); 6506 } 6507 }, { 6508 key: 'clear', 6509 value: function clear() { 6510 this.stack = { undo: [], redo: [] }; 6511 } 6512 }, { 6513 key: 'cutoff', 6514 value: function cutoff() { 6515 this.lastRecorded = 0; 6516 } 6517 }, { 6518 key: 'record', 6519 value: function record(changeDelta, oldDelta) { 6520 if (changeDelta.ops.length === 0) return; 6521 this.stack.redo = []; 6522 var undoDelta = this.quill.getContents().diff(oldDelta); 6523 var timestamp = Date.now(); 6524 if (this.lastRecorded + this.options.delay > timestamp && this.stack.undo.length > 0) { 6525 var delta = this.stack.undo.pop(); 6526 undoDelta = undoDelta.compose(delta.undo); 6527 changeDelta = delta.redo.compose(changeDelta); 6528 } else { 6529 this.lastRecorded = timestamp; 6530 } 6531 this.stack.undo.push({ 6532 redo: changeDelta, 6533 undo: undoDelta 6534 }); 6535 if (this.stack.undo.length > this.options.maxStack) { 6536 this.stack.undo.shift(); 6537 } 6538 } 6539 }, { 6540 key: 'redo', 6541 value: function redo() { 6542 this.change('redo', 'undo'); 6543 } 6544 }, { 6545 key: 'transform', 6546 value: function transform(delta) { 6547 this.stack.undo.forEach(function (change) { 6548 change.undo = delta.transform(change.undo, true); 6549 change.redo = delta.transform(change.redo, true); 6550 }); 6551 this.stack.redo.forEach(function (change) { 6552 change.undo = delta.transform(change.undo, true); 6553 change.redo = delta.transform(change.redo, true); 6554 }); 6555 } 6556 }, { 6557 key: 'undo', 6558 value: function undo() { 6559 this.change('undo', 'redo'); 6560 } 6561 }]); 6562 6563 return History; 6564 }(_module2.default); 6565 6566 History.DEFAULTS = { 6567 delay: 1000, 6568 maxStack: 100, 6569 userOnly: false 6570 }; 6571 6572 function endsWithNewlineChange(delta) { 6573 var lastOp = delta.ops[delta.ops.length - 1]; 6574 if (lastOp == null) return false; 6575 if (lastOp.insert != null) { 6576 return typeof lastOp.insert === 'string' && lastOp.insert.endsWith('\n'); 6577 } 6578 if (lastOp.attributes != null) { 6579 return Object.keys(lastOp.attributes).some(function (attr) { 6580 return _parchment2.default.query(attr, _parchment2.default.Scope.BLOCK) != null; 6581 }); 6582 } 6583 return false; 6584 } 6585 6586 function getLastChangeIndex(delta) { 6587 var deleteLength = delta.reduce(function (length, op) { 6588 length += op.delete || 0; 6589 return length; 6590 }, 0); 6591 var changeIndex = delta.length() - deleteLength; 6592 if (endsWithNewlineChange(delta)) { 6593 changeIndex -= 1; 6594 } 6595 return changeIndex; 6596 } 6597 6598 exports.default = History; 6599 exports.getLastChangeIndex = getLastChangeIndex; 6600 6601 /***/ }), 6602 /* 43 */ 6603 /***/ (function(module, exports, __webpack_require__) { 6604 6605 "use strict"; 6606 6607 6608 Object.defineProperty(exports, "__esModule", { 6609 value: true 6610 }); 6611 exports.default = exports.BaseTooltip = undefined; 6612 6613 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 6614 6615 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 6616 6617 var _extend = __webpack_require__(3); 6618 6619 var _extend2 = _interopRequireDefault(_extend); 6620 6621 var _quillDelta = __webpack_require__(2); 6622 6623 var _quillDelta2 = _interopRequireDefault(_quillDelta); 6624 6625 var _emitter = __webpack_require__(8); 6626 6627 var _emitter2 = _interopRequireDefault(_emitter); 6628 6629 var _keyboard = __webpack_require__(23); 6630 6631 var _keyboard2 = _interopRequireDefault(_keyboard); 6632 6633 var _theme = __webpack_require__(34); 6634 6635 var _theme2 = _interopRequireDefault(_theme); 6636 6637 var _colorPicker = __webpack_require__(59); 6638 6639 var _colorPicker2 = _interopRequireDefault(_colorPicker); 6640 6641 var _iconPicker = __webpack_require__(60); 6642 6643 var _iconPicker2 = _interopRequireDefault(_iconPicker); 6644 6645 var _picker = __webpack_require__(28); 6646 6647 var _picker2 = _interopRequireDefault(_picker); 6648 6649 var _tooltip = __webpack_require__(61); 6650 6651 var _tooltip2 = _interopRequireDefault(_tooltip); 6652 6653 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 6654 6655 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 6656 6657 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 6658 6659 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { c
vendor: 20,131 bytes, lines 6659-7026
6659onstructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 6660 6661 var ALIGNS = [false, 'center', 'right', 'justify']; 6662 6663 var COLORS = ["#000000", "#e60000", "#ff9900", "#ffff00", "#008a00", "#0066cc", "#9933ff", "#ffffff", "#facccc", "#ffebcc", "#ffffcc", "#cce8cc", "#cce0f5", "#ebd6ff", "#bbbbbb", "#f06666", "#ffc266", "#ffff66", "#66b966", "#66a3e0", "#c285ff", "#888888", "#a10000", "#b26b00", "#b2b200", "#006100", "#0047b2", "#6b24b2", "#444444", "#5c0000", "#663d00", "#666600", "#003700", "#002966", "#3d1466"]; 6664 6665 var FONTS = [false, 'serif', 'monospace']; 6666 6667 var HEADERS = ['1', '2', '3', false]; 6668 6669 var SIZES = ['small', false, 'large', 'huge']; 6670 6671 var BaseTheme = function (_Theme) { 6672 _inherits(BaseTheme, _Theme); 6673 6674 function BaseTheme(quill, options) { 6675 _classCallCheck(this, BaseTheme); 6676 6677 var _this = _possibleConstructorReturn(this, (BaseTheme.__proto__ || Object.getPrototypeOf(BaseTheme)).call(this, quill, options)); 6678 6679 var listener = function listener(e) { 6680 if (!document.body.contains(quill.root)) { 6681 return document.body.removeEventListener('click', listener); 6682 } 6683 if (_this.tooltip != null && !_this.tooltip.root.contains(e.target) && document.activeElement !== _this.tooltip.textbox && !_this.quill.hasFocus()) { 6684 _this.tooltip.hide(); 6685 } 6686 if (_this.pickers != null) { 6687 _this.pickers.forEach(function (picker) { 6688 if (!picker.container.contains(e.target)) { 6689 picker.close(); 6690 } 6691 }); 6692 } 6693 }; 6694 quill.emitter.listenDOM('click', document.body, listener); 6695 return _this; 6696 } 6697 6698 _createClass(BaseTheme, [{ 6699 key: 'addModule', 6700 value: function addModule(name) { 6701 var module = _get(BaseTheme.prototype.__proto__ || Object.getPrototypeOf(BaseTheme.prototype), 'addModule', this).call(this, name); 6702 if (name === 'toolbar') { 6703 this.extendToolbar(module); 6704 } 6705 return module; 6706 } 6707 }, { 6708 key: 'buildButtons', 6709 value: function buildButtons(buttons, icons) { 6710 buttons.forEach(function (button) { 6711 var className = button.getAttribute('class') || ''; 6712 className.split(/\s+/).forEach(function (name) { 6713 if (!name.startsWith('ql-')) return; 6714 name = name.slice('ql-'.length); 6715 if (icons[name] == null) return; 6716 if (name === 'direction') { 6717 button.innerHTML = icons[name][''] + icons[name]['rtl']; 6718 } else if (typeof icons[name] === 'string') { 6719 button.innerHTML = icons[name]; 6720 } else { 6721 var value = button.value || ''; 6722 if (value != null && icons[name][value]) { 6723 button.innerHTML = icons[name][value]; 6724 } 6725 } 6726 }); 6727 }); 6728 } 6729 }, { 6730 key: 'buildPickers', 6731 value: function buildPickers(selects, icons) { 6732 var _this2 = this; 6733 6734 this.pickers = selects.map(function (select) { 6735 if (select.classList.contains('ql-align')) { 6736 if (select.querySelector('option') == null) { 6737 fillSelect(select, ALIGNS); 6738 } 6739 return new _iconPicker2.default(select, icons.align); 6740 } else if (select.classList.contains('ql-background') || select.classList.contains('ql-color')) { 6741 var format = select.classList.contains('ql-background') ? 'background' : 'color'; 6742 if (select.querySelector('option') == null) { 6743 fillSelect(select, COLORS, format === 'background' ? '#ffffff' : '#000000'); 6744 } 6745 return new _colorPicker2.default(select, icons[format]); 6746 } else { 6747 if (select.querySelector('option') == null) { 6748 if (select.classList.contains('ql-font')) { 6749 fillSelect(select, FONTS); 6750 } else if (select.classList.contains('ql-header')) { 6751 fillSelect(select, HEADERS); 6752 } else if (select.classList.contains('ql-size')) { 6753 fillSelect(select, SIZES); 6754 } 6755 } 6756 return new _picker2.default(select); 6757 } 6758 }); 6759 var update = function update() { 6760 _this2.pickers.forEach(function (picker) { 6761 picker.update(); 6762 }); 6763 }; 6764 this.quill.on(_emitter2.default.events.EDITOR_CHANGE, update); 6765 } 6766 }]); 6767 6768 return BaseTheme; 6769 }(_theme2.default); 6770 6771 BaseTheme.DEFAULTS = (0, _extend2.default)(true, {}, _theme2.default.DEFAULTS, { 6772 modules: { 6773 toolbar: { 6774 handlers: { 6775 formula: function formula() { 6776 this.quill.theme.tooltip.edit('formula'); 6777 }, 6778 image: function image() { 6779 var _this3 = this; 6780 6781 var fileInput = this.container.querySelector('input.ql-image[type=file]'); 6782 if (fileInput == null) { 6783 fileInput = document.createElement('input'); 6784 fileInput.setAttribute('type', 'file'); 6785 fileInput.setAttribute('accept', 'image/png, image/gif, image/jpeg, image/bmp, image/x-icon'); 6786 fileInput.classList.add('ql-image'); 6787 fileInput.addEventListener('change', function () { 6788 if (fileInput.files != null && fileInput.files[0] != null) { 6789 var reader = new FileReader(); 6790 reader.onload = function (e) { 6791 var range = _this3.quill.getSelection(true); 6792 _this3.quill.updateContents(new _quillDelta2.default().retain(range.index).delete(range.length).insert({ image: e.target.result }), _emitter2.default.sources.USER); 6793 _this3.quill.setSelection(range.index + 1, _emitter2.default.sources.SILENT); 6794 fileInput.value = ""; 6795 }; 6796 reader.readAsDataURL(fileInput.files[0]); 6797 } 6798 }); 6799 this.container.appendChild(fileInput); 6800 } 6801 fileInput.click(); 6802 }, 6803 video: function video() { 6804 this.quill.theme.tooltip.edit('video'); 6805 } 6806 } 6807 } 6808 } 6809 }); 6810 6811 var BaseTooltip = function (_Tooltip) { 6812 _inherits(BaseTooltip, _Tooltip); 6813 6814 function BaseTooltip(quill, boundsContainer) { 6815 _classCallCheck(this, BaseTooltip); 6816 6817 var _this4 = _possibleConstructorReturn(this, (BaseTooltip.__proto__ || Object.getPrototypeOf(BaseTooltip)).call(this, quill, boundsContainer)); 6818 6819 _this4.textbox = _this4.root.querySelector('input[type="text"]'); 6820 _this4.listen(); 6821 return _this4; 6822 } 6823 6824 _createClass(BaseTooltip, [{ 6825 key: 'listen', 6826 value: function listen() { 6827 var _this5 = this; 6828 6829 this.textbox.addEventListener('keydown', function (event) { 6830 if (_keyboard2.default.match(event, 'enter')) { 6831 _this5.save(); 6832 event.preventDefault(); 6833 } else if (_keyboard2.default.match(event, 'escape')) { 6834 _this5.cancel(); 6835 event.preventDefault(); 6836 } 6837 }); 6838 } 6839 }, { 6840 key: 'cancel', 6841 value: function cancel() { 6842 this.hide(); 6843 } 6844 }, { 6845 key: 'edit', 6846 value: function edit() { 6847 var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'link'; 6848 var preview = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; 6849 6850 this.root.classList.remove('ql-hidden'); 6851 this.root.classList.add('ql-editing'); 6852 if (preview != null) { 6853 this.textbox.value = preview; 6854 } else if (mode !== this.root.getAttribute('data-mode')) { 6855 this.textbox.value = ''; 6856 } 6857 this.position(this.quill.getBounds(this.quill.selection.savedRange)); 6858 this.textbox.select(); 6859 this.textbox.setAttribute('placeholder', this.textbox.getAttribute('data-' + mode) || ''); 6860 this.root.setAttribute('data-mode', mode); 6861 } 6862 }, { 6863 key: 'restoreFocus', 6864 value: function restoreFocus() { 6865 var scrollTop = this.quill.scrollingContainer.scrollTop; 6866 this.quill.focus(); 6867 this.quill.scrollingContainer.scrollTop = scrollTop; 6868 } 6869 }, { 6870 key: 'save', 6871 value: function save() { 6872 var value = this.textbox.value; 6873 switch (this.root.getAttribute('data-mode')) { 6874 case 'link': 6875 { 6876 var scrollTop = this.quill.root.scrollTop; 6877 if (this.linkRange) { 6878 this.quill.formatText(this.linkRange, 'link', value, _emitter2.default.sources.USER); 6879 delete this.linkRange; 6880 } else { 6881 this.restoreFocus(); 6882 this.quill.format('link', value, _emitter2.default.sources.USER); 6883 } 6884 this.quill.root.scrollTop = scrollTop; 6885 break; 6886 } 6887 case 'video': 6888 { 6889 value = extractVideoUrl(value); 6890 } // eslint-disable-next-line no-fallthrough 6891 case 'formula': 6892 { 6893 if (!value) break; 6894 var range = this.quill.getSelection(true); 6895 if (range != null) { 6896 var index = range.index + range.length; 6897 this.quill.insertEmbed(index, this.root.getAttribute('data-mode'), value, _emitter2.default.sources.USER); 6898 if (this.root.getAttribute('data-mode') === 'formula') { 6899 this.quill.insertText(index + 1, ' ', _emitter2.default.sources.USER); 6900 } 6901 this.quill.setSelection(index + 2, _emitter2.default.sources.USER); 6902 } 6903 break; 6904 } 6905 default: 6906 } 6907 this.textbox.value = ''; 6908 this.hide(); 6909 } 6910 }]); 6911 6912 return BaseTooltip; 6913 }(_tooltip2.default); 6914 6915 function extractVideoUrl(url) { 6916 var match = url.match(/^(?:(https?):\/\/)?(?:(?:www|m)\.)?youtube\.com\/watch.*v=([a-zA-Z0-9_-]+)/) || url.match(/^(?:(https?):\/\/)?(?:(?:www|m)\.)?youtu\.be\/([a-zA-Z0-9_-]+)/); 6917 if (match) { 6918 return (match[1] || 'https') + '://www.youtube.com/embed/' + match[2] + '?showinfo=0'; 6919 } 6920 if (match = url.match(/^(?:(https?):\/\/)?(?:www\.)?vimeo\.com\/(\d+)/)) { 6921 // eslint-disable-line no-cond-assign 6922 return (match[1] || 'https') + '://player.vimeo.com/video/' + match[2] + '/'; 6923 } 6924 return url; 6925 } 6926 6927 function fillSelect(select, values) { 6928 var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 6929 6930 values.forEach(function (value) { 6931 var option = document.createElement('option'); 6932 if (value === defaultValue) { 6933 option.setAttribute('selected', 'selected'); 6934 } else { 6935 option.setAttribute('value', value); 6936 } 6937 select.appendChild(option); 6938 }); 6939 } 6940 6941 exports.BaseTooltip = BaseTooltip; 6942 exports.default = BaseTheme; 6943 6944 /***/ }), 6945 /* 44 */ 6946 /***/ (function(module, exports, __webpack_require__) { 6947 6948 "use strict"; 6949 6950 Object.defineProperty(exports, "__esModule", { value: true }); 6951 var LinkedList = /** @class */ (function () { 6952 function LinkedList() { 6953 this.head = this.tail = null; 6954 this.length = 0; 6955 } 6956 LinkedList.prototype.append = function () { 6957 var nodes = []; 6958 for (var _i = 0; _i < arguments.length; _i++) { 6959 nodes[_i] = arguments[_i]; 6960 } 6961 this.insertBefore(nodes[0], null); 6962 if (nodes.length > 1) { 6963 this.append.apply(this, nodes.slice(1)); 6964 } 6965 }; 6966 LinkedList.prototype.contains = function (node) { 6967 var cur, next = this.iterator(); 6968 while ((cur = next())) { 6969 if (cur === node) 6970 return true; 6971 } 6972 return false; 6973 }; 6974 LinkedList.prototype.insertBefore = function (node, refNode) { 6975 if (!node) 6976 return; 6977 node.next = refNode; 6978 if (refNode != null) { 6979 node.prev = refNode.prev; 6980 if (refNode.prev != null) { 6981 refNode.prev.next = node; 6982 } 6983 refNode.prev = node; 6984 if (refNode === this.head) { 6985 this.head = node; 6986 } 6987 } 6988 else if (this.tail != null) { 6989 this.tail.next = node; 6990 node.prev = this.tail; 6991 this.tail = node; 6992 } 6993 else { 6994 node.prev = null; 6995 this.head = this.tail = node; 6996 } 6997 this.length += 1; 6998 }; 6999 LinkedList.prototype.offset = function (target) { 7000 var index = 0, cur = this.head; 7001 while (cur != null) { 7002 if (cur === target) 7003 return index; 7004 index += cur.length(); 7005 cur = cur.next; 7006 } 7007 return -1; 7008 }; 7009 LinkedList.prototype.remove = function (node) { 7010 if (!this.contains(node)) 7011 return; 7012 if (node.prev != null) 7013 node.prev.next = node.next; 7014 if (node.next != null) 7015 node.next.prev = node.prev; 7016 if (node === this.head) 7017 this.head = node.next; 7018 if (node === this.tail) 7019 this.tail = node.prev; 7020 this.length -= 1; 7021 }; 7022 LinkedList.prototype.iterator = function (curNode) { 7023 if (curNode === void 0) { curNode = this.head; } 7024 // TODO use yield when we can 7025 return function () { 7026 var ret = curNode;
vendor: 45,110 bytes, lines 7027-7917
7027 if (curNode != null) 7028 curNode = curNode.next; 7029 return ret; 7030 }; 7031 }; 7032 LinkedList.prototype.find = function (index, inclusive) { 7033 if (inclusive === void 0) { inclusive = false; } 7034 var cur, next = this.iterator(); 7035 while ((cur = next())) { 7036 var length = cur.length(); 7037 if (index < length || 7038 (inclusive && index === length && (cur.next == null || cur.next.length() !== 0))) { 7039 return [cur, index]; 7040 } 7041 index -= length; 7042 } 7043 return [null, 0]; 7044 }; 7045 LinkedList.prototype.forEach = function (callback) { 7046 var cur, next = this.iterator(); 7047 while ((cur = next())) { 7048 callback(cur); 7049 } 7050 }; 7051 LinkedList.prototype.forEachAt = function (index, length, callback) { 7052 if (length <= 0) 7053 return; 7054 var _a = this.find(index), startNode = _a[0], offset = _a[1]; 7055 var cur, curIndex = index - offset, next = this.iterator(startNode); 7056 while ((cur = next()) && curIndex < index + length) { 7057 var curLength = cur.length(); 7058 if (index > curIndex) { 7059 callback(cur, index - curIndex, Math.min(length, curIndex + curLength - index)); 7060 } 7061 else { 7062 callback(cur, 0, Math.min(curLength, index + length - curIndex)); 7063 } 7064 curIndex += curLength; 7065 } 7066 }; 7067 LinkedList.prototype.map = function (callback) { 7068 return this.reduce(function (memo, cur) { 7069 memo.push(callback(cur)); 7070 return memo; 7071 }, []); 7072 }; 7073 LinkedList.prototype.reduce = function (callback, memo) { 7074 var cur, next = this.iterator(); 7075 while ((cur = next())) { 7076 memo = callback(memo, cur); 7077 } 7078 return memo; 7079 }; 7080 return LinkedList; 7081 }()); 7082 exports.default = LinkedList; 7083 7084 7085 /***/ }), 7086 /* 45 */ 7087 /***/ (function(module, exports, __webpack_require__) { 7088 7089 "use strict"; 7090 7091 var __extends = (this && this.__extends) || (function () { 7092 var extendStatics = Object.setPrototypeOf || 7093 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 7094 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 7095 return function (d, b) { 7096 extendStatics(d, b); 7097 function __() { this.constructor = d; } 7098 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 7099 }; 7100 })(); 7101 Object.defineProperty(exports, "__esModule", { value: true }); 7102 var container_1 = __webpack_require__(17); 7103 var Registry = __webpack_require__(1); 7104 var OBSERVER_CONFIG = { 7105 attributes: true, 7106 characterData: true, 7107 characterDataOldValue: true, 7108 childList: true, 7109 subtree: true, 7110 }; 7111 var MAX_OPTIMIZE_ITERATIONS = 100; 7112 var ScrollBlot = /** @class */ (function (_super) { 7113 __extends(ScrollBlot, _super); 7114 function ScrollBlot(node) { 7115 var _this = _super.call(this, node) || this; 7116 _this.scroll = _this; 7117 _this.observer = new MutationObserver(function (mutations) { 7118 _this.update(mutations); 7119 }); 7120 _this.observer.observe(_this.domNode, OBSERVER_CONFIG); 7121 _this.attach(); 7122 return _this; 7123 } 7124 ScrollBlot.prototype.detach = function () { 7125 _super.prototype.detach.call(this); 7126 this.observer.disconnect(); 7127 }; 7128 ScrollBlot.prototype.deleteAt = function (index, length) { 7129 this.update(); 7130 if (index === 0 && length === this.length()) { 7131 this.children.forEach(function (child) { 7132 child.remove(); 7133 }); 7134 } 7135 else { 7136 _super.prototype.deleteAt.call(this, index, length); 7137 } 7138 }; 7139 ScrollBlot.prototype.formatAt = function (index, length, name, value) { 7140 this.update(); 7141 _super.prototype.formatAt.call(this, index, length, name, value); 7142 }; 7143 ScrollBlot.prototype.insertAt = function (index, value, def) { 7144 this.update(); 7145 _super.prototype.insertAt.call(this, index, value, def); 7146 }; 7147 ScrollBlot.prototype.optimize = function (mutations, context) { 7148 var _this = this; 7149 if (mutations === void 0) { mutations = []; } 7150 if (context === void 0) { context = {}; } 7151 _super.prototype.optimize.call(this, context); 7152 // We must modify mutations directly, cannot make copy and then modify 7153 var records = [].slice.call(this.observer.takeRecords()); 7154 // Array.push currently seems to be implemented by a non-tail recursive function 7155 // so we cannot just mutations.push.apply(mutations, this.observer.takeRecords()); 7156 while (records.length > 0) 7157 mutations.push(records.pop()); 7158 // TODO use WeakMap 7159 var mark = function (blot, markParent) { 7160 if (markParent === void 0) { markParent = true; } 7161 if (blot == null || blot === _this) 7162 return; 7163 if (blot.domNode.parentNode == null) 7164 return; 7165 // @ts-ignore 7166 if (blot.domNode[Registry.DATA_KEY].mutations == null) { 7167 // @ts-ignore 7168 blot.domNode[Registry.DATA_KEY].mutations = []; 7169 } 7170 if (markParent) 7171 mark(blot.parent); 7172 }; 7173 var optimize = function (blot) { 7174 // Post-order traversal 7175 if ( 7176 // @ts-ignore 7177 blot.domNode[Registry.DATA_KEY] == null || 7178 // @ts-ignore 7179 blot.domNode[Registry.DATA_KEY].mutations == null) { 7180 return; 7181 } 7182 if (blot instanceof container_1.default) { 7183 blot.children.forEach(optimize); 7184 } 7185 blot.optimize(context); 7186 }; 7187 var remaining = mutations; 7188 for (var i = 0; remaining.length > 0; i += 1) { 7189 if (i >= MAX_OPTIMIZE_ITERATIONS) { 7190 throw new Error('[Parchment] Maximum optimize iterations reached'); 7191 } 7192 remaining.forEach(function (mutation) { 7193 var blot = Registry.find(mutation.target, true); 7194 if (blot == null) 7195 return; 7196 if (blot.domNode === mutation.target) { 7197 if (mutation.type === 'childList') { 7198 mark(Registry.find(mutation.previousSibling, false)); 7199 [].forEach.call(mutation.addedNodes, function (node) { 7200 var child = Registry.find(node, false); 7201 mark(child, false); 7202 if (child instanceof container_1.default) { 7203 child.children.forEach(function (grandChild) { 7204 mark(grandChild, false); 7205 }); 7206 } 7207 }); 7208 } 7209 else if (mutation.type === 'attributes') { 7210 mark(blot.prev); 7211 } 7212 } 7213 mark(blot); 7214 }); 7215 this.children.forEach(optimize); 7216 remaining = [].slice.call(this.observer.takeRecords()); 7217 records = remaining.slice(); 7218 while (records.length > 0) 7219 mutations.push(records.pop()); 7220 } 7221 }; 7222 ScrollBlot.prototype.update = function (mutations, context) { 7223 var _this = this; 7224 if (context === void 0) { context = {}; } 7225 mutations = mutations || this.observer.takeRecords(); 7226 // TODO use WeakMap 7227 mutations 7228 .map(function (mutation) { 7229 var blot = Registry.find(mutation.target, true); 7230 if (blot == null) 7231 return null; 7232 // @ts-ignore 7233 if (blot.domNode[Registry.DATA_KEY].mutations == null) { 7234 // @ts-ignore 7235 blot.domNode[Registry.DATA_KEY].mutations = [mutation]; 7236 return blot; 7237 } 7238 else { 7239 // @ts-ignore 7240 blot.domNode[Registry.DATA_KEY].mutations.push(mutation); 7241 return null; 7242 } 7243 }) 7244 .forEach(function (blot) { 7245 if (blot == null || 7246 blot === _this || 7247 //@ts-ignore 7248 blot.domNode[Registry.DATA_KEY] == null) 7249 return; 7250 // @ts-ignore 7251 blot.update(blot.domNode[Registry.DATA_KEY].mutations || [], context); 7252 }); 7253 // @ts-ignore 7254 if (this.domNode[Registry.DATA_KEY].mutations != null) { 7255 // @ts-ignore 7256 _super.prototype.update.call(this, this.domNode[Registry.DATA_KEY].mutations, context); 7257 } 7258 this.optimize(mutations, context); 7259 }; 7260 ScrollBlot.blotName = 'scroll'; 7261 ScrollBlot.defaultChild = 'block'; 7262 ScrollBlot.scope = Registry.Scope.BLOCK_BLOT; 7263 ScrollBlot.tagName = 'DIV'; 7264 return ScrollBlot; 7265 }(container_1.default)); 7266 exports.default = ScrollBlot; 7267 7268 7269 /***/ }), 7270 /* 46 */ 7271 /***/ (function(module, exports, __webpack_require__) { 7272 7273 "use strict"; 7274 7275 var __extends = (this && this.__extends) || (function () { 7276 var extendStatics = Object.setPrototypeOf || 7277 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 7278 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 7279 return function (d, b) { 7280 extendStatics(d, b); 7281 function __() { this.constructor = d; } 7282 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 7283 }; 7284 })(); 7285 Object.defineProperty(exports, "__esModule", { value: true }); 7286 var format_1 = __webpack_require__(18); 7287 var Registry = __webpack_require__(1); 7288// Shallow object comparison 7289 function isEqual(obj1, obj2) { 7290 if (Object.keys(obj1).length !== Object.keys(obj2).length) 7291 return false; 7292 // @ts-ignore 7293 for (var prop in obj1) { 7294 // @ts-ignore 7295 if (obj1[prop] !== obj2[prop]) 7296 return false; 7297 } 7298 return true; 7299 } 7300 var InlineBlot = /** @class */ (function (_super) { 7301 __extends(InlineBlot, _super); 7302 function InlineBlot() { 7303 return _super !== null && _super.apply(this, arguments) || this; 7304 } 7305 InlineBlot.formats = function (domNode) { 7306 if (domNode.tagName === InlineBlot.tagName) 7307 return undefined; 7308 return _super.formats.call(this, domNode); 7309 }; 7310 InlineBlot.prototype.format = function (name, value) { 7311 var _this = this; 7312 if (name === this.statics.blotName && !value) { 7313 this.children.forEach(function (child) { 7314 if (!(child instanceof format_1.default)) { 7315 child = child.wrap(InlineBlot.blotName, true); 7316 } 7317 _this.attributes.copy(child); 7318 }); 7319 this.unwrap(); 7320 } 7321 else { 7322 _super.prototype.format.call(this, name, value); 7323 } 7324 }; 7325 InlineBlot.prototype.formatAt = function (index, length, name, value) { 7326 if (this.formats()[name] != null || Registry.query(name, Registry.Scope.ATTRIBUTE)) { 7327 var blot = this.isolate(index, length); 7328 blot.format(name, value); 7329 } 7330 else { 7331 _super.prototype.formatAt.call(this, index, length, name, value); 7332 } 7333 }; 7334 InlineBlot.prototype.optimize = function (context) { 7335 _super.prototype.optimize.call(this, context); 7336 var formats = this.formats(); 7337 if (Object.keys(formats).length === 0) { 7338 return this.unwrap(); // unformatted span 7339 } 7340 var next = this.next; 7341 if (next instanceof InlineBlot && next.prev === this && isEqual(formats, next.formats())) { 7342 next.moveChildren(this); 7343 next.remove(); 7344 } 7345 }; 7346 InlineBlot.blotName = 'inline'; 7347 InlineBlot.scope = Registry.Scope.INLINE_BLOT; 7348 InlineBlot.tagName = 'SPAN'; 7349 return InlineBlot; 7350 }(format_1.default)); 7351 exports.default = InlineBlot; 7352 7353 7354 /***/ }), 7355 /* 47 */ 7356 /***/ (function(module, exports, __webpack_require__) { 7357 7358 "use strict"; 7359 7360 var __extends = (this && this.__extends) || (function () { 7361 var extendStatics = Object.setPrototypeOf || 7362 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 7363 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 7364 return function (d, b) { 7365 extendStatics(d, b); 7366 function __() { this.constructor = d; } 7367 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 7368 }; 7369 })(); 7370 Object.defineProperty(exports, "__esModule", { value: true }); 7371 var format_1 = __webpack_require__(18); 7372 var Registry = __webpack_require__(1); 7373 var BlockBlot = /** @class */ (function (_super) { 7374 __extends(BlockBlot, _super); 7375 function BlockBlot() { 7376 return _super !== null && _super.apply(this, arguments) || this; 7377 } 7378 BlockBlot.formats = function (domNode) { 7379 var tagName = Registry.query(BlockBlot.blotName).tagName; 7380 if (domNode.tagName === tagName) 7381 return undefined; 7382 return _super.formats.call(this, domNode); 7383 }; 7384 BlockBlot.prototype.format = function (name, value) { 7385 if (Registry.query(name, Registry.Scope.BLOCK) == null) { 7386 return; 7387 } 7388 else if (name === this.statics.blotName && !value) { 7389 this.replaceWith(BlockBlot.blotName); 7390 } 7391 else { 7392 _super.prototype.format.call(this, name, value); 7393 } 7394 }; 7395 BlockBlot.prototype.formatAt = function (index, length, name, value) { 7396 if (Registry.query(name, Registry.Scope.BLOCK) != null) { 7397 this.format(name, value); 7398 } 7399 else { 7400 _super.prototype.formatAt.call(this, index, length, name, value); 7401 } 7402 }; 7403 BlockBlot.prototype.insertAt = function (index, value, def) { 7404 if (def == null || Registry.query(value, Registry.Scope.INLINE) != null) { 7405 // Insert text or inline 7406 _super.prototype.insertAt.call(this, index, value, def); 7407 } 7408 else { 7409 var after = this.split(index); 7410 var blot = Registry.create(value, def); 7411 after.parent.insertBefore(blot, after); 7412 } 7413 }; 7414 BlockBlot.prototype.update = function (mutations, context) { 7415 if (navigator.userAgent.match(/Trident/)) { 7416 this.build(); 7417 } 7418 else { 7419 _super.prototype.update.call(this, mutations, context); 7420 } 7421 }; 7422 BlockBlot.blotName = 'block'; 7423 BlockBlot.scope = Registry.Scope.BLOCK_BLOT; 7424 BlockBlot.tagName = 'P'; 7425 return BlockBlot; 7426 }(format_1.default)); 7427 exports.default = BlockBlot; 7428 7429 7430 /***/ }), 7431 /* 48 */ 7432 /***/ (function(module, exports, __webpack_require__) { 7433 7434 "use strict"; 7435 7436 var __extends = (this && this.__extends) || (function () { 7437 var extendStatics = Object.setPrototypeOf || 7438 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 7439 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 7440 return function (d, b) { 7441 extendStatics(d, b); 7442 function __() { this.constructor = d; } 7443 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 7444 }; 7445 })(); 7446 Object.defineProperty(exports, "__esModule", { value: true }); 7447 var leaf_1 = __webpack_require__(19); 7448 var EmbedBlot = /** @class */ (function (_super) { 7449 __extends(EmbedBlot, _super); 7450 function EmbedBlot() { 7451 return _super !== null && _super.apply(this, arguments) || this; 7452 } 7453 EmbedBlot.formats = function (domNode) { 7454 return undefined; 7455 }; 7456 EmbedBlot.prototype.format = function (name, value) { 7457 // super.formatAt wraps, which is what we want in general, 7458 // but this allows subclasses to overwrite for formats 7459 // that just apply to particular embeds 7460 _super.prototype.formatAt.call(this, 0, this.length(), name, value); 7461 }; 7462 EmbedBlot.prototype.formatAt = function (index, length, name, value) { 7463 if (index === 0 && length === this.length()) { 7464 this.format(name, value); 7465 } 7466 else { 7467 _super.prototype.formatAt.call(this, index, length, name, value); 7468 } 7469 }; 7470 EmbedBlot.prototype.formats = function () { 7471 return this.statics.formats(this.domNode); 7472 }; 7473 return EmbedBlot; 7474 }(leaf_1.default)); 7475 exports.default = EmbedBlot; 7476 7477 7478 /***/ }), 7479 /* 49 */ 7480 /***/ (function(module, exports, __webpack_require__) { 7481 7482 "use strict"; 7483 7484 var __extends = (this && this.__extends) || (function () { 7485 var extendStatics = Object.setPrototypeOf || 7486 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 7487 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; 7488 return function (d, b) { 7489 extendStatics(d, b); 7490 function __() { this.constructor = d; } 7491 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 7492 }; 7493 })(); 7494 Object.defineProperty(exports, "__esModule", { value: true }); 7495 var leaf_1 = __webpack_require__(19); 7496 var Registry = __webpack_require__(1); 7497 var TextBlot = /** @class */ (function (_super) { 7498 __extends(TextBlot, _super); 7499 function TextBlot(node) { 7500 var _this = _super.call(this, node) || this; 7501 _this.text = _this.statics.value(_this.domNode); 7502 return _this; 7503 } 7504 TextBlot.create = function (value) { 7505 return document.createTextNode(value); 7506 }; 7507 TextBlot.value = function (domNode) { 7508 var text = domNode.data; 7509 // @ts-ignore 7510 if (text['normalize']) 7511 text = text['normalize'](); 7512 return text; 7513 }; 7514 TextBlot.prototype.deleteAt = function (index, length) { 7515 this.domNode.data = this.text = this.text.slice(0, index) + this.text.slice(index + length); 7516 }; 7517 TextBlot.prototype.index = function (node, offset) { 7518 if (this.domNode === node) { 7519 return offset; 7520 } 7521 return -1; 7522 }; 7523 TextBlot.prototype.insertAt = function (index, value, def) { 7524 if (def == null) { 7525 this.text = this.text.slice(0, index) + value + this.text.slice(index); 7526 this.domNode.data = this.text; 7527 } 7528 else { 7529 _super.prototype.insertAt.call(this, index, value, def); 7530 } 7531 }; 7532 TextBlot.prototype.length = function () { 7533 return this.text.length; 7534 }; 7535 TextBlot.prototype.optimize = function (context) { 7536 _super.prototype.optimize.call(this, context); 7537 this.text = this.statics.value(this.domNode); 7538 if (this.text.length === 0) { 7539 this.remove(); 7540 } 7541 else if (this.next instanceof TextBlot && this.next.prev === this) { 7542 this.insertAt(this.length(), this.next.value()); 7543 this.next.remove(); 7544 } 7545 }; 7546 TextBlot.prototype.position = function (index, inclusive) { 7547 if (inclusive === void 0) { inclusive = false; } 7548 return [this.domNode, index]; 7549 }; 7550 TextBlot.prototype.split = function (index, force) { 7551 if (force === void 0) { force = false; } 7552 if (!force) { 7553 if (index === 0) 7554 return this; 7555 if (index === this.length()) 7556 return this.next; 7557 } 7558 var after = Registry.create(this.domNode.splitText(index)); 7559 this.parent.insertBefore(after, this.next); 7560 this.text = this.statics.value(this.domNode); 7561 return after; 7562 }; 7563 TextBlot.prototype.update = function (mutations, context) { 7564 var _this = this; 7565 if (mutations.some(function (mutation) { 7566 return mutation.type === 'characterData' && mutation.target === _this.domNode; 7567 })) { 7568 this.text = this.statics.value(this.domNode); 7569 } 7570 }; 7571 TextBlot.prototype.value = function () { 7572 return this.text; 7573 }; 7574 TextBlot.blotName = 'text'; 7575 TextBlot.scope = Registry.Scope.INLINE_BLOT; 7576 return TextBlot; 7577 }(leaf_1.default)); 7578 exports.default = TextBlot; 7579 7580 7581 /***/ }), 7582 /* 50 */ 7583 /***/ (function(module, exports, __webpack_require__) { 7584 7585 "use strict"; 7586 7587 7588 var elem = document.createElement('div'); 7589 elem.classList.toggle('test-class', false); 7590 if (elem.classList.contains('test-class')) { 7591 var _toggle = DOMTokenList.prototype.toggle; 7592 DOMTokenList.prototype.toggle = function (token, force) { 7593 if (arguments.length > 1 && !this.contains(token) === !force) { 7594 return force; 7595 } else { 7596 return _toggle.call(this, token); 7597 } 7598 }; 7599 } 7600 7601 if (!String.prototype.startsWith) { 7602 String.prototype.startsWith = function (searchString, position) { 7603 position = position || 0; 7604 return this.substr(position, searchString.length) === searchString; 7605 }; 7606 } 7607 7608 if (!String.prototype.endsWith) { 7609 String.prototype.endsWith = function (searchString, position) { 7610 var subjectString = this.toString(); 7611 if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) { 7612 position = subjectString.length; 7613 } 7614 position -= searchString.length; 7615 var lastIndex = subjectString.indexOf(searchString, position); 7616 return lastIndex !== -1 && lastIndex === position; 7617 }; 7618 } 7619 7620 if (!Array.prototype.find) { 7621 Object.defineProperty(Array.prototype, "find", { 7622 value: function value(predicate) { 7623 if (this === null) { 7624 throw new TypeError('Array.prototype.find called on null or undefined'); 7625 } 7626 if (typeof predicate !== 'function') { 7627 throw new TypeError('predicate must be a function'); 7628 } 7629 var list = Object(this); 7630 var length = list.length >>> 0; 7631 var thisArg = arguments[1]; 7632 var value; 7633 7634 for (var i = 0; i < length; i++) { 7635 value = list[i]; 7636 if (predicate.call(thisArg, value, i, list)) { 7637 return value; 7638 } 7639 } 7640 return undefined; 7641 } 7642 }); 7643 } 7644 7645 document.addEventListener("DOMContentLoaded", function () { 7646 // Disable resizing in Firefox 7647 document.execCommand("enableObjectResizing", false, false); 7648 // Disable automatic linkifying in IE11 7649 document.execCommand("autoUrlDetect", false, false); 7650 }); 7651 7652 /***/ }), 7653 /* 51 */ 7654 /***/ (function(module, exports) { 7655 7656 /** 7657 * This library modifies the diff-patch-match library by Neil Fraser 7658 * by removing the patch and match functionality and certain advanced 7659 * options in the diff function. The original license is as follows: 7660 * 7661 * === 7662 * 7663 * Diff Match and Patch 7664 * 7665 * Copyright 2006 Google Inc. 7666 * http://code.google.com/p/google-diff-match-patch/ 7667 * 7668 * Licensed under the Apache License, Version 2.0 (the "License"); 7669 * you may not use this file except in compliance with the License. 7670 * You may obtain a copy of the License at 7671 * 7672 * http://www.apache.org/licenses/LICENSE-2.0 7673 * 7674 * Unless required by applicable law or agreed to in writing, software 7675 * distributed under the License is distributed on an "AS IS" BASIS, 7676 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 7677 * See the License for the specific language governing permissions and 7678 * limitations under the License. 7679 */ 7680 7681 7682 /** 7683 * The data structure representing a diff is an array of tuples: 7684 * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']] 7685 * which means: delete 'Hello', add 'Goodbye' and keep ' world.' 7686 */ 7687 var DIFF_DELETE = -1; 7688 var DIFF_INSERT = 1; 7689 var DIFF_EQUAL = 0; 7690 7691 7692 /** 7693 * Find the differences between two texts. Simplifies the problem by stripping 7694 * any common prefix or suffix off the texts before diffing. 7695 * @param {string} text1 Old string to be diffed. 7696 * @param {string} text2 New string to be diffed. 7697 * @param {Int} cursor_pos Expected edit position in text1 (optional) 7698 * @return {Array} Array of diff tuples. 7699 */ 7700 function diff_main(text1, text2, cursor_pos) { 7701 // Check for equality (speedup). 7702 if (text1 == text2) { 7703 if (text1) { 7704 return [[DIFF_EQUAL, text1]]; 7705 } 7706 return []; 7707 } 7708 7709 // Check cursor_pos within bounds 7710 if (cursor_pos < 0 || text1.length < cursor_pos) { 7711 cursor_pos = null; 7712 } 7713 7714 // Trim off common prefix (speedup). 7715 var commonlength = diff_commonPrefix(text1, text2); 7716 var commonprefix = text1.substring(0, commonlength); 7717 text1 = text1.substring(commonlength); 7718 text2 = text2.substring(commonlength); 7719 7720 // Trim off common suffix (speedup). 7721 commonlength = diff_commonSuffix(text1, text2); 7722 var commonsuffix = text1.substring(text1.length - commonlength); 7723 text1 = text1.substring(0, text1.length - commonlength); 7724 text2 = text2.substring(0, text2.length - commonlength); 7725 7726 // Compute the diff on the middle block. 7727 var diffs = diff_compute_(text1, text2); 7728 7729 // Restore the prefix and suffix. 7730 if (commonprefix) { 7731 diffs.unshift([DIFF_EQUAL, commonprefix]); 7732 } 7733 if (commonsuffix) { 7734 diffs.push([DIFF_EQUAL, commonsuffix]); 7735 } 7736 diff_cleanupMerge(diffs); 7737 if (cursor_pos != null) { 7738 diffs = fix_cursor(diffs, cursor_pos); 7739 } 7740 diffs = fix_emoji(diffs); 7741 return diffs; 7742 }; 7743 7744 7745 /** 7746 * Find the differences between two texts. Assumes that the texts do not 7747 * have any common prefix or suffix. 7748 * @param {string} text1 Old string to be diffed. 7749 * @param {string} text2 New string to be diffed. 7750 * @return {Array} Array of diff tuples. 7751 */ 7752 function diff_compute_(text1, text2) { 7753 var diffs; 7754 7755 if (!text1) { 7756 // Just add some text (speedup). 7757 return [[DIFF_INSERT, text2]]; 7758 } 7759 7760 if (!text2) { 7761 // Just delete some text (speedup). 7762 return [[DIFF_DELETE, text1]]; 7763 } 7764 7765 var longtext = text1.length > text2.length ? text1 : text2; 7766 var shorttext = text1.length > text2.length ? text2 : text1; 7767 var i = longtext.indexOf(shorttext); 7768 if (i != -1) { 7769 // Shorter text is inside the longer text (speedup). 7770 diffs = [[DIFF_INSERT, longtext.substring(0, i)], 7771 [DIFF_EQUAL, shorttext], 7772 [DIFF_INSERT, longtext.substring(i + shorttext.length)]]; 7773 // Swap insertions for deletions if diff is reversed. 7774 if (text1.length > text2.length) { 7775 diffs[0][0] = diffs[2][0] = DIFF_DELETE; 7776 } 7777 return diffs; 7778 } 7779 7780 if (shorttext.length == 1) { 7781 // Single character string. 7782 // After the previous speedup, the character can't be an equality. 7783 return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]]; 7784 } 7785 7786 // Check to see if the problem can be split in two. 7787 var hm = diff_halfMatch_(text1, text2); 7788 if (hm) { 7789 // A half-match was found, sort out the return data. 7790 var text1_a = hm[0]; 7791 var text1_b = hm[1]; 7792 var text2_a = hm[2]; 7793 var text2_b = hm[3]; 7794 var mid_common = hm[4]; 7795 // Send both pairs off for separate processing. 7796 var diffs_a = diff_main(text1_a, text2_a); 7797 var diffs_b = diff_main(text1_b, text2_b); 7798 // Merge the results. 7799 return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b); 7800 } 7801 7802 return diff_bisect_(text1, text2); 7803 }; 7804 7805 7806 /** 7807 * Find the 'middle snake' of a diff, split the problem in two 7808 * and return the recursively constructed diff. 7809 * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. 7810 * @param {string} text1 Old string to be diffed. 7811 * @param {string} text2 New string to be diffed. 7812 * @return {Array} Array of diff tuples. 7813 * @private 7814 */ 7815 function diff_bisect_(text1, text2) { 7816 // Cache the text lengths to prevent multiple calls. 7817 var text1_length = text1.length; 7818 var text2_length = text2.length; 7819 var max_d = Math.ceil((text1_length + text2_length) / 2); 7820 var v_offset = max_d; 7821 var v_length = 2 * max_d; 7822 var v1 = new Array(v_length); 7823 var v2 = new Array(v_length); 7824 // Setting all elements to -1 is faster in Chrome & Firefox than mixing 7825 // integers and undefined. 7826 for (var x = 0; x < v_length; x++) { 7827 v1[x] = -1; 7828 v2[x] = -1; 7829 } 7830 v1[v_offset + 1] = 0; 7831 v2[v_offset + 1] = 0; 7832 var delta = text1_length - text2_length; 7833 // If the total number of characters is odd, then the front path will collide 7834 // with the reverse path. 7835 var front = (delta % 2 != 0); 7836 // Offsets for start and end of k loop. 7837 // Prevents mapping of space beyond the grid. 7838 var k1start = 0; 7839 var k1end = 0; 7840 var k2start = 0; 7841 var k2end = 0; 7842 for (var d = 0; d < max_d; d++) { 7843 // Walk the front path one step. 7844 for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) { 7845 var k1_offset = v_offset + k1; 7846 var x1; 7847 if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) { 7848 x1 = v1[k1_offset + 1]; 7849 } else { 7850 x1 = v1[k1_offset - 1] + 1; 7851 } 7852 var y1 = x1 - k1; 7853 while (x1 < text1_length && y1 < text2_length && 7854 text1.charAt(x1) == text2.charAt(y1)) { 7855 x1++; 7856 y1++; 7857 } 7858 v1[k1_offset] = x1; 7859 if (x1 > text1_length) { 7860 // Ran off the right of the graph. 7861 k1end += 2; 7862 } else if (y1 > text2_length) { 7863 // Ran off the bottom of the graph. 7864 k1start += 2; 7865 } else if (front) { 7866 var k2_offset = v_offset + delta - k1; 7867 if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) { 7868 // Mirror x2 onto top-left coordinate system. 7869 var x2 = text1_length - v2[k2_offset]; 7870 if (x1 >= x2) { 7871 // Overlap detected. 7872 return diff_bisectSplit_(text1, text2, x1, y1); 7873 } 7874 } 7875 } 7876 } 7877 7878 // Walk the reverse path one step. 7879 for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) { 7880 var k2_offset = v_offset + k2; 7881 var x2; 7882 if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) { 7883 x2 = v2[k2_offset + 1]; 7884 } else { 7885 x2 = v2[k2_offset - 1] + 1; 7886 } 7887 var y2 = x2 - k2; 7888 while (x2 < text1_length && y2 < text2_length && 7889 text1.charAt(text1_length - x2 - 1) == 7890 text2.charAt(text2_length - y2 - 1)) { 7891 x2++; 7892 y2++; 7893 } 7894 v2[k2_offset] = x2; 7895 if (x2 > text1_length) { 7896 // Ran off the left of the graph. 7897 k2end += 2; 7898 } else if (y2 > text2_length) { 7899 // Ran off the top of the graph. 7900 k2start += 2; 7901 } else if (!front) { 7902 var k1_offset = v_offset + delta - k2; 7903 if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) { 7904 var x1 = v1[k1_offset]; 7905 var y1 = v_offset + x1 - k1_offset; 7906 // Mirror x2 onto top-left coordinate system. 7907 x2 = text1_length - x2; 7908 if (x1 >= x2) { 7909 // Overlap detected. 7910 return diff_bisectSplit_(text1, text2, x1, y1); 7911 } 7912 } 7913 } 7914 } 7915 } 7916 // Diff took too long and hit the deadline or 7917 // number of diffs equals number of characters, no commonality at all.
7918 return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]]; 7919 }; 7920 7921 7922 /** 7923 * Given the location of the 'middle snake', split the diff in two parts 7924 * and recurse. 7925 * @param {string} text1 Old string to be diffed. 7926 * @param {string} text2 New string to be diffed. 7927 * @param {number} x Index of split point in text1. 7928 * @param {number} y Index of split point in text2. 7929 * @return {Array} Array of diff tuples. 7930 */ 7931 function diff_bisectSplit_(text1, text2, x, y) { 7932 var text1a = text1.substring(0, x); 7933 var text2a = text2.substring(0, y); 7934 var text1b = text1.substring(x); 7935 var text2b = text2.substring(y); 7936 7937 // Compute both diffs serially. 7938 var diffs = diff_main(text1a, text2a); 7939 var diffsb = diff_main(text1b, text2b); 7940 7941 return diffs.concat(diffsb); 7942 }; 7943 7944 7945 /** 7946 * Determine the common prefix of two strings. 7947 * @param {string} text1 First string. 7948 * @param {string} text2 Second string. 7949 * @return {number} The number of characters common to the start of each 7950 * string. 7951 */ 7952 function diff_commonPrefix(text1, text2) {
7953 // Quick check for common null cases. 7954 if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) { 7955 return 0; 7956 } 7957 // Binary search. 7958 // Performance analysis: http://neil.fraser.name/news/2007/10/09/ 7959 var pointermin = 0; 7960 var pointermax = Math.min(text1.length, text2.length); 7961 var pointermid = pointermax; 7962 var pointerstart = 0; 7963 while (pointermin < pointermid) { 7964 if (text1.substring(pointerstart, pointermid) == 7965 text2.substring(pointerstart, pointermid)) { 7966 pointermin = pointermid; 7967 pointerstart = pointermin; 7968 } else { 7969 pointermax = pointermid; 7970 } 7971 pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); 7972 } 7973 return pointermid; 7974 }; 7975 7976 7977 /** 7978 * Determine the common suffix of two strings. 7979 * @param {string} text1 First string. 7980 * @param {string} text2 Second string. 7981 * @return {number} The number of characters common to the end of each string. 7982 */ 7983 function diff_commonSuffix(text1, text2) {
vendor: 59,563 bytes, lines 7984-9155
7984 // Quick check for common null cases. 7985 if (!text1 || !text2 || 7986 text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) { 7987 return 0; 7988 } 7989 // Binary search. 7990 // Performance analysis: http://neil.fraser.name/news/2007/10/09/ 7991 var pointermin = 0; 7992 var pointermax = Math.min(text1.length, text2.length); 7993 var pointermid = pointermax; 7994 var pointerend = 0; 7995 while (pointermin < pointermid) { 7996 if (text1.substring(text1.length - pointermid, text1.length - pointerend) == 7997 text2.substring(text2.length - pointermid, text2.length - pointerend)) { 7998 pointermin = pointermid; 7999 pointerend = pointermin; 8000 } else { 8001 pointermax = pointermid; 8002 } 8003 pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); 8004 } 8005 return pointermid; 8006 }; 8007 8008 8009 /** 8010 * Do the two texts share a substring which is at least half the length of the 8011 * longer text? 8012 * This speedup can produce non-minimal diffs. 8013 * @param {string} text1 First string. 8014 * @param {string} text2 Second string. 8015 * @return {Array.<string>} Five element Array, containing the prefix of 8016 * text1, the suffix of text1, the prefix of text2, the suffix of 8017 * text2 and the common middle. Or null if there was no match. 8018 */ 8019 function diff_halfMatch_(text1, text2) { 8020 var longtext = text1.length > text2.length ? text1 : text2; 8021 var shorttext = text1.length > text2.length ? text2 : text1; 8022 if (longtext.length < 4 || shorttext.length * 2 < longtext.length) { 8023 return null; // Pointless. 8024 } 8025 8026 /** 8027 * Does a substring of shorttext exist within longtext such that the substring 8028 * is at least half the length of longtext? 8029 * Closure, but does not reference any external variables. 8030 * @param {string} longtext Longer string. 8031 * @param {string} shorttext Shorter string. 8032 * @param {number} i Start index of quarter length substring within longtext. 8033 * @return {Array.<string>} Five element Array, containing the prefix of 8034 * longtext, the suffix of longtext, the prefix of shorttext, the suffix 8035 * of shorttext and the common middle. Or null if there was no match. 8036 * @private 8037 */ 8038 function diff_halfMatchI_(longtext, shorttext, i) { 8039 // Start with a 1/4 length substring at position i as a seed. 8040 var seed = longtext.substring(i, i + Math.floor(longtext.length / 4)); 8041 var j = -1; 8042 var best_common = ''; 8043 var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b; 8044 while ((j = shorttext.indexOf(seed, j + 1)) != -1) { 8045 var prefixLength = diff_commonPrefix(longtext.substring(i), 8046 shorttext.substring(j)); 8047 var suffixLength = diff_commonSuffix(longtext.substring(0, i), 8048 shorttext.substring(0, j)); 8049 if (best_common.length < suffixLength + prefixLength) { 8050 best_common = shorttext.substring(j - suffixLength, j) + 8051 shorttext.substring(j, j + prefixLength); 8052 best_longtext_a = longtext.substring(0, i - suffixLength); 8053 best_longtext_b = longtext.substring(i + prefixLength); 8054 best_shorttext_a = shorttext.substring(0, j - suffixLength); 8055 best_shorttext_b = shorttext.substring(j + prefixLength); 8056 } 8057 } 8058 if (best_common.length * 2 >= longtext.length) { 8059 return [best_longtext_a, best_longtext_b, 8060 best_shorttext_a, best_shorttext_b, best_common]; 8061 } else { 8062 return null; 8063 } 8064 } 8065 8066 // First check if the second quarter is the seed for a half-match. 8067 var hm1 = diff_halfMatchI_(longtext, shorttext, 8068 Math.ceil(longtext.length / 4)); 8069 // Check again based on the third quarter. 8070 var hm2 = diff_halfMatchI_(longtext, shorttext, 8071 Math.ceil(longtext.length / 2)); 8072 var hm; 8073 if (!hm1 && !hm2) { 8074 return null; 8075 } else if (!hm2) { 8076 hm = hm1; 8077 } else if (!hm1) { 8078 hm = hm2; 8079 } else { 8080 // Both matched. Select the longest. 8081 hm = hm1[4].length > hm2[4].length ? hm1 : hm2; 8082 } 8083 8084 // A half-match was found, sort out the return data. 8085 var text1_a, text1_b, text2_a, text2_b; 8086 if (text1.length > text2.length) { 8087 text1_a = hm[0]; 8088 text1_b = hm[1]; 8089 text2_a = hm[2]; 8090 text2_b = hm[3]; 8091 } else { 8092 text2_a = hm[0]; 8093 text2_b = hm[1]; 8094 text1_a = hm[2]; 8095 text1_b = hm[3]; 8096 } 8097 var mid_common = hm[4]; 8098 return [text1_a, text1_b, text2_a, text2_b, mid_common]; 8099 }; 8100 8101 8102 /** 8103 * Reorder and merge like edit sections. Merge equalities. 8104 * Any edit section can move as long as it doesn't cross an equality. 8105 * @param {Array} diffs Array of diff tuples. 8106 */ 8107 function diff_cleanupMerge(diffs) { 8108 diffs.push([DIFF_EQUAL, '']); // Add a dummy entry at the end. 8109 var pointer = 0; 8110 var count_delete = 0; 8111 var count_insert = 0; 8112 var text_delete = ''; 8113 var text_insert = ''; 8114 var commonlength; 8115 while (pointer < diffs.length) { 8116 switch (diffs[pointer][0]) { 8117 case DIFF_INSERT: 8118 count_insert++; 8119 text_insert += diffs[pointer][1]; 8120 pointer++; 8121 break; 8122 case DIFF_DELETE: 8123 count_delete++; 8124 text_delete += diffs[pointer][1]; 8125 pointer++; 8126 break; 8127 case DIFF_EQUAL: 8128 // Upon reaching an equality, check for prior redundancies. 8129 if (count_delete + count_insert > 1) { 8130 if (count_delete !== 0 && count_insert !== 0) { 8131 // Factor out any common prefixies. 8132 commonlength = diff_commonPrefix(text_insert, text_delete); 8133 if (commonlength !== 0) { 8134 if ((pointer - count_delete - count_insert) > 0 && 8135 diffs[pointer - count_delete - count_insert - 1][0] == 8136 DIFF_EQUAL) { 8137 diffs[pointer - count_delete - count_insert - 1][1] += 8138 text_insert.substring(0, commonlength); 8139 } else { 8140 diffs.splice(0, 0, [DIFF_EQUAL, 8141 text_insert.substring(0, commonlength)]); 8142 pointer++; 8143 } 8144 text_insert = text_insert.substring(commonlength); 8145 text_delete = text_delete.substring(commonlength); 8146 } 8147 // Factor out any common suffixies. 8148 commonlength = diff_commonSuffix(text_insert, text_delete); 8149 if (commonlength !== 0) { 8150 diffs[pointer][1] = text_insert.substring(text_insert.length - 8151 commonlength) + diffs[pointer][1]; 8152 text_insert = text_insert.substring(0, text_insert.length - 8153 commonlength); 8154 text_delete = text_delete.substring(0, text_delete.length - 8155 commonlength); 8156 } 8157 } 8158 // Delete the offending records and add the merged ones. 8159 if (count_delete === 0) { 8160 diffs.splice(pointer - count_insert, 8161 count_delete + count_insert, [DIFF_INSERT, text_insert]); 8162 } else if (count_insert === 0) { 8163 diffs.splice(pointer - count_delete, 8164 count_delete + count_insert, [DIFF_DELETE, text_delete]); 8165 } else { 8166 diffs.splice(pointer - count_delete - count_insert, 8167 count_delete + count_insert, [DIFF_DELETE, text_delete], 8168 [DIFF_INSERT, text_insert]); 8169 } 8170 pointer = pointer - count_delete - count_insert + 8171 (count_delete ? 1 : 0) + (count_insert ? 1 : 0) + 1; 8172 } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) { 8173 // Merge this equality with the previous one. 8174 diffs[pointer - 1][1] += diffs[pointer][1]; 8175 diffs.splice(pointer, 1); 8176 } else { 8177 pointer++; 8178 } 8179 count_insert = 0; 8180 count_delete = 0; 8181 text_delete = ''; 8182 text_insert = ''; 8183 break; 8184 } 8185 } 8186 if (diffs[diffs.length - 1][1] === '') { 8187 diffs.pop(); // Remove the dummy entry at the end. 8188 } 8189 8190 // Second pass: look for single edits surrounded on both sides by equalities 8191 // which can be shifted sideways to eliminate an equality. 8192 // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC 8193 var changes = false; 8194 pointer = 1; 8195 // Intentionally ignore the first and last element (don't need checking). 8196 while (pointer < diffs.length - 1) { 8197 if (diffs[pointer - 1][0] == DIFF_EQUAL && 8198 diffs[pointer + 1][0] == DIFF_EQUAL) { 8199 // This is a single edit surrounded by equalities. 8200 if (diffs[pointer][1].substring(diffs[pointer][1].length - 8201 diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) { 8202 // Shift the edit over the previous equality. 8203 diffs[pointer][1] = diffs[pointer - 1][1] + 8204 diffs[pointer][1].substring(0, diffs[pointer][1].length - 8205 diffs[pointer - 1][1].length); 8206 diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1]; 8207 diffs.splice(pointer - 1, 1); 8208 changes = true; 8209 } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) == 8210 diffs[pointer + 1][1]) { 8211 // Shift the edit over the next equality. 8212 diffs[pointer - 1][1] += diffs[pointer + 1][1]; 8213 diffs[pointer][1] = 8214 diffs[pointer][1].substring(diffs[pointer + 1][1].length) + 8215 diffs[pointer + 1][1]; 8216 diffs.splice(pointer + 1, 1); 8217 changes = true; 8218 } 8219 } 8220 pointer++; 8221 } 8222 // If shifts were made, the diff needs reordering and another shift sweep. 8223 if (changes) { 8224 diff_cleanupMerge(diffs); 8225 } 8226 }; 8227 8228 8229 var diff = diff_main; 8230 diff.INSERT = DIFF_INSERT; 8231 diff.DELETE = DIFF_DELETE; 8232 diff.EQUAL = DIFF_EQUAL; 8233 8234 module.exports = diff; 8235 8236 /* 8237 * Modify a diff such that the cursor position points to the start of a change: 8238 * E.g. 8239 * cursor_normalize_diff([[DIFF_EQUAL, 'abc']], 1) 8240 * => [1, [[DIFF_EQUAL, 'a'], [DIFF_EQUAL, 'bc']]] 8241 * cursor_normalize_diff([[DIFF_INSERT, 'new'], [DIFF_DELETE, 'xyz']], 2) 8242 * => [2, [[DIFF_INSERT, 'new'], [DIFF_DELETE, 'xy'], [DIFF_DELETE, 'z']]] 8243 * 8244 * @param {Array} diffs Array of diff tuples 8245 * @param {Int} cursor_pos Suggested edit position. Must not be out of bounds! 8246 * @return {Array} A tuple [cursor location in the modified diff, modified diff] 8247 */ 8248 function cursor_normalize_diff (diffs, cursor_pos) { 8249 if (cursor_pos === 0) { 8250 return [DIFF_EQUAL, diffs]; 8251 } 8252 for (var current_pos = 0, i = 0; i < diffs.length; i++) { 8253 var d = diffs[i]; 8254 if (d[0] === DIFF_DELETE || d[0] === DIFF_EQUAL) { 8255 var next_pos = current_pos + d[1].length; 8256 if (cursor_pos === next_pos) { 8257 return [i + 1, diffs]; 8258 } else if (cursor_pos < next_pos) { 8259 // copy to prevent side effects 8260 diffs = diffs.slice(); 8261 // split d into two diff changes 8262 var split_pos = cursor_pos - current_pos; 8263 var d_left = [d[0], d[1].slice(0, split_pos)]; 8264 var d_right = [d[0], d[1].slice(split_pos)]; 8265 diffs.splice(i, 1, d_left, d_right); 8266 return [i + 1, diffs]; 8267 } else { 8268 current_pos = next_pos; 8269 } 8270 } 8271 } 8272 throw new Error('cursor_pos is out of bounds!') 8273 } 8274 8275 /* 8276 * Modify a diff such that the edit position is "shifted" to the proposed edit location (cursor_position). 8277 * 8278 * Case 1) 8279 * Check if a naive shift is possible: 8280 * [0, X], [ 1, Y] -> [ 1, Y], [0, X] (if X + Y === Y + X) 8281 * [0, X], [-1, Y] -> [-1, Y], [0, X] (if X + Y === Y + X) - holds same result 8282 * Case 2) 8283 * Check if the following shifts are possible: 8284 * [0, 'pre'], [ 1, 'prefix'] -> [ 1, 'pre'], [0, 'pre'], [ 1, 'fix'] 8285 * [0, 'pre'], [-1, 'prefix'] -> [-1, 'pre'], [0, 'pre'], [-1, 'fix'] 8286 * ^ ^ 8287 * d d_next 8288 * 8289 * @param {Array} diffs Array of diff tuples 8290 * @param {Int} cursor_pos Suggested edit position. Must not be out of bounds! 8291 * @return {Array} Array of diff tuples 8292 */ 8293 function fix_cursor (diffs, cursor_pos) { 8294 var norm = cursor_normalize_diff(diffs, cursor_pos); 8295 var ndiffs = norm[1]; 8296 var cursor_pointer = norm[0]; 8297 var d = ndiffs[cursor_pointer]; 8298 var d_next = ndiffs[cursor_pointer + 1]; 8299 8300 if (d == null) { 8301 // Text was deleted from end of original string, 8302 // cursor is now out of bounds in new string 8303 return diffs; 8304 } else if (d[0] !== DIFF_EQUAL) { 8305 // A modification happened at the cursor location. 8306 // This is the expected outcome, so we can return the original diff. 8307 return diffs; 8308 } else { 8309 if (d_next != null && d[1] + d_next[1] === d_next[1] + d[1]) { 8310 // Case 1) 8311 // It is possible to perform a naive shift 8312 ndiffs.splice(cursor_pointer, 2, d_next, d) 8313 return merge_tuples(ndiffs, cursor_pointer, 2) 8314 } else if (d_next != null && d_next[1].indexOf(d[1]) === 0) { 8315 // Case 2) 8316 // d[1] is a prefix of d_next[1] 8317 // We can assume that d_next[0] !== 0, since d[0] === 0 8318 // Shift edit locations.. 8319 ndiffs.splice(cursor_pointer, 2, [d_next[0], d[1]], [0, d[1]]); 8320 var suffix = d_next[1].slice(d[1].length); 8321 if (suffix.length > 0) { 8322 ndiffs.splice(cursor_pointer + 2, 0, [d_next[0], suffix]); 8323 } 8324 return merge_tuples(ndiffs, cursor_pointer, 3) 8325 } else { 8326 // Not possible to perform any modification 8327 return diffs; 8328 } 8329 } 8330 } 8331 8332 /* 8333 * Check diff did not split surrogate pairs. 8334 * Ex. [0, '\uD83D'], [-1, '\uDC36'], [1, '\uDC2F'] -> [-1, '\uD83D\uDC36'], [1, '\uD83D\uDC2F'] 8335 * '\uD83D\uDC36' === 'ð¶', '\uD83D\uDC2F' === 'ð¯' 8336 * 8337 * @param {Array} diffs Array of diff tuples 8338 * @return {Array} Array of diff tuples 8339 */ 8340 function fix_emoji (diffs) { 8341 var compact = false; 8342 var starts_with_pair_end = function(str) { 8343 return str.charCodeAt(0) >= 0xDC00 && str.charCodeAt(0) <= 0xDFFF; 8344 } 8345 var ends_with_pair_start = function(str) { 8346 return str.charCodeAt(str.length-1) >= 0xD800 && str.charCodeAt(str.length-1) <= 0xDBFF; 8347 } 8348 for (var i = 2; i < diffs.length; i += 1) { 8349 if (diffs[i-2][0] === DIFF_EQUAL && ends_with_pair_start(diffs[i-2][1]) && 8350 diffs[i-1][0] === DIFF_DELETE && starts_with_pair_end(diffs[i-1][1]) && 8351 diffs[i][0] === DIFF_INSERT && starts_with_pair_end(diffs[i][1])) { 8352 compact = true; 8353 8354 diffs[i-1][1] = diffs[i-2][1].slice(-1) + diffs[i-1][1]; 8355 diffs[i][1] = diffs[i-2][1].slice(-1) + diffs[i][1]; 8356 8357 diffs[i-2][1] = diffs[i-2][1].slice(0, -1); 8358 } 8359 } 8360 if (!compact) { 8361 return diffs; 8362 } 8363 var fixed_diffs = []; 8364 for (var i = 0; i < diffs.length; i += 1) { 8365 if (diffs[i][1].length > 0) { 8366 fixed_diffs.push(diffs[i]); 8367 } 8368 } 8369 return fixed_diffs; 8370 } 8371 8372 /* 8373 * Try to merge tuples with their neigbors in a given range. 8374 * E.g. [0, 'a'], [0, 'b'] -> [0, 'ab'] 8375 * 8376 * @param {Array} diffs Array of diff tuples. 8377 * @param {Int} start Position of the first element to merge (diffs[start] is also merged with diffs[start - 1]). 8378 * @param {Int} length Number of consecutive elements to check. 8379 * @return {Array} Array of merged diff tuples. 8380 */ 8381 function merge_tuples (diffs, start, length) { 8382 // Check from (start-1) to (start+length). 8383 for (var i = start + length - 1; i >= 0 && i >= start - 1; i--) { 8384 if (i + 1 < diffs.length) { 8385 var left_d = diffs[i]; 8386 var right_d = diffs[i+1]; 8387 if (left_d[0] === right_d[1]) { 8388 diffs.splice(i, 2, [left_d[0], left_d[1] + right_d[1]]); 8389 } 8390 } 8391 } 8392 return diffs; 8393 } 8394 8395 8396 /***/ }), 8397 /* 52 */ 8398 /***/ (function(module, exports) { 8399 8400 exports = module.exports = typeof Object.keys === 'function' 8401 ? Object.keys : shim; 8402 8403 exports.shim = shim; 8404 function shim (obj) { 8405 var keys = []; 8406 for (var key in obj) keys.push(key); 8407 return keys; 8408 } 8409 8410 8411 /***/ }), 8412 /* 53 */ 8413 /***/ (function(module, exports) { 8414 8415 var supportsArgumentsClass = (function(){ 8416 return Object.prototype.toString.call(arguments) 8417 })() == '[object Arguments]'; 8418 8419 exports = module.exports = supportsArgumentsClass ? supported : unsupported; 8420 8421 exports.supported = supported; 8422 function supported(object) { 8423 return Object.prototype.toString.call(object) == '[object Arguments]'; 8424 }; 8425 8426 exports.unsupported = unsupported; 8427 function unsupported(object){ 8428 return object && 8429 typeof object == 'object' && 8430 typeof object.length == 'number' && 8431 Object.prototype.hasOwnProperty.call(object, 'callee') && 8432 !Object.prototype.propertyIsEnumerable.call(object, 'callee') || 8433 false; 8434 }; 8435 8436 8437 /***/ }), 8438 /* 54 */ 8439 /***/ (function(module, exports) { 8440 8441 'use strict'; 8442 8443 var has = Object.prototype.hasOwnProperty 8444 , prefix = '~'; 8445 8446 /** 8447 * Constructor to create a storage for our `EE` objects. 8448 * An `Events` instance is a plain object whose properties are event names. 8449 * 8450 * @constructor 8451 * @api private 8452 */ 8453 function Events() {} 8454 8455// 8456// We try to not inherit from `Object.prototype`. In some engines creating an 8457// instance in this way is faster than calling `Object.create(null)` directly. 8458// If `Object.create(null)` is not supported we prefix the event names with a 8459// character to make sure that the built-in object properties are not 8460// overridden or used as an attack vector. 8461// 8462 if (Object.create) { 8463 Events.prototype = Object.create(null); 8464 8465 // 8466 // This hack is needed because the `__proto__` property is still inherited in 8467 // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5. 8468 // 8469 if (!new Events().__proto__) prefix = false; 8470 } 8471 8472 /** 8473 * Representation of a single event listener. 8474 * 8475 * @param {Function} fn The listener function. 8476 * @param {Mixed} context The context to invoke the listener with. 8477 * @param {Boolean} [once=false] Specify if the listener is a one-time listener. 8478 * @constructor 8479 * @api private 8480 */ 8481 function EE(fn, context, once) { 8482 this.fn = fn; 8483 this.context = context; 8484 this.once = once || false; 8485 } 8486 8487 /** 8488 * Minimal `EventEmitter` interface that is molded against the Node.js 8489 * `EventEmitter` interface. 8490 * 8491 * @constructor 8492 * @api public 8493 */ 8494 function EventEmitter() { 8495 this._events = new Events(); 8496 this._eventsCount = 0; 8497 } 8498 8499 /** 8500 * Return an array listing the events for which the emitter has registered 8501 * listeners. 8502 * 8503 * @returns {Array} 8504 * @api public 8505 */ 8506 EventEmitter.prototype.eventNames = function eventNames() { 8507 var names = [] 8508 , events 8509 , name; 8510 8511 if (this._eventsCount === 0) return names; 8512 8513 for (name in (events = this._events)) { 8514 if (has.call(events, name)) names.push(prefix ? name.slice(1) : name); 8515 } 8516 8517 if (Object.getOwnPropertySymbols) { 8518 return names.concat(Object.getOwnPropertySymbols(events)); 8519 } 8520 8521 return names; 8522 }; 8523 8524 /** 8525 * Return the listeners registered for a given event. 8526 * 8527 * @param {String|Symbol} event The event name. 8528 * @param {Boolean} exists Only check if there are listeners. 8529 * @returns {Array|Boolean} 8530 * @api public 8531 */ 8532 EventEmitter.prototype.listeners = function listeners(event, exists) { 8533 var evt = prefix ? prefix + event : event 8534 , available = this._events[evt]; 8535 8536 if (exists) return !!available; 8537 if (!available) return []; 8538 if (available.fn) return [available.fn]; 8539 8540 for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) { 8541 ee[i] = available[i].fn; 8542 } 8543 8544 return ee; 8545 }; 8546 8547 /** 8548 * Calls each of the listeners registered for a given event. 8549 * 8550 * @param {String|Symbol} event The event name. 8551 * @returns {Boolean} `true` if the event had listeners, else `false`. 8552 * @api public 8553 */ 8554 EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) { 8555 var evt = prefix ? prefix + event : event; 8556 8557 if (!this._events[evt]) return false; 8558 8559 var listeners = this._events[evt] 8560 , len = arguments.length 8561 , args 8562 , i; 8563 8564 if (listeners.fn) { 8565 if (listeners.once) this.removeListener(event, listeners.fn, undefined, true); 8566 8567 switch (len) { 8568 case 1: return listeners.fn.call(listeners.context), true; 8569 case 2: return listeners.fn.call(listeners.context, a1), true; 8570 case 3: return listeners.fn.call(listeners.context, a1, a2), true; 8571 case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true; 8572 case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true; 8573 case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true; 8574 } 8575 8576 for (i = 1, args = new Array(len -1); i < len; i++) { 8577 args[i - 1] = arguments[i]; 8578 } 8579 8580 listeners.fn.apply(listeners.context, args); 8581 } else { 8582 var length = listeners.length 8583 , j; 8584 8585 for (i = 0; i < length; i++) { 8586 if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true); 8587 8588 switch (len) { 8589 case 1: listeners[i].fn.call(listeners[i].context); break; 8590 case 2: listeners[i].fn.call(listeners[i].context, a1); break; 8591 case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break; 8592 case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break; 8593 default: 8594 if (!args) for (j = 1, args = new Array(len -1); j < len; j++) { 8595 args[j - 1] = arguments[j]; 8596 } 8597 8598 listeners[i].fn.apply(listeners[i].context, args); 8599 } 8600 } 8601 } 8602 8603 return true; 8604 }; 8605 8606 /** 8607 * Add a listener for a given event. 8608 * 8609 * @param {String|Symbol} event The event name. 8610 * @param {Function} fn The listener function. 8611 * @param {Mixed} [context=this] The context to invoke the listener with. 8612 * @returns {EventEmitter} `this`. 8613 * @api public 8614 */ 8615 EventEmitter.prototype.on = function on(event, fn, context) { 8616 var listener = new EE(fn, context || this) 8617 , evt = prefix ? prefix + event : event; 8618 8619 if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++; 8620 else if (!this._events[evt].fn) this._events[evt].push(listener); 8621 else this._events[evt] = [this._events[evt], listener]; 8622 8623 return this; 8624 }; 8625 8626 /** 8627 * Add a one-time listener for a given event. 8628 * 8629 * @param {String|Symbol} event The event name. 8630 * @param {Function} fn The listener function. 8631 * @param {Mixed} [context=this] The context to invoke the listener with. 8632 * @returns {EventEmitter} `this`. 8633 * @api public 8634 */ 8635 EventEmitter.prototype.once = function once(event, fn, context) { 8636 var listener = new EE(fn, context || this, true) 8637 , evt = prefix ? prefix + event : event; 8638 8639 if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++; 8640 else if (!this._events[evt].fn) this._events[evt].push(listener); 8641 else this._events[evt] = [this._events[evt], listener]; 8642 8643 return this; 8644 }; 8645 8646 /** 8647 * Remove the listeners of a given event. 8648 * 8649 * @param {String|Symbol} event The event name. 8650 * @param {Function} fn Only remove the listeners that match this function. 8651 * @param {Mixed} context Only remove the listeners that have this context. 8652 * @param {Boolean} once Only remove one-time listeners. 8653 * @returns {EventEmitter} `this`. 8654 * @api public 8655 */ 8656 EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) { 8657 var evt = prefix ? prefix + event : event; 8658 8659 if (!this._events[evt]) return this; 8660 if (!fn) { 8661 if (--this._eventsCount === 0) this._events = new Events(); 8662 else delete this._events[evt]; 8663 return this; 8664 } 8665 8666 var listeners = this._events[evt]; 8667 8668 if (listeners.fn) { 8669 if ( 8670 listeners.fn === fn 8671 && (!once || listeners.once) 8672 && (!context || listeners.context === context) 8673 ) { 8674 if (--this._eventsCount === 0) this._events = new Events(); 8675 else delete this._events[evt]; 8676 } 8677 } else { 8678 for (var i = 0, events = [], length = listeners.length; i < length; i++) { 8679 if ( 8680 listeners[i].fn !== fn 8681 || (once && !listeners[i].once) 8682 || (context && listeners[i].context !== context) 8683 ) { 8684 events.push(listeners[i]); 8685 } 8686 } 8687 8688 // 8689 // Reset the array, or remove it completely if we have no more listeners. 8690 // 8691 if (events.length) this._events[evt] = events.length === 1 ? events[0] : events; 8692 else if (--this._eventsCount === 0) this._events = new Events(); 8693 else delete this._events[evt]; 8694 } 8695 8696 return this; 8697 }; 8698 8699 /** 8700 * Remove all listeners, or those of the specified event. 8701 * 8702 * @param {String|Symbol} [event] The event name. 8703 * @returns {EventEmitter} `this`. 8704 * @api public 8705 */ 8706 EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) { 8707 var evt; 8708 8709 if (event) { 8710 evt = prefix ? prefix + event : event; 8711 if (this._events[evt]) { 8712 if (--this._eventsCount === 0) this._events = new Events(); 8713 else delete this._events[evt]; 8714 } 8715 } else { 8716 this._events = new Events(); 8717 this._eventsCount = 0; 8718 } 8719 8720 return this; 8721 }; 8722 8723// 8724// Alias methods names because people roll like that. 8725// 8726 EventEmitter.prototype.off = EventEmitter.prototype.removeListener; 8727 EventEmitter.prototype.addListener = EventEmitter.prototype.on; 8728 8729// 8730// This function doesn't apply anymore. 8731// 8732 EventEmitter.prototype.setMaxListeners = function setMaxListeners() { 8733 return this; 8734 }; 8735 8736// 8737// Expose the prefix. 8738// 8739 EventEmitter.prefixed = prefix; 8740 8741// 8742// Allow `EventEmitter` to be imported as module namespace. 8743// 8744 EventEmitter.EventEmitter = EventEmitter; 8745 8746// 8747// Expose the module. 8748// 8749 if ('undefined' !== typeof module) { 8750 module.exports = EventEmitter; 8751 } 8752 8753 8754 /***/ }), 8755 /* 55 */ 8756 /***/ (function(module, exports, __webpack_require__) { 8757 8758 "use strict"; 8759 8760 8761 Object.defineProperty(exports, "__esModule", { 8762 value: true 8763 }); 8764 exports.matchText = exports.matchSpacing = exports.matchNewline = exports.matchBlot = exports.matchAttributor = exports.default = undefined; 8765 8766 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; 8767 8768 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 8769 8770 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 8771 8772 var _extend2 = __webpack_require__(3); 8773 8774 var _extend3 = _interopRequireDefault(_extend2); 8775 8776 var _quillDelta = __webpack_require__(2); 8777 8778 var _quillDelta2 = _interopRequireDefault(_quillDelta); 8779 8780 var _parchment = __webpack_require__(0); 8781 8782 var _parchment2 = _interopRequireDefault(_parchment); 8783 8784 var _quill = __webpack_require__(5); 8785 8786 var _quill2 = _interopRequireDefault(_quill); 8787 8788 var _logger = __webpack_require__(10); 8789 8790 var _logger2 = _interopRequireDefault(_logger); 8791 8792 var _module = __webpack_require__(9); 8793 8794 var _module2 = _interopRequireDefault(_module); 8795 8796 var _align = __webpack_require__(36); 8797 8798 var _background = __webpack_require__(37); 8799 8800 var _code = __webpack_require__(13); 8801 8802 var _code2 = _interopRequireDefault(_code); 8803 8804 var _color = __webpack_require__(26); 8805 8806 var _direction = __webpack_require__(38); 8807 8808 var _font = __webpack_require__(39); 8809 8810 var _size = __webpack_require__(40); 8811 8812 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 8813 8814 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } 8815 8816 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 8817 8818 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 8819 8820 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 8821 8822 var debug = (0, _logger2.default)('quill:clipboard'); 8823 8824 var DOM_KEY = '__ql-matcher'; 8825 8826 var CLIPBOARD_CONFIG = [[Node.TEXT_NODE, matchText], [Node.TEXT_NODE, matchNewline], ['br', matchBreak], [Node.ELEMENT_NODE, matchNewline], [Node.ELEMENT_NODE, matchBlot], [Node.ELEMENT_NODE, matchSpacing], [Node.ELEMENT_NODE, matchAttributor], [Node.ELEMENT_NODE, matchStyles], ['li', matchIndent], ['b', matchAlias.bind(matchAlias, 'bold')], ['i', matchAlias.bind(matchAlias, 'italic')], ['style', matchIgnore]]; 8827 8828 var ATTRIBUTE_ATTRIBUTORS = [_align.AlignAttribute, _direction.DirectionAttribute].reduce(function (memo, attr) { 8829 memo[attr.keyName] = attr; 8830 return memo; 8831 }, {}); 8832 8833 var STYLE_ATTRIBUTORS = [_align.AlignStyle, _background.BackgroundStyle, _color.ColorStyle, _direction.DirectionStyle, _font.FontStyle, _size.SizeStyle].reduce(function (memo, attr) { 8834 memo[attr.keyName] = attr; 8835 return memo; 8836 }, {}); 8837 8838 var Clipboard = function (_Module) { 8839 _inherits(Clipboard, _Module); 8840 8841 function Clipboard(quill, options) { 8842 _classCallCheck(this, Clipboard); 8843 8844 var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this, quill, options)); 8845 8846 _this.quill.root.addEventListener('paste', _this.onPaste.bind(_this)); 8847 _this.container = _this.quill.addContainer('ql-clipboard'); 8848 _this.container.setAttribute('contenteditable', true); 8849 _this.container.setAttribute('tabindex', -1); 8850 _this.matchers = []; 8851 CLIPBOARD_CONFIG.concat(_this.options.matchers).forEach(function (_ref) { 8852 var _ref2 = _slicedToArray(_ref, 2), 8853 selector = _ref2[0], 8854 matcher = _ref2[1]; 8855 8856 if (!options.matchVisual && matcher === matchSpacing) return; 8857 _this.addMatcher(selector, matcher); 8858 }); 8859 return _this; 8860 } 8861 8862 _createClass(Clipboard, [{ 8863 key: 'addMatcher', 8864 value: function addMatcher(selector, matcher) { 8865 this.matchers.push([selector, matcher]); 8866 } 8867 }, { 8868 key: 'convert', 8869 value: function convert(html) { 8870 if (typeof html === 'string') { 8871 this.container.innerHTML = html.replace(/\>\r?\n +\</g, '><'); // Remove spaces between tags 8872 return this.convert(); 8873 } 8874 var formats = this.quill.getFormat(this.quill.selection.savedRange.index); 8875 if (formats[_code2.default.blotName]) { 8876 var text = this.container.innerText; 8877 this.container.innerHTML = ''; 8878 return new _quillDelta2.default().insert(text, _defineProperty({}, _code2.default.blotName, formats[_code2.default.blotName])); 8879 } 8880 8881 var _prepareMatching = this.prepareMatching(), 8882 _prepareMatching2 = _slicedToArray(_prepareMatching, 2), 8883 elementMatchers = _prepareMatching2[0], 8884 textMatchers = _prepareMatching2[1]; 8885 8886 var delta = traverse(this.container, elementMatchers, textMatchers); 8887 // Remove trailing newline 8888 if (deltaEndsWith(delta, '\n') && delta.ops[delta.ops.length - 1].attributes == null) { 8889 delta = delta.compose(new _quillDelta2.default().retain(delta.length() - 1).delete(1)); 8890 } 8891 debug.log('convert', this.container.innerHTML, delta); 8892 this.container.innerHTML = ''; 8893 return delta; 8894 } 8895 }, { 8896 key: 'dangerouslyPasteHTML', 8897 value: function dangerouslyPasteHTML(index, html) { 8898 var source = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _quill2.default.sources.API; 8899 8900 if (typeof index === 'string') { 8901 this.quill.setContents(this.convert(index), html); 8902 this.quill.setSelection(0, _quill2.default.sources.SILENT); 8903 } else { 8904 var paste = this.convert(html); 8905 this.quill.updateContents(new _quillDelta2.default().retain(index).concat(paste), source); 8906 this.quill.setSelection(index + paste.length(), _quill2.default.sources.SILENT); 8907 } 8908 } 8909 }, { 8910 key: 'onPaste', 8911 value: function onPaste(e) { 8912 var _this2 = this; 8913 8914 if (e.defaultPrevented || !this.quill.isEnabled()) return; 8915 var range = this.quill.getSelection(); 8916 var delta = new _quillDelta2.default().retain(range.index); 8917 var scrollTop = this.quill.scrollingContainer.scrollTop; 8918 this.container.focus(); 8919 this.quill.selection.update(_quill2.default.sources.SILENT); 8920 setTimeout(function () { 8921 delta = delta.concat(_this2.convert()).delete(range.length); 8922 _this2.quill.updateContents(delta, _quill2.default.sources.USER); 8923 // range.length contributes to delta.length() 8924 _this2.quill.setSelection(delta.length() - range.length, _quill2.default.sources.SILENT); 8925 _this2.quill.scrollingContainer.scrollTop = scrollTop; 8926 _this2.quill.focus(); 8927 }, 1); 8928 } 8929 }, { 8930 key: 'prepareMatching', 8931 value: function prepareMatching() { 8932 var _this3 = this; 8933 8934 var elementMatchers = [], 8935 textMatchers = []; 8936 this.matchers.forEach(function (pair) { 8937 var _pair = _slicedToArray(pair, 2), 8938 selector = _pair[0], 8939 matcher = _pair[1]; 8940 8941 switch (selector) { 8942 case Node.TEXT_NODE: 8943 textMatchers.push(matcher); 8944 break; 8945 case Node.ELEMENT_NODE: 8946 elementMatchers.push(matcher); 8947 break; 8948 default: 8949 [].forEach.call(_this3.container.querySelectorAll(selector), function (node) { 8950 // TODO use weakmap 8951 node[DOM_KEY] = node[DOM_KEY] || []; 8952 node[DOM_KEY].push(matcher); 8953 }); 8954 break; 8955 } 8956 }); 8957 return [elementMatchers, textMatchers]; 8958 } 8959 }]); 8960 8961 return Clipboard; 8962 }(_module2.default); 8963 8964 Clipboard.DEFAULTS = { 8965 matchers: [], 8966 matchVisual: true 8967 }; 8968 8969 function applyFormat(delta, format, value) { 8970 if ((typeof format === 'undefined' ? 'undefined' : _typeof(format)) === 'object') { 8971 return Object.keys(format).reduce(function (delta, key) { 8972 return applyFormat(delta, key, format[key]); 8973 }, delta); 8974 } else { 8975 return delta.reduce(function (delta, op) { 8976 if (op.attributes && op.attributes[format]) { 8977 return delta.push(op); 8978 } else { 8979 return delta.insert(op.insert, (0, _extend3.default)({}, _defineProperty({}, format, value), op.attributes)); 8980 } 8981 }, new _quillDelta2.default()); 8982 } 8983 } 8984 8985 function computeStyle(node) { 8986 if (node.nodeType !== Node.ELEMENT_NODE) return {}; 8987 var DOM_KEY = '__ql-computed-style'; 8988 return node[DOM_KEY] || (node[DOM_KEY] = window.getComputedStyle(node)); 8989 } 8990 8991 function deltaEndsWith(delta, text) { 8992 var endText = ""; 8993 for (var i = delta.ops.length - 1; i >= 0 && endText.length < text.length; --i) { 8994 var op = delta.ops[i]; 8995 if (typeof op.insert !== 'string') break; 8996 endText = op.insert + endText; 8997 } 8998 return endText.slice(-1 * text.length) === text; 8999 } 9000 9001 function isLine(node) { 9002 if (node.childNodes.length === 0) return false; // Exclude embed blocks 9003 var style = computeStyle(node); 9004 return ['block', 'list-item'].indexOf(style.display) > -1; 9005 } 9006 9007 function traverse(node, elementMatchers, textMatchers) { 9008 // Post-order 9009 if (node.nodeType === node.TEXT_NODE) { 9010 return textMatchers.reduce(function (delta, matcher) { 9011 return matcher(node, delta); 9012 }, new _quillDelta2.default()); 9013 } else if (node.nodeType === node.ELEMENT_NODE) { 9014 return [].reduce.call(node.childNodes || [], function (delta, childNode) { 9015 var childrenDelta = traverse(childNode, elementMatchers, textMatchers); 9016 if (childNode.nodeType === node.ELEMENT_NODE) { 9017 childrenDelta = elementMatchers.reduce(function (childrenDelta, matcher) { 9018 return matcher(childNode, childrenDelta); 9019 }, childrenDelta); 9020 childrenDelta = (childNode[DOM_KEY] || []).reduce(function (childrenDelta, matcher) { 9021 return matcher(childNode, childrenDelta); 9022 }, childrenDelta); 9023 } 9024 return delta.concat(childrenDelta); 9025 }, new _quillDelta2.default()); 9026 } else { 9027 return new _quillDelta2.default(); 9028 } 9029 } 9030 9031 function matchAlias(format, node, delta) { 9032 return applyFormat(delta, format, true); 9033 } 9034 9035 function matchAttributor(node, delta) { 9036 var attributes = _parchment2.default.Attributor.Attribute.keys(node); 9037 var classes = _parchment2.default.Attributor.Class.keys(node); 9038 var styles = _parchment2.default.Attributor.Style.keys(node); 9039 var formats = {}; 9040 attributes.concat(classes).concat(styles).forEach(function (name) { 9041 var attr = _parchment2.default.query(name, _parchment2.default.Scope.ATTRIBUTE); 9042 if (attr != null) { 9043 formats[attr.attrName] = attr.value(node); 9044 if (formats[attr.attrName]) return; 9045 } 9046 attr = ATTRIBUTE_ATTRIBUTORS[name]; 9047 if (attr != null && (attr.attrName === name || attr.keyName === name)) { 9048 formats[attr.attrName] = attr.value(node) || undefined; 9049 } 9050 attr = STYLE_ATTRIBUTORS[name]; 9051 if (attr != null && (attr.attrName === name || attr.keyName === name)) { 9052 attr = STYLE_ATTRIBUTORS[name]; 9053 formats[attr.attrName] = attr.value(node) || undefined; 9054 } 9055 }); 9056 if (Object.keys(formats).length > 0) { 9057 delta = applyFormat(delta, formats); 9058 } 9059 return delta; 9060 } 9061 9062 function matchBlot(node, delta) { 9063 var match = _parchment2.default.query(node); 9064 if (match == null) return delta; 9065 if (match.prototype instanceof _parchment2.default.Embed) { 9066 var embed = {}; 9067 var value = match.value(node); 9068 if (value != null) { 9069 embed[match.blotName] = value; 9070 delta = new _quillDelta2.default().insert(embed, match.formats(node)); 9071 } 9072 } else if (typeof match.formats === 'function') { 9073 delta = applyFormat(delta, match.blotName, match.formats(node)); 9074 } 9075 return delta; 9076 } 9077 9078 function matchBreak(node, delta) { 9079 if (!deltaEndsWith(delta, '\n')) { 9080 delta.insert('\n'); 9081 } 9082 return delta; 9083 } 9084 9085 function matchIgnore() { 9086 return new _quillDelta2.default(); 9087 } 9088 9089 function matchIndent(node, delta) { 9090 var match = _parchment2.default.query(node); 9091 if (match == null || match.blotName !== 'list-item' || !deltaEndsWith(delta, '\n')) { 9092 return delta; 9093 } 9094 var indent = -1, 9095 parent = node.parentNode; 9096 while (!parent.classList.contains('ql-clipboard')) { 9097 if ((_parchment2.default.query(parent) || {}).blotName === 'list') { 9098 indent += 1; 9099 } 9100 parent = parent.parentNode; 9101 } 9102 if (indent <= 0) return delta; 9103 return delta.compose(new _quillDelta2.default().retain(delta.length() - 1).retain(1, { indent: indent })); 9104 } 9105 9106 function matchNewline(node, delta) { 9107 if (!deltaEndsWith(delta, '\n')) { 9108 if (isLine(node) || delta.length() > 0 && node.nextSibling && isLine(node.nextSibling)) { 9109 delta.insert('\n'); 9110 } 9111 } 9112 return delta; 9113 } 9114 9115 function matchSpacing(node, delta) { 9116 if (isLine(node) && node.nextElementSibling != null && !deltaEndsWith(delta, '\n\n')) { 9117 var nodeHeight = node.offsetHeight + parseFloat(computeStyle(node).marginTop) + parseFloat(computeStyle(node).marginBottom); 9118 if (node.nextElementSibling.offsetTop > node.offsetTop + nodeHeight * 1.5) { 9119 delta.insert('\n'); 9120 } 9121 } 9122 return delta; 9123 } 9124 9125 function matchStyles(node, delta) { 9126 var formats = {}; 9127 var style = node.style || {}; 9128 if (style.fontStyle && computeStyle(node).fontStyle === 'italic') { 9129 formats.italic = true; 9130 } 9131 if (style.fontWeight && (computeStyle(node).fontWeight.startsWith('bold') || parseInt(computeStyle(node).fontWeight) >= 700)) { 9132 formats.bold = true; 9133 } 9134 if (Object.keys(formats).length > 0) { 9135 delta = applyFormat(delta, formats); 9136 } 9137 if (parseFloat(style.textIndent || 0) > 0) { 9138 // Could be 0.5in 9139 delta = new _quillDelta2.default().insert('\t').concat(delta); 9140 } 9141 return delta; 9142 } 9143 9144 function matchText(node, delta) { 9145 var text = node.data; 9146 // Word represents empty line with <o:p> </o:p> 9147 if (node.parentNode.tagName === 'O:P') { 9148 return delta.insert(text.trim()); 9149 } 9150 if (text.trim().length === 0 && node.parentNode.classList.contains('ql-clipboard')) { 9151 return delta; 9152 } 9153 if (!computeStyle(node.parentNode).whiteSpace.startsWith('pre')) { 9154 // eslint-disable-next-line func-style 9155 var replacer = function replacer(collapse, match) {
vendor: 53,145 bytes, lines 9156-10084
9156 match = match.replace(/[^\u00a0]/g, ''); // \u00a0 is nbsp; 9157 return match.length < 1 && collapse ? ' ' : match; 9158 }; 9159 text = text.replace(/\r\n/g, ' ').replace(/\n/g, ' '); 9160 text = text.replace(/\s\s+/g, replacer.bind(replacer, true)); // collapse whitespace 9161 if (node.previousSibling == null && isLine(node.parentNode) || node.previousSibling != null && isLine(node.previousSibling)) { 9162 text = text.replace(/^\s+/, replacer.bind(replacer, false)); 9163 } 9164 if (node.nextSibling == null && isLine(node.parentNode) || node.nextSibling != null && isLine(node.nextSibling)) { 9165 text = text.replace(/\s+$/, replacer.bind(replacer, false)); 9166 } 9167 } 9168 return delta.insert(text); 9169 } 9170 9171 exports.default = Clipboard; 9172 exports.matchAttributor = matchAttributor; 9173 exports.matchBlot = matchBlot; 9174 exports.matchNewline = matchNewline; 9175 exports.matchSpacing = matchSpacing; 9176 exports.matchText = matchText; 9177 9178 /***/ }), 9179 /* 56 */ 9180 /***/ (function(module, exports, __webpack_require__) { 9181 9182 "use strict"; 9183 9184 9185 Object.defineProperty(exports, "__esModule", { 9186 value: true 9187 }); 9188 9189 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 9190 9191 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 9192 9193 var _inline = __webpack_require__(6); 9194 9195 var _inline2 = _interopRequireDefault(_inline); 9196 9197 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 9198 9199 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 9200 9201 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 9202 9203 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 9204 9205 var Bold = function (_Inline) { 9206 _inherits(Bold, _Inline); 9207 9208 function Bold() { 9209 _classCallCheck(this, Bold); 9210 9211 return _possibleConstructorReturn(this, (Bold.__proto__ || Object.getPrototypeOf(Bold)).apply(this, arguments)); 9212 } 9213 9214 _createClass(Bold, [{ 9215 key: 'optimize', 9216 value: function optimize(context) { 9217 _get(Bold.prototype.__proto__ || Object.getPrototypeOf(Bold.prototype), 'optimize', this).call(this, context); 9218 if (this.domNode.tagName !== this.statics.tagName[0]) { 9219 this.replaceWith(this.statics.blotName); 9220 } 9221 } 9222 }], [{ 9223 key: 'create', 9224 value: function create() { 9225 return _get(Bold.__proto__ || Object.getPrototypeOf(Bold), 'create', this).call(this); 9226 } 9227 }, { 9228 key: 'formats', 9229 value: function formats() { 9230 return true; 9231 } 9232 }]); 9233 9234 return Bold; 9235 }(_inline2.default); 9236 9237 Bold.blotName = 'bold'; 9238 Bold.tagName = ['STRONG', 'B']; 9239 9240 exports.default = Bold; 9241 9242 /***/ }), 9243 /* 57 */ 9244 /***/ (function(module, exports, __webpack_require__) { 9245 9246 "use strict"; 9247 9248 9249 Object.defineProperty(exports, "__esModule", { 9250 value: true 9251 }); 9252 exports.addControls = exports.default = undefined; 9253 9254 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 9255 9256 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 9257 9258 var _quillDelta = __webpack_require__(2); 9259 9260 var _quillDelta2 = _interopRequireDefault(_quillDelta); 9261 9262 var _parchment = __webpack_require__(0); 9263 9264 var _parchment2 = _interopRequireDefault(_parchment); 9265 9266 var _quill = __webpack_require__(5); 9267 9268 var _quill2 = _interopRequireDefault(_quill); 9269 9270 var _logger = __webpack_require__(10); 9271 9272 var _logger2 = _interopRequireDefault(_logger); 9273 9274 var _module = __webpack_require__(9); 9275 9276 var _module2 = _interopRequireDefault(_module); 9277 9278 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 9279 9280 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } 9281 9282 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 9283 9284 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 9285 9286 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 9287 9288 var debug = (0, _logger2.default)('quill:toolbar'); 9289 9290 var Toolbar = function (_Module) { 9291 _inherits(Toolbar, _Module); 9292 9293 function Toolbar(quill, options) { 9294 _classCallCheck(this, Toolbar); 9295 9296 var _this = _possibleConstructorReturn(this, (Toolbar.__proto__ || Object.getPrototypeOf(Toolbar)).call(this, quill, options)); 9297 9298 if (Array.isArray(_this.options.container)) { 9299 var container = document.createElement('div'); 9300 addControls(container, _this.options.container); 9301 quill.container.parentNode.insertBefore(container, quill.container); 9302 _this.container = container; 9303 } else if (typeof _this.options.container === 'string') { 9304 _this.container = document.querySelector(_this.options.container); 9305 } else { 9306 _this.container = _this.options.container; 9307 } 9308 if (!(_this.container instanceof HTMLElement)) { 9309 var _ret; 9310 9311 return _ret = debug.error('Container required for toolbar', _this.options), _possibleConstructorReturn(_this, _ret); 9312 } 9313 _this.container.classList.add('ql-toolbar'); 9314 _this.controls = []; 9315 _this.handlers = {}; 9316 Object.keys(_this.options.handlers).forEach(function (format) { 9317 _this.addHandler(format, _this.options.handlers[format]); 9318 }); 9319 [].forEach.call(_this.container.querySelectorAll('button, select'), function (input) { 9320 _this.attach(input); 9321 }); 9322 _this.quill.on(_quill2.default.events.EDITOR_CHANGE, function (type, range) { 9323 if (type === _quill2.default.events.SELECTION_CHANGE) { 9324 _this.update(range); 9325 } 9326 }); 9327 _this.quill.on(_quill2.default.events.SCROLL_OPTIMIZE, function () { 9328 var _this$quill$selection = _this.quill.selection.getRange(), 9329 _this$quill$selection2 = _slicedToArray(_this$quill$selection, 1), 9330 range = _this$quill$selection2[0]; // quill.getSelection triggers update 9331 9332 9333 _this.update(range); 9334 }); 9335 return _this; 9336 } 9337 9338 _createClass(Toolbar, [{ 9339 key: 'addHandler', 9340 value: function addHandler(format, handler) { 9341 this.handlers[format] = handler; 9342 } 9343 }, { 9344 key: 'attach', 9345 value: function attach(input) { 9346 var _this2 = this; 9347 9348 var format = [].find.call(input.classList, function (className) { 9349 return className.indexOf('ql-') === 0; 9350 }); 9351 if (!format) return; 9352 format = format.slice('ql-'.length); 9353 if (input.tagName === 'BUTTON') { 9354 input.setAttribute('type', 'button'); 9355 } 9356 if (this.handlers[format] == null) { 9357 if (this.quill.scroll.whitelist != null && this.quill.scroll.whitelist[format] == null) { 9358 debug.warn('ignoring attaching to disabled format', format, input); 9359 return; 9360 } 9361 if (_parchment2.default.query(format) == null) { 9362 debug.warn('ignoring attaching to nonexistent format', format, input); 9363 return; 9364 } 9365 } 9366 var eventName = input.tagName === 'SELECT' ? 'change' : 'click'; 9367 input.addEventListener(eventName, function (e) { 9368 var value = void 0; 9369 if (input.tagName === 'SELECT') { 9370 if (input.selectedIndex < 0) return; 9371 var selected = input.options[input.selectedIndex]; 9372 if (selected.hasAttribute('selected')) { 9373 value = false; 9374 } else { 9375 value = selected.value || false; 9376 } 9377 } else { 9378 if (input.classList.contains('ql-active')) { 9379 value = false; 9380 } else { 9381 value = input.value || !input.hasAttribute('value'); 9382 } 9383 e.preventDefault(); 9384 } 9385 _this2.quill.focus(); 9386 9387 var _quill$selection$getR = _this2.quill.selection.getRange(), 9388 _quill$selection$getR2 = _slicedToArray(_quill$selection$getR, 1), 9389 range = _quill$selection$getR2[0]; 9390 9391 if (_this2.handlers[format] != null) { 9392 _this2.handlers[format].call(_this2, value); 9393 } else if (_parchment2.default.query(format).prototype instanceof _parchment2.default.Embed) { 9394 value = prompt('Enter ' + format); 9395 if (!value) return; 9396 _this2.quill.updateContents(new _quillDelta2.default().retain(range.index).delete(range.length).insert(_defineProperty({}, format, value)), _quill2.default.sources.USER); 9397 } else { 9398 _this2.quill.format(format, value, _quill2.default.sources.USER); 9399 } 9400 _this2.update(range); 9401 }); 9402 // TODO use weakmap 9403 this.controls.push([format, input]); 9404 } 9405 }, { 9406 key: 'update', 9407 value: function update(range) { 9408 var formats = range == null ? {} : this.quill.getFormat(range); 9409 this.controls.forEach(function (pair) { 9410 var _pair = _slicedToArray(pair, 2), 9411 format = _pair[0], 9412 input = _pair[1]; 9413 9414 if (input.tagName === 'SELECT') { 9415 var option = void 0; 9416 if (range == null) { 9417 option = null; 9418 } else if (formats[format] == null) { 9419 option = input.querySelector('option[selected]'); 9420 } else if (!Array.isArray(formats[format])) { 9421 var value = formats[format]; 9422 if (typeof value === 'string') { 9423 value = value.replace(/\"/g, '\\"'); 9424 } 9425 option = input.querySelector('option[value="' + value + '"]'); 9426 } 9427 if (option == null) { 9428 input.value = ''; // TODO make configurable? 9429 input.selectedIndex = -1; 9430 } else { 9431 option.selected = true; 9432 } 9433 } else { 9434 if (range == null) { 9435 input.classList.remove('ql-active'); 9436 } else if (input.hasAttribute('value')) { 9437 // both being null should match (default values) 9438 // '1' should match with 1 (headers) 9439 var isActive = formats[format] === input.getAttribute('value') || formats[format] != null && formats[format].toString() === input.getAttribute('value') || formats[format] == null && !input.getAttribute('value'); 9440 input.classList.toggle('ql-active', isActive); 9441 } else { 9442 input.classList.toggle('ql-active', formats[format] != null); 9443 } 9444 } 9445 }); 9446 } 9447 }]); 9448 9449 return Toolbar; 9450 }(_module2.default); 9451 9452 Toolbar.DEFAULTS = {}; 9453 9454 function addButton(container, format, value) { 9455 var input = document.createElement('button'); 9456 input.setAttribute('type', 'button'); 9457 input.classList.add('ql-' + format); 9458 if (value != null) { 9459 input.value = value; 9460 } 9461 container.appendChild(input); 9462 } 9463 9464 function addControls(container, groups) { 9465 if (!Array.isArray(groups[0])) { 9466 groups = [groups]; 9467 } 9468 groups.forEach(function (controls) { 9469 var group = document.createElement('span'); 9470 group.classList.add('ql-formats'); 9471 controls.forEach(function (control) { 9472 if (typeof control === 'string') { 9473 addButton(group, control); 9474 } else { 9475 var format = Object.keys(control)[0]; 9476 var value = control[format]; 9477 if (Array.isArray(value)) { 9478 addSelect(group, format, value); 9479 } else { 9480 addButton(group, format, value); 9481 } 9482 } 9483 }); 9484 container.appendChild(group); 9485 }); 9486 } 9487 9488 function addSelect(container, format, values) { 9489 var input = document.createElement('select'); 9490 input.classList.add('ql-' + format); 9491 values.forEach(function (value) { 9492 var option = document.createElement('option'); 9493 if (value !== false) { 9494 option.setAttribute('value', value); 9495 } else { 9496 option.setAttribute('selected', 'selected'); 9497 } 9498 input.appendChild(option); 9499 }); 9500 container.appendChild(input); 9501 } 9502 9503 Toolbar.DEFAULTS = { 9504 container: null, 9505 handlers: { 9506 clean: function clean() { 9507 var _this3 = this; 9508 9509 var range = this.quill.getSelection(); 9510 if (range == null) return; 9511 if (range.length == 0) { 9512 var formats = this.quill.getFormat(); 9513 Object.keys(formats).forEach(function (name) { 9514 // Clean functionality in existing apps only clean inline formats 9515 if (_parchment2.default.query(name, _parchment2.default.Scope.INLINE) != null) { 9516 _this3.quill.format(name, false); 9517 } 9518 }); 9519 } else { 9520 this.quill.removeFormat(range, _quill2.default.sources.USER); 9521 } 9522 }, 9523 direction: function direction(value) { 9524 var align = this.quill.getFormat()['align']; 9525 if (value === 'rtl' && align == null) { 9526 this.quill.format('align', 'right', _quill2.default.sources.USER); 9527 } else if (!value && align === 'right') { 9528 this.quill.format('align', false, _quill2.default.sources.USER); 9529 } 9530 this.quill.format('direction', value, _quill2.default.sources.USER); 9531 }, 9532 indent: function indent(value) { 9533 var range = this.quill.getSelection(); 9534 var formats = this.quill.getFormat(range); 9535 var indent = parseInt(formats.indent || 0); 9536 if (value === '+1' || value === '-1') { 9537 var modifier = value === '+1' ? 1 : -1; 9538 if (formats.direction === 'rtl') modifier *= -1; 9539 this.quill.format('indent', indent + modifier, _quill2.default.sources.USER); 9540 } 9541 }, 9542 link: function link(value) { 9543 if (value === true) { 9544 value = prompt('Enter link URL:'); 9545 } 9546 this.quill.format('link', value, _quill2.default.sources.USER); 9547 }, 9548 list: function list(value) { 9549 var range = this.quill.getSelection(); 9550 var formats = this.quill.getFormat(range); 9551 if (value === 'check') { 9552 if (formats['list'] === 'checked' || formats['list'] === 'unchecked') { 9553 this.quill.format('list', false, _quill2.default.sources.USER); 9554 } else { 9555 this.quill.format('list', 'unchecked', _quill2.default.sources.USER); 9556 } 9557 } else { 9558 this.quill.format('list', value, _quill2.default.sources.USER); 9559 } 9560 } 9561 } 9562 }; 9563 9564 exports.default = Toolbar; 9565 exports.addControls = addControls; 9566 9567 /***/ }), 9568 /* 58 */ 9569 /***/ (function(module, exports) { 9570 9571 module.exports = "<svg viewbox=\"0 0 18 18\"> <polyline class=\"ql-even ql-stroke\" points=\"5 7 3 9 5 11\"></polyline> <polyline class=\"ql-even ql-stroke\" points=\"13 7 15 9 13 11\"></polyline> <line class=ql-stroke x1=10 x2=8 y1=5 y2=13></line> </svg>"; 9572 9573 /***/ }), 9574 /* 59 */ 9575 /***/ (function(module, exports, __webpack_require__) { 9576 9577 "use strict"; 9578 9579 9580 Object.defineProperty(exports, "__esModule", { 9581 value: true 9582 }); 9583 9584 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 9585 9586 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 9587 9588 var _picker = __webpack_require__(28); 9589 9590 var _picker2 = _interopRequireDefault(_picker); 9591 9592 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 9593 9594 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 9595 9596 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 9597 9598 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 9599 9600 var ColorPicker = function (_Picker) { 9601 _inherits(ColorPicker, _Picker); 9602 9603 function ColorPicker(select, label) { 9604 _classCallCheck(this, ColorPicker); 9605 9606 var _this = _possibleConstructorReturn(this, (ColorPicker.__proto__ || Object.getPrototypeOf(ColorPicker)).call(this, select)); 9607 9608 _this.label.innerHTML = label; 9609 _this.container.classList.add('ql-color-picker'); 9610 [].slice.call(_this.container.querySelectorAll('.ql-picker-item'), 0, 7).forEach(function (item) { 9611 item.classList.add('ql-primary'); 9612 }); 9613 return _this; 9614 } 9615 9616 _createClass(ColorPicker, [{ 9617 key: 'buildItem', 9618 value: function buildItem(option) { 9619 var item = _get(ColorPicker.prototype.__proto__ || Object.getPrototypeOf(ColorPicker.prototype), 'buildItem', this).call(this, option); 9620 item.style.backgroundColor = option.getAttribute('value') || ''; 9621 return item; 9622 } 9623 }, { 9624 key: 'selectItem', 9625 value: function selectItem(item, trigger) { 9626 _get(ColorPicker.prototype.__proto__ || Object.getPrototypeOf(ColorPicker.prototype), 'selectItem', this).call(this, item, trigger); 9627 var colorLabel = this.label.querySelector('.ql-color-label'); 9628 var value = item ? item.getAttribute('data-value') || '' : ''; 9629 if (colorLabel) { 9630 if (colorLabel.tagName === 'line') { 9631 colorLabel.style.stroke = value; 9632 } else { 9633 colorLabel.style.fill = value; 9634 } 9635 } 9636 } 9637 }]); 9638 9639 return ColorPicker; 9640 }(_picker2.default); 9641 9642 exports.default = ColorPicker; 9643 9644 /***/ }), 9645 /* 60 */ 9646 /***/ (function(module, exports, __webpack_require__) { 9647 9648 "use strict"; 9649 9650 9651 Object.defineProperty(exports, "__esModule", { 9652 value: true 9653 }); 9654 9655 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 9656 9657 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 9658 9659 var _picker = __webpack_require__(28); 9660 9661 var _picker2 = _interopRequireDefault(_picker); 9662 9663 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 9664 9665 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 9666 9667 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 9668 9669 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 9670 9671 var IconPicker = function (_Picker) { 9672 _inherits(IconPicker, _Picker); 9673 9674 function IconPicker(select, icons) { 9675 _classCallCheck(this, IconPicker); 9676 9677 var _this = _possibleConstructorReturn(this, (IconPicker.__proto__ || Object.getPrototypeOf(IconPicker)).call(this, select)); 9678 9679 _this.container.classList.add('ql-icon-picker'); 9680 [].forEach.call(_this.container.querySelectorAll('.ql-picker-item'), function (item) { 9681 item.innerHTML = icons[item.getAttribute('data-value') || '']; 9682 }); 9683 _this.defaultItem = _this.container.querySelector('.ql-selected'); 9684 _this.selectItem(_this.defaultItem); 9685 return _this; 9686 } 9687 9688 _createClass(IconPicker, [{ 9689 key: 'selectItem', 9690 value: function selectItem(item, trigger) { 9691 _get(IconPicker.prototype.__proto__ || Object.getPrototypeOf(IconPicker.prototype), 'selectItem', this).call(this, item, trigger); 9692 item = item || this.defaultItem; 9693 this.label.innerHTML = item.innerHTML; 9694 } 9695 }]); 9696 9697 return IconPicker; 9698 }(_picker2.default); 9699 9700 exports.default = IconPicker; 9701 9702 /***/ }), 9703 /* 61 */ 9704 /***/ (function(module, exports, __webpack_require__) { 9705 9706 "use strict"; 9707 9708 9709 Object.defineProperty(exports, "__esModule", { 9710 value: true 9711 }); 9712 9713 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 9714 9715 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 9716 9717 var Tooltip = function () { 9718 function Tooltip(quill, boundsContainer) { 9719 var _this = this; 9720 9721 _classCallCheck(this, Tooltip); 9722 9723 this.quill = quill; 9724 this.boundsContainer = boundsContainer || document.body; 9725 this.root = quill.addContainer('ql-tooltip'); 9726 this.root.innerHTML = this.constructor.TEMPLATE; 9727 if (this.quill.root === this.quill.scrollingContainer) { 9728 this.quill.root.addEventListener('scroll', function () { 9729 _this.root.style.marginTop = -1 * _this.quill.root.scrollTop + 'px'; 9730 }); 9731 } 9732 this.hide(); 9733 } 9734 9735 _createClass(Tooltip, [{ 9736 key: 'hide', 9737 value: function hide() { 9738 this.root.classList.add('ql-hidden'); 9739 } 9740 }, { 9741 key: 'position', 9742 value: function position(reference) { 9743 var left = reference.left + reference.width / 2 - this.root.offsetWidth / 2; 9744 // root.scrollTop should be 0 if scrollContainer !== root 9745 var top = reference.bottom + this.quill.root.scrollTop; 9746 this.root.style.left = left + 'px'; 9747 this.root.style.top = top + 'px'; 9748 this.root.classList.remove('ql-flip'); 9749 var containerBounds = this.boundsContainer.getBoundingClientRect(); 9750 var rootBounds = this.root.getBoundingClientRect(); 9751 var shift = 0; 9752 if (rootBounds.right > containerBounds.right) { 9753 shift = containerBounds.right - rootBounds.right; 9754 this.root.style.left = left + shift + 'px'; 9755 } 9756 if (rootBounds.left < containerBounds.left) { 9757 shift = containerBounds.left - rootBounds.left; 9758 this.root.style.left = left + shift + 'px'; 9759 } 9760 if (rootBounds.bottom > containerBounds.bottom) { 9761 var height = rootBounds.bottom - rootBounds.top; 9762 var verticalShift = reference.bottom - reference.top + height; 9763 this.root.style.top = top - verticalShift + 'px'; 9764 this.root.classList.add('ql-flip'); 9765 } 9766 return shift; 9767 } 9768 }, { 9769 key: 'show', 9770 value: function show() { 9771 this.root.classList.remove('ql-editing'); 9772 this.root.classList.remove('ql-hidden'); 9773 } 9774 }]); 9775 9776 return Tooltip; 9777 }(); 9778 9779 exports.default = Tooltip; 9780 9781 /***/ }), 9782 /* 62 */ 9783 /***/ (function(module, exports, __webpack_require__) { 9784 9785 "use strict"; 9786 9787 9788 Object.defineProperty(exports, "__esModule", { 9789 value: true 9790 }); 9791 9792 var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); 9793 9794 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 9795 9796 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 9797 9798 var _extend = __webpack_require__(3); 9799 9800 var _extend2 = _interopRequireDefault(_extend); 9801 9802 var _emitter = __webpack_require__(8); 9803 9804 var _emitter2 = _interopRequireDefault(_emitter); 9805 9806 var _base = __webpack_require__(43); 9807 9808 var _base2 = _interopRequireDefault(_base); 9809 9810 var _link = __webpack_require__(27); 9811 9812 var _link2 = _interopRequireDefault(_link); 9813 9814 var _selection = __webpack_require__(15); 9815 9816 var _icons = __webpack_require__(41); 9817 9818 var _icons2 = _interopRequireDefault(_icons); 9819 9820 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 9821 9822 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 9823 9824 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 9825 9826 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 9827 9828 var TOOLBAR_CONFIG = [[{ header: ['1', '2', '3', false] }], ['bold', 'italic', 'underline', 'link'], [{ list: 'ordered' }, { list: 'bullet' }], ['clean']]; 9829 9830 var SnowTheme = function (_BaseTheme) { 9831 _inherits(SnowTheme, _BaseTheme); 9832 9833 function SnowTheme(quill, options) { 9834 _classCallCheck(this, SnowTheme); 9835 9836 if (options.modules.toolbar != null && options.modules.toolbar.container == null) { 9837 options.modules.toolbar.container = TOOLBAR_CONFIG; 9838 } 9839 9840 var _this = _possibleConstructorReturn(this, (SnowTheme.__proto__ || Object.getPrototypeOf(SnowTheme)).call(this, quill, options)); 9841 9842 _this.quill.container.classList.add('ql-snow'); 9843 return _this; 9844 } 9845 9846 _createClass(SnowTheme, [{ 9847 key: 'extendToolbar', 9848 value: function extendToolbar(toolbar) { 9849 toolbar.container.classList.add('ql-snow'); 9850 this.buildButtons([].slice.call(toolbar.container.querySelectorAll('button')), _icons2.default); 9851 this.buildPickers([].slice.call(toolbar.container.querySelectorAll('select')), _icons2.default); 9852 this.tooltip = new SnowTooltip(this.quill, this.options.bounds); 9853 if (toolbar.container.querySelector('.ql-link')) { 9854 this.quill.keyboard.addBinding({ key: 'K', shortKey: true }, function (range, context) { 9855 toolbar.handlers['link'].call(toolbar, !context.format.link); 9856 }); 9857 } 9858 } 9859 }]); 9860 9861 return SnowTheme; 9862 }(_base2.default); 9863 9864 SnowTheme.DEFAULTS = (0, _extend2.default)(true, {}, _base2.default.DEFAULTS, { 9865 modules: { 9866 toolbar: { 9867 handlers: { 9868 link: function link(value) { 9869 if (value) { 9870 var range = this.quill.getSelection(); 9871 if (range == null || range.length == 0) return; 9872 var preview = this.quill.getText(range); 9873 if (/^\S+@\S+\.\S+$/.test(preview) && preview.indexOf('mailto:') !== 0) { 9874 preview = 'mailto:' + preview; 9875 } 9876 var tooltip = this.quill.theme.tooltip; 9877 tooltip.edit('link', preview); 9878 } else { 9879 this.quill.format('link', false); 9880 } 9881 } 9882 } 9883 } 9884 } 9885 }); 9886 9887 var SnowTooltip = function (_BaseTooltip) { 9888 _inherits(SnowTooltip, _BaseTooltip); 9889 9890 function SnowTooltip(quill, bounds) { 9891 _classCallCheck(this, SnowTooltip); 9892 9893 var _this2 = _possibleConstructorReturn(this, (SnowTooltip.__proto__ || Object.getPrototypeOf(SnowTooltip)).call(this, quill, bounds)); 9894 9895 _this2.preview = _this2.root.querySelector('a.ql-preview'); 9896 return _this2; 9897 } 9898 9899 _createClass(SnowTooltip, [{ 9900 key: 'listen', 9901 value: function listen() { 9902 var _this3 = this; 9903 9904 _get(SnowTooltip.prototype.__proto__ || Object.getPrototypeOf(SnowTooltip.prototype), 'listen', this).call(this); 9905 this.root.querySelector('a.ql-action').addEventListener('click', function (event) { 9906 if (_this3.root.classList.contains('ql-editing')) { 9907 _this3.save(); 9908 } else { 9909 _this3.edit('link', _this3.preview.textContent); 9910 } 9911 event.preventDefault(); 9912 }); 9913 this.root.querySelector('a.ql-remove').addEventListener('click', function (event) { 9914 if (_this3.linkRange != null) { 9915 var range = _this3.linkRange; 9916 _this3.restoreFocus(); 9917 _this3.quill.formatText(range, 'link', false, _emitter2.default.sources.USER); 9918 delete _this3.linkRange; 9919 } 9920 event.preventDefault(); 9921 _this3.hide(); 9922 }); 9923 this.quill.on(_emitter2.default.events.SELECTION_CHANGE, function (range, oldRange, source) { 9924 if (range == null) return; 9925 if (range.length === 0 && source === _emitter2.default.sources.USER) { 9926 var _quill$scroll$descend = _this3.quill.scroll.descendant(_link2.default, range.index), 9927 _quill$scroll$descend2 = _slicedToArray(_quill$scroll$descend, 2), 9928 link = _quill$scroll$descend2[0], 9929 offset = _quill$scroll$descend2[1]; 9930 9931 if (link != null) { 9932 _this3.linkRange = new _selection.Range(range.index - offset, link.length()); 9933 var preview = _link2.default.formats(link.domNode); 9934 _this3.preview.textContent = preview; 9935 _this3.preview.setAttribute('href', preview); 9936 _this3.show(); 9937 _this3.position(_this3.quill.getBounds(_this3.linkRange)); 9938 return; 9939 } 9940 } else { 9941 delete _this3.linkRange; 9942 } 9943 _this3.hide(); 9944 }); 9945 } 9946 }, { 9947 key: 'show', 9948 value: function show() { 9949 _get(SnowTooltip.prototype.__proto__ || Object.getPrototypeOf(SnowTooltip.prototype), 'show', this).call(this); 9950 this.root.removeAttribute('data-mode'); 9951 } 9952 }]); 9953 9954 return SnowTooltip; 9955 }(_base.BaseTooltip); 9956 9957 SnowTooltip.TEMPLATE = ['<a class="ql-preview" target="_blank" href="about:blank"></a>', '<input type="text" data-formula="e=mc^2" data-link="https://quilljs.com" data-video="Embed URL">', '<a class="ql-action"></a>', '<a class="ql-remove"></a>'].join(''); 9958 9959 exports.default = SnowTheme; 9960 9961 /***/ }), 9962 /* 63 */ 9963 /***/ (function(module, exports, __webpack_require__) { 9964 9965 "use strict"; 9966 9967 9968 Object.defineProperty(exports, "__esModule", { 9969 value: true 9970 }); 9971 9972 var _core = __webpack_require__(29); 9973 9974 var _core2 = _interopRequireDefault(_core); 9975 9976 var _align = __webpack_require__(36); 9977 9978 var _direction = __webpack_require__(38); 9979 9980 var _indent = __webpack_require__(64); 9981 9982 var _blockquote = __webpack_require__(65); 9983 9984 var _blockquote2 = _interopRequireDefault(_blockquote); 9985 9986 var _header = __webpack_require__(66); 9987 9988 var _header2 = _interopRequireDefault(_header); 9989 9990 var _list = __webpack_require__(67); 9991 9992 var _list2 = _interopRequireDefault(_list); 9993 9994 var _background = __webpack_require__(37); 9995 9996 var _color = __webpack_require__(26); 9997 9998 var _font = __webpack_require__(39); 9999 10000 var _size = __webpack_require__(40); 10001 10002 var _bold = __webpack_require__(56); 10003 10004 var _bold2 = _interopRequireDefault(_bold); 10005 10006 var _italic = __webpack_require__(68); 10007 10008 var _italic2 = _interopRequireDefault(_italic); 10009 10010 var _link = __webpack_require__(27); 10011 10012 var _link2 = _interopRequireDefault(_link); 10013 10014 var _script = __webpack_require__(69); 10015 10016 var _script2 = _interopRequireDefault(_script); 10017 10018 var _strike = __webpack_require__(70); 10019 10020 var _strike2 = _interopRequireDefault(_strike); 10021 10022 var _underline = __webpack_require__(71); 10023 10024 var _underline2 = _interopRequireDefault(_underline); 10025 10026 var _image = __webpack_require__(72); 10027 10028 var _image2 = _interopRequireDefault(_image); 10029 10030 var _video = __webpack_require__(73); 10031 10032 var _video2 = _interopRequireDefault(_video); 10033 10034 var _code = __webpack_require__(13); 10035 10036 var _code2 = _interopRequireDefault(_code); 10037 10038 var _formula = __webpack_require__(74); 10039 10040 var _formula2 = _interopRequireDefault(_formula); 10041 10042 var _syntax = __webpack_require__(75); 10043 10044 var _syntax2 = _interopRequireDefault(_syntax); 10045 10046 var _toolbar = __webpack_require__(57); 10047 10048 var _toolbar2 = _interopRequireDefault(_toolbar); 10049 10050 var _icons = __webpack_require__(41); 10051 10052 var _icons2 = _interopRequireDefault(_icons); 10053 10054 var _picker = __webpack_require__(28); 10055 10056 var _picker2 = _interopRequireDefault(_picker); 10057 10058 var _colorPicker = __webpack_require__(59); 10059 10060 var _colorPicker2 = _interopRequireDefault(_colorPicker); 10061 10062 var _iconPicker = __webpack_require__(60); 10063 10064 var _iconPicker2 = _interopRequireDefault(_iconPicker); 10065 10066 var _tooltip = __webpack_require__(61); 10067 10068 var _tooltip2 = _interopRequireDefault(_tooltip); 10069 10070 var _bubble = __webpack_require__(108); 10071 10072 var _bubble2 = _interopRequireDefault(_bubble); 10073 10074 var _snow = __webpack_require__(62); 10075 10076 var _snow2 = _interopRequireDefault(_snow); 10077 10078 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10079 10080 _core2.default.register({ 10081 'attributors/attribute/direction': _direction.DirectionAttribute, 10082 10083 'attributors/class/align': _align.AlignClass, 10084 'attributors/class/background': _background.Backgroun
10084dClass, 10085 'attributors/class/color': _color.ColorClass, 10086 'attributors/class/direction': _direction.DirectionClass, 10087 'attributors/class/font': _font.FontClass, 10088 'attributors/class/size': _size.SizeClass, 10089 10090 'attributors/style/align': _align.AlignStyle, 10091 'attributors/style/background': _background.BackgroundStyle, 10092 'attributors/style/color': _color.ColorStyle, 10093 'attributors/style/direction': _direction.DirectionStyle, 10094 'attributors/style/font': _font.FontStyle, 10095 'attributors/style/size': _size.SizeStyle 10096 }, true); 10097 10098 _core2.default.register({ 10099 'formats/align': _align.AlignClass, 10100 'formats/direction': _direction.DirectionClass, 10101 'formats/indent': _indent.IndentClass, 10102 10103 'formats/background': _background.BackgroundStyle, 10104 'formats/color': _color.ColorStyle, 10105 'formats/font': _font.FontClass, 10106 'formats/size': _size.SizeClass, 10107 10108 'formats/blockquote': _blockquote2.default,
vendor: 29,959 bytes, lines 10109-10626
10109 'formats/code-block': _code2.default, 10110 'formats/header': _header2.default, 10111 'formats/list': _list2.default, 10112 10113 'formats/bold': _bold2.default, 10114 'formats/code': _code.Code, 10115 'formats/italic': _italic2.default, 10116 'formats/link': _link2.default, 10117 'formats/script': _script2.default, 10118 'formats/strike': _strike2.default, 10119 'formats/underline': _underline2.default, 10120 10121 'formats/image': _image2.default, 10122 'formats/video': _video2.default, 10123 10124 'formats/list/item': _list.ListItem, 10125 10126 'modules/formula': _formula2.default, 10127 'modules/syntax': _syntax2.default, 10128 'modules/toolbar': _toolbar2.default, 10129 10130 'themes/bubble': _bubble2.default, 10131 'themes/snow': _snow2.default, 10132 10133 'ui/icons': _icons2.default, 10134 'ui/picker': _picker2.default, 10135 'ui/icon-picker': _iconPicker2.default, 10136 'ui/color-picker': _colorPicker2.default, 10137 'ui/tooltip': _tooltip2.default 10138 }, true); 10139 10140 exports.default = _core2.default; 10141 10142 /***/ }), 10143 /* 64 */ 10144 /***/ (function(module, exports, __webpack_require__) { 10145 10146 "use strict"; 10147 10148 10149 Object.defineProperty(exports, "__esModule", { 10150 value: true 10151 }); 10152 exports.IndentClass = undefined; 10153 10154 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10155 10156 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 10157 10158 var _parchment = __webpack_require__(0); 10159 10160 var _parchment2 = _interopRequireDefault(_parchment); 10161 10162 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10163 10164 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10165 10166 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10167 10168 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10169 10170 var IdentAttributor = function (_Parchment$Attributor) { 10171 _inherits(IdentAttributor, _Parchment$Attributor); 10172 10173 function IdentAttributor() { 10174 _classCallCheck(this, IdentAttributor); 10175 10176 return _possibleConstructorReturn(this, (IdentAttributor.__proto__ || Object.getPrototypeOf(IdentAttributor)).apply(this, arguments)); 10177 } 10178 10179 _createClass(IdentAttributor, [{ 10180 key: 'add', 10181 value: function add(node, value) { 10182 if (value === '+1' || value === '-1') { 10183 var indent = this.value(node) || 0; 10184 value = value === '+1' ? indent + 1 : indent - 1; 10185 } 10186 if (value === 0) { 10187 this.remove(node); 10188 return true; 10189 } else { 10190 return _get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'add', this).call(this, node, value); 10191 } 10192 } 10193 }, { 10194 key: 'canAdd', 10195 value: function canAdd(node, value) { 10196 return _get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'canAdd', this).call(this, node, value) || _get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'canAdd', this).call(this, node, parseInt(value)); 10197 } 10198 }, { 10199 key: 'value', 10200 value: function value(node) { 10201 return parseInt(_get(IdentAttributor.prototype.__proto__ || Object.getPrototypeOf(IdentAttributor.prototype), 'value', this).call(this, node)) || undefined; // Don't return NaN 10202 } 10203 }]); 10204 10205 return IdentAttributor; 10206 }(_parchment2.default.Attributor.Class); 10207 10208 var IndentClass = new IdentAttributor('indent', 'ql-indent', { 10209 scope: _parchment2.default.Scope.BLOCK, 10210 whitelist: [1, 2, 3, 4, 5, 6, 7, 8] 10211 }); 10212 10213 exports.IndentClass = IndentClass; 10214 10215 /***/ }), 10216 /* 65 */ 10217 /***/ (function(module, exports, __webpack_require__) { 10218 10219 "use strict"; 10220 10221 10222 Object.defineProperty(exports, "__esModule", { 10223 value: true 10224 }); 10225 10226 var _block = __webpack_require__(4); 10227 10228 var _block2 = _interopRequireDefault(_block); 10229 10230 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10231 10232 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10233 10234 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10235 10236 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10237 10238 var Blockquote = function (_Block) { 10239 _inherits(Blockquote, _Block); 10240 10241 function Blockquote() { 10242 _classCallCheck(this, Blockquote); 10243 10244 return _possibleConstructorReturn(this, (Blockquote.__proto__ || Object.getPrototypeOf(Blockquote)).apply(this, arguments)); 10245 } 10246 10247 return Blockquote; 10248 }(_block2.default); 10249 10250 Blockquote.blotName = 'blockquote'; 10251 Blockquote.tagName = 'blockquote'; 10252 10253 exports.default = Blockquote; 10254 10255 /***/ }), 10256 /* 66 */ 10257 /***/ (function(module, exports, __webpack_require__) { 10258 10259 "use strict"; 10260 10261 10262 Object.defineProperty(exports, "__esModule", { 10263 value: true 10264 }); 10265 10266 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10267 10268 var _block = __webpack_require__(4); 10269 10270 var _block2 = _interopRequireDefault(_block); 10271 10272 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10273 10274 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10275 10276 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10277 10278 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10279 10280 var Header = function (_Block) { 10281 _inherits(Header, _Block); 10282 10283 function Header() { 10284 _classCallCheck(this, Header); 10285 10286 return _possibleConstructorReturn(this, (Header.__proto__ || Object.getPrototypeOf(Header)).apply(this, arguments)); 10287 } 10288 10289 _createClass(Header, null, [{ 10290 key: 'formats', 10291 value: function formats(domNode) { 10292 return this.tagName.indexOf(domNode.tagName) + 1; 10293 } 10294 }]); 10295 10296 return Header; 10297 }(_block2.default); 10298 10299 Header.blotName = 'header'; 10300 Header.tagName = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6']; 10301 10302 exports.default = Header; 10303 10304 /***/ }), 10305 /* 67 */ 10306 /***/ (function(module, exports, __webpack_require__) { 10307 10308 "use strict"; 10309 10310 10311 Object.defineProperty(exports, "__esModule", { 10312 value: true 10313 }); 10314 exports.default = exports.ListItem = undefined; 10315 10316 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10317 10318 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 10319 10320 var _parchment = __webpack_require__(0); 10321 10322 var _parchment2 = _interopRequireDefault(_parchment); 10323 10324 var _block = __webpack_require__(4); 10325 10326 var _block2 = _interopRequireDefault(_block); 10327 10328 var _container = __webpack_require__(25); 10329 10330 var _container2 = _interopRequireDefault(_container); 10331 10332 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10333 10334 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } 10335 10336 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10337 10338 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10339 10340 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10341 10342 var ListItem = function (_Block) { 10343 _inherits(ListItem, _Block); 10344 10345 function ListItem() { 10346 _classCallCheck(this, ListItem); 10347 10348 return _possibleConstructorReturn(this, (ListItem.__proto__ || Object.getPrototypeOf(ListItem)).apply(this, arguments)); 10349 } 10350 10351 _createClass(ListItem, [{ 10352 key: 'format', 10353 value: function format(name, value) { 10354 if (name === List.blotName && !value) { 10355 this.replaceWith(_parchment2.default.create(this.statics.scope)); 10356 } else { 10357 _get(ListItem.prototype.__proto__ || Object.getPrototypeOf(ListItem.prototype), 'format', this).call(this, name, value); 10358 } 10359 } 10360 }, { 10361 key: 'remove', 10362 value: function remove() { 10363 if (this.prev == null && this.next == null) { 10364 this.parent.remove(); 10365 } else { 10366 _get(ListItem.prototype.__proto__ || Object.getPrototypeOf(ListItem.prototype), 'remove', this).call(this); 10367 } 10368 } 10369 }, { 10370 key: 'replaceWith', 10371 value: function replaceWith(name, value) { 10372 this.parent.isolate(this.offset(this.parent), this.length()); 10373 if (name === this.parent.statics.blotName) { 10374 this.parent.replaceWith(name, value); 10375 return this; 10376 } else { 10377 this.parent.unwrap(); 10378 return _get(ListItem.prototype.__proto__ || Object.getPrototypeOf(ListItem.prototype), 'replaceWith', this).call(this, name, value); 10379 } 10380 } 10381 }], [{ 10382 key: 'formats', 10383 value: function formats(domNode) { 10384 return domNode.tagName === this.tagName ? undefined : _get(ListItem.__proto__ || Object.getPrototypeOf(ListItem), 'formats', this).call(this, domNode); 10385 } 10386 }]); 10387 10388 return ListItem; 10389 }(_block2.default); 10390 10391 ListItem.blotName = 'list-item'; 10392 ListItem.tagName = 'LI'; 10393 10394 var List = function (_Container) { 10395 _inherits(List, _Container); 10396 10397 _createClass(List, null, [{ 10398 key: 'create', 10399 value: function create(value) { 10400 var tagName = value === 'ordered' ? 'OL' : 'UL'; 10401 var node = _get(List.__proto__ || Object.getPrototypeOf(List), 'create', this).call(this, tagName); 10402 if (value === 'checked' || value === 'unchecked') { 10403 node.setAttribute('data-checked', value === 'checked'); 10404 } 10405 return node; 10406 } 10407 }, { 10408 key: 'formats', 10409 value: function formats(domNode) { 10410 if (domNode.tagName === 'OL') return 'ordered'; 10411 if (domNode.tagName === 'UL') { 10412 if (domNode.hasAttribute('data-checked')) { 10413 return domNode.getAttribute('data-checked') === 'true' ? 'checked' : 'unchecked'; 10414 } else { 10415 return 'bullet'; 10416 } 10417 } 10418 return undefined; 10419 } 10420 }]); 10421 10422 function List(domNode) { 10423 _classCallCheck(this, List); 10424 10425 var _this2 = _possibleConstructorReturn(this, (List.__proto__ || Object.getPrototypeOf(List)).call(this, domNode)); 10426 10427 var listEventHandler = function listEventHandler(e) { 10428 if (e.target.parentNode !== domNode) return; 10429 var format = _this2.statics.formats(domNode); 10430 var blot = _parchment2.default.find(e.target); 10431 if (format === 'checked') { 10432 blot.format('list', 'unchecked'); 10433 } else if (format === 'unchecked') { 10434 blot.format('list', 'checked'); 10435 } 10436 }; 10437 10438 domNode.addEventListener('touchstart', listEventHandler); 10439 domNode.addEventListener('mousedown', listEventHandler); 10440 return _this2; 10441 } 10442 10443 _createClass(List, [{ 10444 key: 'format', 10445 value: function format(name, value) { 10446 if (this.children.length > 0) { 10447 this.children.tail.format(name, value); 10448 } 10449 } 10450 }, { 10451 key: 'formats', 10452 value: function formats() { 10453 // We don't inherit from FormatBlot 10454 return _defineProperty({}, this.statics.blotName, this.statics.formats(this.domNode)); 10455 } 10456 }, { 10457 key: 'insertBefore', 10458 value: function insertBefore(blot, ref) { 10459 if (blot instanceof ListItem) { 10460 _get(List.prototype.__proto__ || Object.getPrototypeOf(List.prototype), 'insertBefore', this).call(this, blot, ref); 10461 } else { 10462 var index = ref == null ? this.length() : ref.offset(this); 10463 var after = this.split(index); 10464 after.parent.insertBefore(blot, after); 10465 } 10466 } 10467 }, { 10468 key: 'optimize', 10469 value: function optimize(context) { 10470 _get(List.prototype.__proto__ || Object.getPrototypeOf(List.prototype), 'optimize', this).call(this, context); 10471 var next = this.next; 10472 if (next != null && next.prev === this && next.statics.blotName === this.statics.blotName && next.domNode.tagName === this.domNode.tagName && next.domNode.getAttribute('data-checked') === this.domNode.getAttribute('data-checked')) { 10473 next.moveChildren(this); 10474 next.remove(); 10475 } 10476 } 10477 }, { 10478 key: 'replace', 10479 value: function replace(target) { 10480 if (target.statics.blotName !== this.statics.blotName) { 10481 var item = _parchment2.default.create(this.statics.defaultChild); 10482 target.moveChildren(item); 10483 this.appendChild(item); 10484 } 10485 _get(List.prototype.__proto__ || Object.getPrototypeOf(List.prototype), 'replace', this).call(this, target); 10486 } 10487 }]); 10488 10489 return List; 10490 }(_container2.default); 10491 10492 List.blotName = 'list'; 10493 List.scope = _parchment2.default.Scope.BLOCK_BLOT; 10494 List.tagName = ['OL', 'UL']; 10495 List.defaultChild = 'list-item'; 10496 List.allowedChildren = [ListItem]; 10497 10498 exports.ListItem = ListItem; 10499 exports.default = List; 10500 10501 /***/ }), 10502 /* 68 */ 10503 /***/ (function(module, exports, __webpack_require__) { 10504 10505 "use strict"; 10506 10507 10508 Object.defineProperty(exports, "__esModule", { 10509 value: true 10510 }); 10511 10512 var _bold = __webpack_require__(56); 10513 10514 var _bold2 = _interopRequireDefault(_bold); 10515 10516 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10517 10518 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10519 10520 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10521 10522 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10523 10524 var Italic = function (_Bold) { 10525 _inherits(Italic, _Bold); 10526 10527 function Italic() { 10528 _classCallCheck(this, Italic); 10529 10530 return _possibleConstructorReturn(this, (Italic.__proto__ || Object.getPrototypeOf(Italic)).apply(this, arguments)); 10531 } 10532 10533 return Italic; 10534 }(_bold2.default); 10535 10536 Italic.blotName = 'italic'; 10537 Italic.tagName = ['EM', 'I']; 10538 10539 exports.default = Italic; 10540 10541 /***/ }), 10542 /* 69 */ 10543 /***/ (function(module, exports, __webpack_require__) { 10544 10545 "use strict"; 10546 10547 10548 Object.defineProperty(exports, "__esModule", { 10549 value: true 10550 }); 10551 10552 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10553 10554 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 10555 10556 var _inline = __webpack_require__(6); 10557 10558 var _inline2 = _interopRequireDefault(_inline); 10559 10560 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10561 10562 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10563 10564 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10565 10566 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10567 10568 var Script = function (_Inline) { 10569 _inherits(Script, _Inline); 10570 10571 function Script() { 10572 _classCallCheck(this, Script); 10573 10574 return _possibleConstructorReturn(this, (Script.__proto__ || Object.getPrototypeOf(Script)).apply(this, arguments)); 10575 } 10576 10577 _createClass(Script, null, [{ 10578 key: 'create', 10579 value: function create(value) { 10580 if (value === 'super') { 10581 return document.createElement('sup'); 10582 } else if (value === 'sub') { 10583 return document.createElement('sub'); 10584 } else { 10585 return _get(Script.__proto__ || Object.getPrototypeOf(Script), 'create', this).call(this, value); 10586 } 10587 } 10588 }, { 10589 key: 'formats', 10590 value: function formats(domNode) { 10591 if (domNode.tagName === 'SUB') return 'sub'; 10592 if (domNode.tagName === 'SUP') return 'super'; 10593 return undefined; 10594 } 10595 }]); 10596 10597 return Script; 10598 }(_inline2.default); 10599 10600 Script.blotName = 'script'; 10601 Script.tagName = ['SUB', 'SUP']; 10602 10603 exports.default = Script; 10604 10605 /***/ }), 10606 /* 70 */ 10607 /***/ (function(module, exports, __webpack_require__) { 10608 10609 "use strict"; 10610 10611 10612 Object.defineProperty(exports, "__esModule", { 10613 value: true 10614 }); 10615 10616 var _inline = __webpack_require__(6); 10617 10618 var _inline2 = _interopRequireDefault(_inline); 10619 10620 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10621 10622 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10623 10624 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10625 10626 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { c
vendor: 5,179 bytes, lines 10626-10712
10626onstructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10627 10628 var Strike = function (_Inline) { 10629 _inherits(Strike, _Inline); 10630 10631 function Strike() { 10632 _classCallCheck(this, Strike); 10633 10634 return _possibleConstructorReturn(this, (Strike.__proto__ || Object.getPrototypeOf(Strike)).apply(this, arguments)); 10635 } 10636 10637 return Strike; 10638 }(_inline2.default); 10639 10640 Strike.blotName = 'strike'; 10641 Strike.tagName = 'S'; 10642 10643 exports.default = Strike; 10644 10645 /***/ }), 10646 /* 71 */ 10647 /***/ (function(module, exports, __webpack_require__) { 10648 10649 "use strict"; 10650 10651 10652 Object.defineProperty(exports, "__esModule", { 10653 value: true 10654 }); 10655 10656 var _inline = __webpack_require__(6); 10657 10658 var _inline2 = _interopRequireDefault(_inline); 10659 10660 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10661 10662 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10663 10664 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10665 10666 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10667 10668 var Underline = function (_Inline) { 10669 _inherits(Underline, _Inline); 10670 10671 function Underline() { 10672 _classCallCheck(this, Underline); 10673 10674 return _possibleConstructorReturn(this, (Underline.__proto__ || Object.getPrototypeOf(Underline)).apply(this, arguments)); 10675 } 10676 10677 return Underline; 10678 }(_inline2.default); 10679 10680 Underline.blotName = 'underline'; 10681 Underline.tagName = 'U'; 10682 10683 exports.default = Underline; 10684 10685 /***/ }), 10686 /* 72 */ 10687 /***/ (function(module, exports, __webpack_require__) { 10688 10689 "use strict"; 10690 10691 10692 Object.defineProperty(exports, "__esModule", { 10693 value: true 10694 }); 10695 10696 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10697 10698 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 10699 10700 var _parchment = __webpack_require__(0); 10701 10702 var _parchment2 = _interopRequireDefault(_parchment); 10703 10704 var _link = __webpack_require__(27); 10705 10706 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10707 10708 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10709 10710 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10711 10712 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { c
vendor: 22,174 bytes, lines 10712-11123
10712onstructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10713 10714 var ATTRIBUTES = ['alt', 'height', 'width']; 10715 10716 var Image = function (_Parchment$Embed) { 10717 _inherits(Image, _Parchment$Embed); 10718 10719 function Image() { 10720 _classCallCheck(this, Image); 10721 10722 return _possibleConstructorReturn(this, (Image.__proto__ || Object.getPrototypeOf(Image)).apply(this, arguments)); 10723 } 10724 10725 _createClass(Image, [{ 10726 key: 'format', 10727 value: function format(name, value) { 10728 if (ATTRIBUTES.indexOf(name) > -1) { 10729 if (value) { 10730 this.domNode.setAttribute(name, value); 10731 } else { 10732 this.domNode.removeAttribute(name); 10733 } 10734 } else { 10735 _get(Image.prototype.__proto__ || Object.getPrototypeOf(Image.prototype), 'format', this).call(this, name, value); 10736 } 10737 } 10738 }], [{ 10739 key: 'create', 10740 value: function create(value) { 10741 var node = _get(Image.__proto__ || Object.getPrototypeOf(Image), 'create', this).call(this, value); 10742 if (typeof value === 'string') { 10743 node.setAttribute('src', this.sanitize(value)); 10744 } 10745 return node; 10746 } 10747 }, { 10748 key: 'formats', 10749 value: function formats(domNode) { 10750 return ATTRIBUTES.reduce(function (formats, attribute) { 10751 if (domNode.hasAttribute(attribute)) { 10752 formats[attribute] = domNode.getAttribute(attribute); 10753 } 10754 return formats; 10755 }, {}); 10756 } 10757 }, { 10758 key: 'match', 10759 value: function match(url) { 10760 return (/\.(jpe?g|gif|png)$/.test(url) || /^data:image\/.+;base64/.test(url) 10761 ); 10762 } 10763 }, { 10764 key: 'sanitize', 10765 value: function sanitize(url) { 10766 return (0, _link.sanitize)(url, ['http', 'https', 'data']) ? url : '//:0'; 10767 } 10768 }, { 10769 key: 'value', 10770 value: function value(domNode) { 10771 return domNode.getAttribute('src'); 10772 } 10773 }]); 10774 10775 return Image; 10776 }(_parchment2.default.Embed); 10777 10778 Image.blotName = 'image'; 10779 Image.tagName = 'IMG'; 10780 10781 exports.default = Image; 10782 10783 /***/ }), 10784 /* 73 */ 10785 /***/ (function(module, exports, __webpack_require__) { 10786 10787 "use strict"; 10788 10789 10790 Object.defineProperty(exports, "__esModule", { 10791 value: true 10792 }); 10793 10794 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10795 10796 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 10797 10798 var _block = __webpack_require__(4); 10799 10800 var _link = __webpack_require__(27); 10801 10802 var _link2 = _interopRequireDefault(_link); 10803 10804 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10805 10806 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10807 10808 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10809 10810 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10811 10812 var ATTRIBUTES = ['height', 'width']; 10813 10814 var Video = function (_BlockEmbed) { 10815 _inherits(Video, _BlockEmbed); 10816 10817 function Video() { 10818 _classCallCheck(this, Video); 10819 10820 return _possibleConstructorReturn(this, (Video.__proto__ || Object.getPrototypeOf(Video)).apply(this, arguments)); 10821 } 10822 10823 _createClass(Video, [{ 10824 key: 'format', 10825 value: function format(name, value) { 10826 if (ATTRIBUTES.indexOf(name) > -1) { 10827 if (value) { 10828 this.domNode.setAttribute(name, value); 10829 } else { 10830 this.domNode.removeAttribute(name); 10831 } 10832 } else { 10833 _get(Video.prototype.__proto__ || Object.getPrototypeOf(Video.prototype), 'format', this).call(this, name, value); 10834 } 10835 } 10836 }], [{ 10837 key: 'create', 10838 value: function create(value) { 10839 var node = _get(Video.__proto__ || Object.getPrototypeOf(Video), 'create', this).call(this, value); 10840 node.setAttribute('frameborder', '0'); 10841 node.setAttribute('allowfullscreen', true); 10842 node.setAttribute('src', this.sanitize(value)); 10843 return node; 10844 } 10845 }, { 10846 key: 'formats', 10847 value: function formats(domNode) { 10848 return ATTRIBUTES.reduce(function (formats, attribute) { 10849 if (domNode.hasAttribute(attribute)) { 10850 formats[attribute] = domNode.getAttribute(attribute); 10851 } 10852 return formats; 10853 }, {}); 10854 } 10855 }, { 10856 key: 'sanitize', 10857 value: function sanitize(url) { 10858 return _link2.default.sanitize(url); 10859 } 10860 }, { 10861 key: 'value', 10862 value: function value(domNode) { 10863 return domNode.getAttribute('src'); 10864 } 10865 }]); 10866 10867 return Video; 10868 }(_block.BlockEmbed); 10869 10870 Video.blotName = 'video'; 10871 Video.className = 'ql-video'; 10872 Video.tagName = 'IFRAME'; 10873 10874 exports.default = Video; 10875 10876 /***/ }), 10877 /* 74 */ 10878 /***/ (function(module, exports, __webpack_require__) { 10879 10880 "use strict"; 10881 10882 10883 Object.defineProperty(exports, "__esModule", { 10884 value: true 10885 }); 10886 exports.default = exports.FormulaBlot = undefined; 10887 10888 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10889 10890 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 10891 10892 var _embed = __webpack_require__(35); 10893 10894 var _embed2 = _interopRequireDefault(_embed); 10895 10896 var _quill = __webpack_require__(5); 10897 10898 var _quill2 = _interopRequireDefault(_quill); 10899 10900 var _module = __webpack_require__(9); 10901 10902 var _module2 = _interopRequireDefault(_module); 10903 10904 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 10905 10906 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 10907 10908 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 10909 10910 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 10911 10912 var FormulaBlot = function (_Embed) { 10913 _inherits(FormulaBlot, _Embed); 10914 10915 function FormulaBlot() { 10916 _classCallCheck(this, FormulaBlot); 10917 10918 return _possibleConstructorReturn(this, (FormulaBlot.__proto__ || Object.getPrototypeOf(FormulaBlot)).apply(this, arguments)); 10919 } 10920 10921 _createClass(FormulaBlot, null, [{ 10922 key: 'create', 10923 value: function create(value) { 10924 var node = _get(FormulaBlot.__proto__ || Object.getPrototypeOf(FormulaBlot), 'create', this).call(this, value); 10925 if (typeof value === 'string') { 10926 window.katex.render(value, node, { 10927 throwOnError: false, 10928 errorColor: '#f00' 10929 }); 10930 node.setAttribute('data-value', value); 10931 } 10932 return node; 10933 } 10934 }, { 10935 key: 'value', 10936 value: function value(domNode) { 10937 return domNode.getAttribute('data-value'); 10938 } 10939 }]); 10940 10941 return FormulaBlot; 10942 }(_embed2.default); 10943 10944 FormulaBlot.blotName = 'formula'; 10945 FormulaBlot.className = 'ql-formula'; 10946 FormulaBlot.tagName = 'SPAN'; 10947 10948 var Formula = function (_Module) { 10949 _inherits(Formula, _Module); 10950 10951 _createClass(Formula, null, [{ 10952 key: 'register', 10953 value: function register() { 10954 _quill2.default.register(FormulaBlot, true); 10955 } 10956 }]); 10957 10958 function Formula() { 10959 _classCallCheck(this, Formula); 10960 10961 var _this2 = _possibleConstructorReturn(this, (Formula.__proto__ || Object.getPrototypeOf(Formula)).call(this)); 10962 10963 if (window.katex == null) { 10964 throw new Error('Formula module requires KaTeX.'); 10965 } 10966 return _this2; 10967 } 10968 10969 return Formula; 10970 }(_module2.default); 10971 10972 exports.FormulaBlot = FormulaBlot; 10973 exports.default = Formula; 10974 10975 /***/ }), 10976 /* 75 */ 10977 /***/ (function(module, exports, __webpack_require__) { 10978 10979 "use strict"; 10980 10981 10982 Object.defineProperty(exports, "__esModule", { 10983 value: true 10984 }); 10985 exports.default = exports.CodeToken = exports.CodeBlock = undefined; 10986 10987 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 10988 10989 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 10990 10991 var _parchment = __webpack_require__(0); 10992 10993 var _parchment2 = _interopRequireDefault(_parchment); 10994 10995 var _quill = __webpack_require__(5); 10996 10997 var _quill2 = _interopRequireDefault(_quill); 10998 10999 var _module = __webpack_require__(9); 11000 11001 var _module2 = _interopRequireDefault(_module); 11002 11003 var _code = __webpack_require__(13); 11004 11005 var _code2 = _interopRequireDefault(_code); 11006 11007 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 11008 11009 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 11010 11011 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 11012 11013 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 11014 11015 var SyntaxCodeBlock = function (_CodeBlock) { 11016 _inherits(SyntaxCodeBlock, _CodeBlock); 11017 11018 function SyntaxCodeBlock() { 11019 _classCallCheck(this, SyntaxCodeBlock); 11020 11021 return _possibleConstructorReturn(this, (SyntaxCodeBlock.__proto__ || Object.getPrototypeOf(SyntaxCodeBlock)).apply(this, arguments)); 11022 } 11023 11024 _createClass(SyntaxCodeBlock, [{ 11025 key: 'replaceWith', 11026 value: function replaceWith(block) { 11027 this.domNode.textContent = this.domNode.textContent; 11028 this.attach(); 11029 _get(SyntaxCodeBlock.prototype.__proto__ || Object.getPrototypeOf(SyntaxCodeBlock.prototype), 'replaceWith', this).call(this, block); 11030 } 11031 }, { 11032 key: 'highlight', 11033 value: function highlight(_highlight) { 11034 var text = this.domNode.textContent; 11035 if (this.cachedText !== text) { 11036 if (text.trim().length > 0 || this.cachedText == null) { 11037 this.domNode.innerHTML = _highlight(text); 11038 this.domNode.normalize(); 11039 this.attach(); 11040 } 11041 this.cachedText = text; 11042 } 11043 } 11044 }]); 11045 11046 return SyntaxCodeBlock; 11047 }(_code2.default); 11048 11049 SyntaxCodeBlock.className = 'ql-syntax'; 11050 11051 var CodeToken = new _parchment2.default.Attributor.Class('token', 'hljs', { 11052 scope: _parchment2.default.Scope.INLINE 11053 }); 11054 11055 var Syntax = function (_Module) { 11056 _inherits(Syntax, _Module); 11057 11058 _createClass(Syntax, null, [{ 11059 key: 'register', 11060 value: function register() { 11061 _quill2.default.register(CodeToken, true); 11062 _quill2.default.register(SyntaxCodeBlock, true); 11063 } 11064 }]); 11065 11066 function Syntax(quill, options) { 11067 _classCallCheck(this, Syntax); 11068 11069 var _this2 = _possibleConstructorReturn(this, (Syntax.__proto__ || Object.getPrototypeOf(Syntax)).call(this, quill, options)); 11070 11071 if (typeof _this2.options.highlight !== 'function') { 11072 throw new Error('Syntax module requires highlight.js. Please include the library on the page before Quill.'); 11073 } 11074 var timer = null; 11075 _this2.quill.on(_quill2.default.events.SCROLL_OPTIMIZE, function () { 11076 clearTimeout(timer); 11077 timer = setTimeout(function () { 11078 _this2.highlight(); 11079 timer = null; 11080 }, _this2.options.interval); 11081 }); 11082 _this2.highlight(); 11083 return _this2; 11084 } 11085 11086 _createClass(Syntax, [{ 11087 key: 'highlight', 11088 value: function highlight() { 11089 var _this3 = this; 11090 11091 if (this.quill.selection.composing) return; 11092 this.quill.update(_quill2.default.sources.USER); 11093 var range = this.quill.getSelection(); 11094 this.quill.scroll.descendants(SyntaxCodeBlock).forEach(function (code) { 11095 code.highlight(_this3.options.highlight); 11096 }); 11097 this.quill.update(_quill2.default.sources.SILENT); 11098 if (range != null) { 11099 this.quill.setSelection(range, _quill2.default.sources.SILENT); 11100 } 11101 } 11102 }]); 11103 11104 return Syntax; 11105 }(_module2.default); 11106 11107 Syntax.DEFAULTS = { 11108 highlight: function () { 11109 if (window.hljs == null) return null; 11110 return function (text) { 11111 var result = window.hljs.highlightAuto(text); 11112 return result.value; 11113 }; 11114 }(), 11115 interval: 1000 11116 }; 11117 11118 exports.CodeBlock = SyntaxCodeBlock; 11119 exports.CodeToken = CodeToken; 11120 exports.default = Syntax; 11121 11122 /***/ }), 11123 /* 76 */
11124 /***/ (function(module, exports) { 11125 11126 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=3 x2=15 y1=9 y2=9></line> <line class=ql-stroke x1=3 x2=13 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=9 y1=4 y2=4></line> </svg>"; 11127 11128 /***/ }), 11129 /* 77 */ 11130 /***/ (function(module, exports) { 11131 11132 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=15 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=14 x2=4 y1=14 y2=14></line> <line class=ql-stroke x1=12 x2=6 y1=4 y2=4></line> </svg>"; 11133 11134 /***/ }), 11135 /* 78 */ 11136 /***/ (function(module, exports) { 11137 11138 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=15 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=15 x2=5 y1=14 y2=14></line> <line class=ql-stroke x1=15 x2=9 y1=4 y2=4></line> </svg>"; 11139 11140 /***/ }), 11141 /* 79 */ 11142 /***/ (function(module, exports) { 11143 11144 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=15 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=15 x2=3 y1=14 y2=14></line> <line class=ql-stroke x1=15 x2=3 y1=4 y2=4></line> </svg>"; 11145 11146 /***/ }), 11147 /* 80 */ 11148 /***/ (function(module, exports) { 11149 11150 module.exports = "<svg viewbox=\"0 0 18 18\"> <g class=\"ql-fill ql-color-label\"> <polygon points=\"6 6.868 6 6 5 6 5 7 5.942 7 6 6.868\"></polygon> <rect height=1 width=1 x=4 y=4></rect> <polygon points=\"6.817 5 6 5 6 6 6.38 6 6.817 5\"></polygon> <rect height=1 width=1 x=2 y=6></rect> <rect height=1 width=1 x=3 y=5></rect> <rect height=1 width=1 x=4 y=7></rect> <polygon points=\"4 11.439 4 11 3 11 3 12 3.755 12 4 11.439\"></polygon> <rect height=1 width=1 x=2 y=12></rect> <rect height=1 width=1 x=2 y=9></rect> <rect height=1 width=1 x=2 y=15></rect> <polygon points=\"4.63 10 4 10 4 11 4.192 11 4.63 10\"></polygon> <rect height=1 width=1 x=3 y=8></rect> <path d=M10.832,4.2L11,4.582V4H10.708A1.948,1.948,0,0,1,10.832,4.2Z></path> <path d=M7,4.582L7.168,4.2A1.929,1.929,0,0,1,7.292,4H7V4.582Z></path> <path d=M8,13H7.683l-0.351.8a1.933,1.933,0,0,1-.124.2H8V13Z></path> <rect height=1 width=1 x=12 y=2></rect> <rect height=1 width=1 x=11 y=3></rect> <path d=M9,3H8V3.282A1.985,1.985,0,0,1,9,3Z></path> <rect height=1 width=1 x=2 y=3></rect> <rect height=1 width=1 x=6 y=2></rect> <rect height=1 width=1 x=3 y=2></rect> <rect height=1 width=1 x=5 y=3></rect> <rect height=1 width=1 x=9 y=2></rect> <rect height=1 width=1 x=15 y=14></rect> <polygon points=\"13.447 10.174 13.469 10.225 13.472 10.232 13.808 11 14 11 14 10 13.37 10 13.447 10.174\"></polygon> <rect height=1 width=1 x=13 y=7></rect> <rect height=1 width=1 x=15 y=5></rect> <rect height=1 width=1 x=14 y=6></rect> <rect height=1 width=1 x=15 y=8></rect> <rect height=1 width=1 x=14 y=9></rect> <path d=M3.775,14H3v1H4V14.314A1.97,1.97,0,0,1,3.775,14Z></path> <rect height=1 width=1 x=14 y=3></rect> <polygon points=\"12 6.868 12 6 11.62 6 12 6.868\"></polygon> <rect height=1 width=1 x=15 y=2></rect> <rect height=1 width=1 x=12 y=5></rect> <rect height=1 width=1 x=13 y=4></rect> <polygon points=\"12.933 9 13 9 13 8 12.495 8 12.933 9\"></polygon> <rect height=1 width=1 x=9 y=14></rect> <rect height=1 width=1 x=8 y=15></rect> <path d=M6,14.926V15H7V14.316A1.993,1.993,0,0,1,6,14.926Z></path> <rect height=1 width=1 x=5 y=15></rect> <path d=M10.668,13.8L10.317,13H10v1h0.792A1.947,1.947,0,0,1,10.668,13.8Z></path> <rect height=1 width=1 x=11 y=15></rect> <path d=M14.332,12.2a1.99,1.99,0,0,1,.166.8H15V12H14.245Z></path> <rect height=1 width=1 x=14 y=15></rect> <rect height=1 width=1 x=15 y=11></rect> </g> <polyline class=ql-stroke points=\"5.5 13 9 5 12.5 13\"></polyline> <line class=ql-stroke x1=11.63 x2=6.38 y1=11 y2=11></line> </svg>"; 11151 11152 /***/ }), 11153 /* 81 */ 11154 /***/ (function(module, exports) { 11155 11156 module.exports = "<svg viewbox=\"0 0 18 18\"> <rect class=\"ql-fill ql-stroke\" height=3 width=3 x=4 y=5></rect> <rect class=\"ql-fill ql-stroke\" height=3 width=3 x=11 y=5></rect> <path class=\"ql-even ql-fill ql-stroke\" d=M7,8c0,4.031-3,5-3,5></path> <path class=\"ql-even ql-fill ql-stroke\" d=M14,8c0,4.031-3,5-3,5></path> </svg>"; 11157 11158 /***/ }), 11159 /* 82 */
11160 /***/ (function(module, exports) { 11161 11162 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-stroke d=M5,4H9.5A2.5,2.5,0,0,1,12,6.5v0A2.5,2.5,0,0,1,9.5,9H5A0,0,0,0,1,5,9V4A0,0,0,0,1,5,4Z></path> <path class=ql-stroke d=M5,9h5.5A2.5,2.5,0,0,1,13,11.5v0A2.5,2.5,0,0,1,10.5,14H5a0,0,0,0,1,0,0V9A0,0,0,0,1,5,9Z></path> </svg>"; 11163 11164 /***/ }), 11165 /* 83 */ 11166 /***/ (function(module, exports) { 11167 11168 module.exports = "<svg class=\"\" viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=5 x2=13 y1=3 y2=3></line> <line class=ql-stroke x1=6 x2=9.35 y1=12 y2=3></line> <line class=ql-stroke x1=11 x2=15 y1=11 y2=15></line> <line class=ql-stroke x1=15 x2=11 y1=11 y2=15></line> <rect class=ql-fill height=1 rx=0.5 ry=0.5 width=7 x=2 y=14></rect> </svg>"; 11169 11170 /***/ }), 11171 /* 84 */ 11172 /***/ (function(module, exports) { 11173 11174 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=\"ql-color-label ql-stroke ql-transparent\" x1=3 x2=15 y1=15 y2=15></line> <polyline class=ql-stroke points=\"5.5 11 9 3 12.5 11\"></polyline> <line class=ql-stroke x1=11.63 x2=6.38 y1=9 y2=9></line> </svg>"; 11175 11176 /***/ }), 11177 /* 85 */ 11178 /***/ (function(module, exports) { 11179 11180 module.exports = "<svg viewbox=\"0 0 18 18\"> <polygon class=\"ql-stroke ql-fill\" points=\"3 11 5 9 3 7 3 11\"></polygon> <line class=\"ql-stroke ql-fill\" x1=15 x2=11 y1=4 y2=4></line> <path class=ql-fill d=M11,3a3,3,0,0,0,0,6h1V3H11Z></path> <rect class=ql-fill height=11 width=1 x=11 y=4></rect> <rect class=ql-fill height=11 width=1 x=13 y=4></rect> </svg>"; 11181 11182 /***/ }), 11183 /* 86 */ 11184 /***/ (function(module, exports) { 11185 11186 module.exports = "<svg viewbox=\"0 0 18 18\"> <polygon class=\"ql-stroke ql-fill\" points=\"15 12 13 10 15 8 15 12\"></polygon> <line class=\"ql-stroke ql-fill\" x1=9 x2=5 y1=4 y2=4></line> <path class=ql-fill d=M5,3A3,3,0,0,0,5,9H6V3H5Z></path> <rect class=ql-fill height=11 width=1 x=5 y=4></rect> <rect class=ql-fill height=11 width=1 x=7 y=4></rect> </svg>"; 11187 11188 /***/ }), 11189 /* 87 */ 11190 /***/ (function(module, exports) { 11191 11192 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M14,16H4a1,1,0,0,1,0-2H14A1,1,0,0,1,14,16Z /> <path class=ql-fill d=M14,4H4A1,1,0,0,1,4,2H14A1,1,0,0,1,14,4Z /> <rect class=ql-fill x=3 y=6 width=12 height=6 rx=1 ry=1 /> </svg>"; 11193 11194 /***/ }), 11195 /* 88 */ 11196 /***/ (function(module, exports) { 11197 11198 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M13,16H5a1,1,0,0,1,0-2h8A1,1,0,0,1,13,16Z /> <path class=ql-fill d=M13,4H5A1,1,0,0,1,5,2h8A1,1,0,0,1,13,4Z /> <rect class=ql-fill x=2 y=6 width=14 height=6 rx=1 ry=1 /> </svg>"; 11199 11200 /***/ }), 11201 /* 89 */ 11202 /***/ (function(module, exports) { 11203 11204 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M15,8H13a1,1,0,0,1,0-2h2A1,1,0,0,1,15,8Z /> <path class=ql-fill d=M15,12H13a1,1,0,0,1,0-2h2A1,1,0,0,1,15,12Z /> <path class=ql-fill d=M15,16H5a1,1,0,0,1,0-2H15A1,1,0,0,1,15,16Z /> <path class=ql-fill d=M15,4H5A1,1,0,0,1,5,2H15A1,1,0,0,1,15,4Z /> <rect class=ql-fill x=2 y=6 width=8 height=6 rx=1 ry=1 /> </svg>"; 11205 11206 /***/ }), 11207 /* 90 */ 11208 /***/ (function(module, exports) { 11209 11210 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M5,8H3A1,1,0,0,1,3,6H5A1,1,0,0,1,5,8Z /> <path class=ql-fill d=M5,12H3a1,1,0,0,1,0-2H5A1,1,0,0,1,5,12Z /> <path class=ql-fill d=M13,16H3a1,1,0,0,1,0-2H13A1,1,0,0,1,13,16Z /> <path class=ql-fill d=M13,4H3A1,1,0,0,1,3,2H13A1,1,0,0,1,13,4Z /> <rect class=ql-fill x=8 y=6 width=8 height=6 rx=1 ry=1 transform=\"translate(24 18) rotate(-180)\"/> </svg>"; 11211 11212 /***/ }), 11213 /* 91 */ 11214 /***/ (function(module, exports) { 11215 11216 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M11.759,2.482a2.561,2.561,0,0,0-3.53.607A7.656,7.656,0,0,0,6.8,6.2C6.109,9.188,5.275,14.677,4.15,14.927a1.545,1.545,0,0,0-1.3-.933A0.922,0.922,0,0,0,2,15.036S1.954,16,4.119,16s3.091-2.691,3.7-5.553c0.
11216177-.826.36-1.726,0.554-2.6L8.775,6.2c0.381-1.421.807-2.521,1.306-2.676a1.014,1.014,0,0,0,1.02.56A0.966,0.966,0,0,0,11.759,2.482Z></path> <rect class=ql-fill height=1.6 rx=0.8 ry=0.8 width=5 x=5.15 y=6.2></rect> <path class=ql-fill d=M13.663,12.027a1.662,1.662,0,0,1,.266-0.276q0.193,0.069.456,0.138a2.1,2.1,0,0,0,.535.069,1.075,1.075,0,0,0,.767-0.3,1.044,1.044,0,0,0,.314-0.8,0.84,0.84,0,0,0-.238-0.619,0.8,0.8,0,0,0-.594-0.239,1.154,1.154,0,0,0-.781.3,4.607,4.607,0,0,0-.781,1q-0.091.15-.218,0.346l-0.246.38c-0.068-.288-0.137-0.582-0.212-0.885-0.459-1.847-2.494-.984-2.941-0.8-0.482.2-.353,0.647-0.094,0.529a0.869,0.869,0,0,1,1.281.585c0.217,0.751.377,1.436,0.527,2.038a5.688,5.688,0,0,1-.362.467,2.69,2.69,0,0,1-.264.271q-0.221-.08-0.471-0.147a2.029,2.029,0,0,0-.522-0.066,1.079,1.079,0,0,0-.768.3A1.058,1.058,0,0,0,9,15.131a0.82,0.82,0,0,0,.832.852,1.134,1.134,0,0,0,.787-0.3,5.11,5.11,0,0,0,.776-0.993q0.141-.219.215-0.34c0.046-.076.122-0.194,0.223-0.346a2.786,2.786,0,0,0,.918,1.726,2.582,2.582,0,0,0,2.376-.185c0.317-.181.212-0.565,0-0.494A0.807,0.807,0,0,1,14.176,15a5.159,5.159,0,0,1-.913-2.446l0,0Q13.487,12.24,13.663,12.027Z></path> </svg>"; 11217 11218 /***/ }), 11219 /* 92 */ 11220 /***/ (function(module, exports) { 11221 11222 module.exports = "<svg viewBox=\"0 0 18 18\"> <path class=ql-fill d=M10,4V14a1,1,0,0,1-2,0V10H3v4a1,1,0,0,1-2,0V4A1,1,0,0,1,3,4V8H8V4a1,1,0,0,1,2,0Zm6.06787,9.209H14.98975V7.59863a.54085.54085,0,0,0-.605-.60547h-.62744a1.01119,1.01119,0,0,0-.748.29688L11.645,8.56641a.5435.5435,0,0,0-.022.8584l.28613.30762a.53861.53861,0,0,0,.84717.0332l.09912-.08789a1.2137,1.2137,0,0,0,.2417-.35254h.02246s-.01123.30859-.01123.60547V13.209H12.041a.54085.54085,0,0,0-.605.60547v.43945a.54085.54085,0,0,0,.605.60547h4.02686a.54085.54085,0,0,0,.605-.60547v-.43945A.54085.54085,0,0,0,16.06787,13.209Z /> </svg>"; 11223 11224 /***/ }), 11225 /* 93 */ 11226 /***/ (function(module, exports) { 11227 11228 module.exports = "<svg viewBox=\"0 0 18 18\"> <path class=ql-fill d=M16.73975,13.81445v.43945a.54085.54085,0,0,1-.605.60547H11.855a.58392.58392,0,0,1-.64893-.60547V14.0127c0-2.90527,3.39941-3.42187,3.39941-4.55469a.77675.77675,0,0,0-.84717-.78125,1.17684,1.17684,0,0,0-.83594.38477c-.2749.26367-.561.374-.85791.13184l-.4292-.34082c-.30811-.24219-.38525-.51758-.1543-.81445a2.97155,2.97155,0,0,1,2.45361-1.17676,2.45393,2.45393,0,0,1,2.68408,2.40918c0,2.45312-3.1792,2.92676-3.27832,3.93848h2.79443A.54085.54085,0,0,1,16.73975,13.81445ZM9,3A.99974.99974,0,0,0,8,4V8H3V4A1,1,0,0,0,1,4V14a1,1,0,0,0,2,0V10H8v4a1,1,0,0,0,2,0V4A.99974.99974,0,0,0,9,3Z /> </svg>"; 11229 11230 /***/ }), 11231 /* 94 */ 11232 /***/ (function(module, exports) { 11233 11234 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=7 x2=13 y1=4 y2=4></line> <line class=ql-stroke x1=5 x2=11 y1=14 y2=14></line> <line class=ql-stroke x1=8 x2=10 y1=14 y2=4></line> </svg>"; 11235 11236 /***/ }), 11237 /* 95 */ 11238 /***/ (function(module, exports) { 11239 11240 module.exports = "<svg viewbox=\"0 0 18 18\"> <rect class=ql-stroke height=10 width=12 x=3 y=4></rect> <circle class=ql-fill cx=6 cy=7 r=1></circle> <polyline class=\"ql-even ql-fill\" points=\"5 12 5 11 7 9 8 10 11 7 13 9 13 12 5 12\"></polyline> </svg>"; 11241 11242 /***/ }), 11243 /* 96 */ 11244 /***/ (function(module, exports) { 11245 11246 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=3 x2=15 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=9 x2=15 y1=9 y2=9></line> <polyline class=\"ql-fill ql-stroke\" points=\"3 7 3 11 5 9 3 7\"></polyline> </svg>"; 11247 11248 /***/ }), 11249 /* 97 */ 11250 /***/ (function(module, exports) { 11251 11252 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=3 x2=15 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=9 x2=15 y1=9 y2=9></line> <polyline class=ql-stroke points=\"5 7 5 11 3 9 5 7\"></polyline> </svg>"; 11253 11254 /***/ }), 11255 /* 98 */
11256 /***/ (function(module, exports) { 11257 11258 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=7 x2=11 y1=7 y2=11></line> <path class=\"ql-even ql-stroke\" d=M8.9,4.577a3.476,3.476,0,0,1,.36,4.679A3.476,3.476,0,0,1,4.577,8.9C3.185,7.5,2.035,6.4,4.217,4.217S7.5,3.185,8.9,4.577Z></path> <path class=\"ql-even ql-stroke\" d=M13.423,9.1a3.476,3.476,0,0,0-4.679-.36,3.476,3.476,0,0,0,.36,4.679c1.392,1.392,2.5,2.542,4.679.36S14.815,10.5,13.423,9.1Z></path> </svg>"; 11259 11260 /***/ }), 11261 /* 99 */ 11262 /***/ (function(module, exports) { 11263 11264 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=7 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=7 x2=15 y1=9 y2=9></line> <line class=ql-stroke x1=7 x2=15 y1=14 y2=14></line> <line class=\"ql-stroke ql-thin\" x1=2.5 x2=4.5 y1=5.5 y2=5.5></line> <path class=ql-fill d=M3.5,6A0.5,0.5,0,0,1,3,5.5V3.085l-0.276.138A0.5,0.5,0,0,1,2.053,3c-0.124-.247-0.023-0.324.224-0.447l1-.5A0.5,0.5,0,0,1,4,2.5v3A0.5,0.5,0,0,1,3.5,6Z></path> <path class=\"ql-stroke ql-thin\" d=M4.5,10.5h-2c0-.234,1.85-1.076,1.85-2.234A0.959,0.959,0,0,0,2.5,8.156></path> <path class=\"ql-stroke ql-thin\" d=M2.5,14.846a0.959,0.959,0,0,0,1.85-.109A0.7,0.7,0,0,0,3.75,14a0.688,0.688,0,0,0,.6-0.736,0.959,0.959,0,0,0-1.85-.109></path> </svg>"; 11265 11266 /***/ }), 11267 /* 100 */ 11268 /***/ (function(module, exports) { 11269 11270 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=6 x2=15 y1=4 y2=4></line> <line class=ql-stroke x1=6 x2=15 y1=9 y2=9></line> <line class=ql-stroke x1=6 x2=15 y1=14 y2=14></line> <line class=ql-stroke x1=3 x2=3 y1=4 y2=4></line> <line class=ql-stroke x1=3 x2=3 y1=9 y2=9></line> <line class=ql-stroke x1=3 x2=3 y1=14 y2=14></line> </svg>"; 11271 11272 /***/ }), 11273 /* 101 */ 11274 /***/ (function(module, exports) { 11275 11276 module.exports = "<svg class=\"\" viewbox=\"0 0 18 18\"> <line class=ql-stroke x1=9 x2=15 y1=4 y2=4></line> <polyline class=ql-stroke points=\"3 4 4 5 6 3\"></polyline> <line class=ql-stroke x1=9 x2=15 y1=14 y2=14></line> <polyline class=ql-stroke points=\"3 14 4 15 6 13\"></polyline> <line class=ql-stroke x1=9 x2=15 y1=9 y2=9></line> <polyline class=ql-stroke points=\"3 9 4 10 6 8\"></polyline> </svg>"; 11277 11278 /***/ }), 11279 /* 102 */ 11280 /***/ (function(module, exports) { 11281 11282 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M15.5,15H13.861a3.858,3.858,0,0,0,1.914-2.975,1.8,1.8,0,0,0-1.6-1.751A1.921,1.921,0,0,0,12.021,11.7a0.50013,0.50013,0,1,0,.957.291h0a0.914,0.914,0,0,1,1.053-.725,0.81,0.81,0,0,1,.744.762c0,1.076-1.16971,1.86982-1.93971,2.43082A1.45639,1.45639,0,0,0,12,15.5a0.5,0.5,0,0,0,.5.5h3A0.5,0.5,0,0,0,15.5,15Z /> <path class=ql-fill d=M9.65,5.241a1,1,0,0,0-1.409.108L6,7.964,3.759,5.349A1,1,0,0,0,2.192,6.59178Q2.21541,6.6213,2.241,6.649L4.684,9.5,2.241,12.35A1,1,0,0,0,3.71,13.70722q0.02557-.02768.049-0.05722L6,11.036,8.241,13.65a1,1,0,1,0,1.567-1.24277Q9.78459,12.3777,9.759,12.35L7.316,9.5,9.759,6.651A1,1,0,0,0,9.65,5.241Z /> </svg>"; 11283 11284 /***/ }), 11285 /* 103 */ 11286 /***/ (function(module, exports) { 11287 11288 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-fill d=M15.5,7H13.861a4.015,4.015,0,0,0,1.914-2.975,1.8,1.8,0,0,0-1.6-1.751A1.922,1.922,0,0,0,12.021,3.7a0.5,0.5,0,1,0,.957.291,0.917,0.917,0,0,1,1.053-.725,0.81,0.81,0,0,1,.744.762c0,1.077-1.164,1.925-1.934,2.486A1.423,1.423,0,0,0,12,7.5a0.5,0.5,0,0,0,.5.5h3A0.5,0.5,0,0,0,15.5,7Z /> <path class=ql-fill d=M9.651,5.241a1,1,0,0,0-1.41.108L6,7.964,3.759,5.349a1,1,0,1,0-1.519,1.3L4.683,9.5,2.241,12.35a1,1,0,1,0,1.519,1.3L6,11.036,8.241,13.65a1,1,0,0,0,1.519-1.3L7.317,9.5,9.759,6.651A1,1,0,0,0,9.651,5.241Z /> </svg>"; 11289 11290 /***/ }), 11291 /* 104 */ 11292 /***/ (function(module, exports) { 11293 11294 module.exports = "<svg viewbox=\"0 0 18 18\"> <line class=\"ql-stroke ql-thin\" x1=15.5 x2=2.5 y1=8.5 y2=9.5></line> <path class=ql-fill d=M9.007,8C6.542,7.791,6,7.519,6,6.5,6,5.792,7.283,5,9,5c1.571,0,2.765.679,2.969,1.309a1,1,0,0,0,1.9-.617C13.356,4.106,11.354,3,9,3,6.2,3,4,4.538,4,6.5a3.2,3.2,0,0,0,.5,1.843Z></path> <path class=ql-fill d=M8.984,10C11.457,10.208,12,10.479,12,11.5c0,0.708-1.283,1.5-3,1.5-1.571,0-2.765-.679-2.969-1.309a1,1,0,1,0-1.9.617C4.644,13.894,6.646,15,9,15c2.8,0,5-1.538,5-3.5a3.2,3.2,0,0,0-.5-1.843Z></path> </svg>"; 11295 11296 /***/ }), 11297 /* 105 */
vendor: 11,580 bytes, lines 11298-11489
11298 /***/ (function(module, exports) { 11299 11300 module.exports = "<svg viewbox=\"0 0 18 18\"> <path class=ql-stroke d=M5,3V9a4.012,4.012,0,0,0,4,4H9a4.012,4.012,0,0,0,4-4V3></path> <rect class=ql-fill height=1 rx=0.5 ry=0.5 width=12 x=3 y=15></rect> </svg>"; 11301 11302 /***/ }), 11303 /* 106 */ 11304 /***/ (function(module, exports) { 11305 11306 module.exports = "<svg viewbox=\"0 0 18 18\"> <rect class=ql-stroke height=12 width=12 x=3 y=3></rect> <rect class=ql-fill height=12 width=1 x=5 y=3></rect> <rect class=ql-fill height=12 width=1 x=12 y=3></rect> <rect class=ql-fill height=2 width=8 x=5 y=8></rect> <rect class=ql-fill height=1 width=3 x=3 y=5></rect> <rect class=ql-fill height=1 width=3 x=3 y=7></rect> <rect class=ql-fill height=1 width=3 x=3 y=10></rect> <rect class=ql-fill height=1 width=3 x=3 y=12></rect> <rect class=ql-fill height=1 width=3 x=12 y=5></rect> <rect class=ql-fill height=1 width=3 x=12 y=7></rect> <rect class=ql-fill height=1 width=3 x=12 y=10></rect> <rect class=ql-fill height=1 width=3 x=12 y=12></rect> </svg>"; 11307 11308 /***/ }), 11309 /* 107 */ 11310 /***/ (function(module, exports) { 11311 11312 module.exports = "<svg viewbox=\"0 0 18 18\"> <polygon class=ql-stroke points=\"7 11 9 13 11 11 7 11\"></polygon> <polygon class=ql-stroke points=\"7 7 9 5 11 7 7 7\"></polygon> </svg>"; 11313 11314 /***/ }), 11315 /* 108 */ 11316 /***/ (function(module, exports, __webpack_require__) { 11317 11318 "use strict"; 11319 11320 11321 Object.defineProperty(exports, "__esModule", { 11322 value: true 11323 }); 11324 exports.default = exports.BubbleTooltip = undefined; 11325 11326 var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; 11327 11328 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); 11329 11330 var _extend = __webpack_require__(3); 11331 11332 var _extend2 = _interopRequireDefault(_extend); 11333 11334 var _emitter = __webpack_require__(8); 11335 11336 var _emitter2 = _interopRequireDefault(_emitter); 11337 11338 var _base = __webpack_require__(43); 11339 11340 var _base2 = _interopRequireDefault(_base); 11341 11342 var _selection = __webpack_require__(15); 11343 11344 var _icons = __webpack_require__(41); 11345 11346 var _icons2 = _interopRequireDefault(_icons); 11347 11348 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 11349 11350 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 11351 11352 function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } 11353 11354 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } 11355 11356 var TOOLBAR_CONFIG = [['bold', 'italic', 'link'], [{ header: 1 }, { header: 2 }, 'blockquote']]; 11357 11358 var BubbleTheme = function (_BaseTheme) { 11359 _inherits(BubbleTheme, _BaseTheme); 11360 11361 function BubbleTheme(quill, options) { 11362 _classCallCheck(this, BubbleTheme); 11363 11364 if (options.modules.toolbar != null && options.modules.toolbar.container == null) { 11365 options.modules.toolbar.container = TOOLBAR_CONFIG; 11366 } 11367 11368 var _this = _possibleConstructorReturn(this, (BubbleTheme.__proto__ || Object.getPrototypeOf(BubbleTheme)).call(this, quill, options)); 11369 11370 _this.quill.container.classList.add('ql-bubble'); 11371 return _this; 11372 } 11373 11374 _createClass(BubbleTheme, [{ 11375 key: 'extendToolbar', 11376 value: function extendToolbar(toolbar) { 11377 this.tooltip = new BubbleTooltip(this.quill, this.options.bounds); 11378 this.tooltip.root.appendChild(toolbar.container); 11379 this.buildButtons([].slice.call(toolbar.container.querySelectorAll('button')), _icons2.default); 11380 this.buildPickers([].slice.call(toolbar.container.querySelectorAll('select')), _icons2.default); 11381 } 11382 }]); 11383 11384 return BubbleTheme; 11385 }(_base2.default); 11386 11387 BubbleTheme.DEFAULTS = (0, _extend2.default)(true, {}, _base2.default.DEFAULTS, { 11388 modules: { 11389 toolbar: { 11390 handlers: { 11391 link: function link(value) { 11392 if (!value) { 11393 this.quill.format('link', false); 11394 } else { 11395 this.quill.theme.tooltip.edit(); 11396 } 11397 } 11398 } 11399 } 11400 } 11401 }); 11402 11403 var BubbleTooltip = function (_BaseTooltip) { 11404 _inherits(BubbleTooltip, _BaseTooltip); 11405 11406 function BubbleTooltip(quill, bounds) { 11407 _classCallCheck(this, BubbleTooltip); 11408 11409 var _this2 = _possibleConstructorReturn(this, (BubbleTooltip.__proto__ || Object.getPrototypeOf(BubbleTooltip)).call(this, quill, bounds)); 11410 11411 _this2.quill.on(_emitter2.default.events.EDITOR_CHANGE, function (type, range, oldRange, source) { 11412 if (type !== _emitter2.default.events.SELECTION_CHANGE) return; 11413 if (range != null && range.length > 0 && source === _emitter2.default.sources.USER) { 11414 _this2.show(); 11415 // Lock our width so we will expand beyond our offsetParent boundaries 11416 _this2.root.style.left = '0px'; 11417 _this2.root.style.width = ''; 11418 _this2.root.style.width = _this2.root.offsetWidth + 'px'; 11419 var lines = _this2.quill.getLines(range.index, range.length); 11420 if (lines.length === 1) { 11421 _this2.position(_this2.quill.getBounds(range)); 11422 } else { 11423 var lastLine = lines[lines.length - 1]; 11424 var index = _this2.quill.getIndex(lastLine); 11425 var length = Math.min(lastLine.length() - 1, range.index + range.length - index); 11426 var _bounds = _this2.quill.getBounds(new _selection.Range(index, length)); 11427 _this2.position(_bounds); 11428 } 11429 } else if (document.activeElement !== _this2.textbox && _this2.quill.hasFocus()) { 11430 _this2.hide(); 11431 } 11432 }); 11433 return _this2; 11434 } 11435 11436 _createClass(BubbleTooltip, [{ 11437 key: 'listen', 11438 value: function listen() { 11439 var _this3 = this; 11440 11441 _get(BubbleTooltip.prototype.__proto__ || Object.getPrototypeOf(BubbleTooltip.prototype), 'listen', this).call(this); 11442 this.root.querySelector('.ql-close').addEventListener('click', function () { 11443 _this3.root.classList.remove('ql-editing'); 11444 }); 11445 this.quill.on(_emitter2.default.events.SCROLL_OPTIMIZE, function () { 11446 // Let selection be restored by toolbar handlers before repositioning 11447 setTimeout(function () { 11448 if (_this3.root.classList.contains('ql-hidden')) return; 11449 var range = _this3.quill.getSelection(); 11450 if (range != null) { 11451 _this3.position(_this3.quill.getBounds(range)); 11452 } 11453 }, 1); 11454 }); 11455 } 11456 }, { 11457 key: 'cancel', 11458 value: function cancel() { 11459 this.show(); 11460 } 11461 }, { 11462 key: 'position', 11463 value: function position(reference) { 11464 var shift = _get(BubbleTooltip.prototype.__proto__ || Object.getPrototypeOf(BubbleTooltip.prototype), 'position', this).call(this, reference); 11465 var arrow = this.root.querySelector('.ql-tooltip-arrow'); 11466 arrow.style.marginLeft = ''; 11467 if (shift === 0) return shift; 11468 arrow.style.marginLeft = -1 * shift - arrow.offsetWidth / 2 + 'px'; 11469 } 11470 }]); 11471 11472 return BubbleTooltip; 11473 }(_base.BaseTooltip); 11474 11475 BubbleTooltip.TEMPLATE = ['<span class="ql-tooltip-arrow"></span>', '<div class="ql-tooltip-editor">', '<input type="text" data-formula="e=mc^2" data-link="https://quilljs.com" data-video="Embed URL">', '<a class="ql-close"></a>', '</div>'].join(''); 11476 11477 exports.BubbleTooltip = BubbleTooltip; 11478 exports.default = BubbleTheme; 11479 11480 /***/ }), 11481 /* 109 */ 11482 /***/ (function(module, exports, __webpack_require__) { 11483 11484 module.exports = __webpack_require__(63); 11485 11486 11487 /***/ }) 11488 /******/ ])["default"]; 11489});
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.