PluginProbe
VikBooking Hotel Booking Engine & PMS / 1.6.5
VikBooking Hotel Booking Engine & PMS v1.6.5
1.8.16 1.8.15 1.8.14 1.8.13 1.8.12 1.8.11 1.8.10 1.8.9 1.8.6 1.8.7 1.8.8 trunk 1.6.0 1.6.1 1.6.2 1.6.3 1.6.4 1.6.5 1.6.6 1.6.7 1.6.8 1.6.9 1.7.0 1.7.1 1.7.2 All 37 releases
vikbooking / admin / resources / quill / quill.js

quill.js in VikBooking Hotel Booking Engine & PMS 1.6.5, at admin/resources/quill/quill.js

11,489 lines 427.0 KB
No matching file
Up and down to move Enter to open Esc to close
Raw Download Zip
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, domNode);
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 () {
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, { constructor: { 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)).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, { constructor: { 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;
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) {
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>&nbsp;</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) {
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.BackgroundClass,
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,
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, { constructor: { 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, { constructor: { 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.177-.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 */
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 });