Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 | 1x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 2682x 1859x 823x 823x 2682x 2682x 2682x 2682x 1667x 1667x 2682x 2682x 1x 1x 342x 342x 342x 296x 46x 20x 26x 46x 46x 46x 207x 207x 225x 207x 207x 5x 5x 5x 5x 202x 207x 1x 3x 3x 3x 2x 3x 1x 10252x 931x 10252x 1x 509x 1x 755x 1x 4193x 1x 39x 1x 1330x 1330x 1330x 1330x 1330x 1330x 1330x 1330x 40227x 14247x 5417x 5417x 5417x 5417x 14247x 25980x 5413x 5413x 5413x 5413x 25980x 13347x 13347x 13347x 12635x 12635x 12635x 12635x 712x 1x 711x 12633x 2x 12631x 12631x 12631x 12631x 12631x 12631x 1327x 4x 1327x 1327x 1x 1326x 1326x 1326x 1x 54x 1x 229x 229x 1x 451x 451x 225x 2104x 1x 147082x 1x 1313x 1x 1312x 1312x 1312x 1301x 1301x 1x 4048x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1708x 1x 857x 1x 8837x 1x 6651x 1x 706x 1x 16x 16x 1x 34x 34x 34x 34x 34x 1x 1x 33x 33x 33x 33x 33x 33x 33x 33x 2x 33x 33x 1x 1x 33x 2x 2x 31x 22x 9x 9x 9x 9x 21x 21x 21x 9x 12x 9x 6x 9x 9x 9x 6x 3x 9x 85x 33x 31x 31x 43x 20x 20x 31x 20x 20x 22x 22x 22x 22x 16x 22x 22x 31x 31x 31x 33x 34x 34x 1x 234x 234x 234x 9x 234x 1x 536x 536x 536x 536x 63x 536x 1x 1888x 1888x 1888x 1888x 56036x 48827x 7209x 7209x 7209x 7209x 7209x 7209x 7209x 3582x 7209x 1888x 56045x 56045x 55x 55x 55990x 4073x 3986x 3986x 3986x 46x 46x 46x 44x 46x 46x 46x 9x 9x 46x 46x 46x 87x 6x 6x 2x 55990x 55990x 44x 46x 46x 46x 1888x 1x 16x 16x 1x 109x 109x 16x 16x 10x 16x 93x 93x 25x 68x 68x 68x 2x 66x 68x 31x 25x 31x 17x 14x 37x 1x 79x 79x 19x 19x 8x 11x 71x 71x 71x 25x 46x 71x 71x 40x 31x 1x 71x 167x 46x 121x 14x 14x 107x 11x 11x 71x 25x 46x 1x 108x 1x 3056x 594x 594x 594x 594x 594x 2462x 2462x 2223x 239x 239x 239x 239x 1x 4633x 4633x 2630x 4633x 1x 557x 557x 557x 1x 2507x 2507x 2507x 3x 2507x 1x 9x 9x 1x 9x 9x 9x 9x 9x 9x 9x 9x 1x 3156x 21131x 21131x 21131x 21131x 1058x 1058x 283x 3156x 21118x 21118x 21118x 3156x 6312x 4599x 3842x 4599x 3156x 3156x 1x 10x 10x 10x 10x 10x 10x 1x 785x 785x 785x 785x 785x 785x 785x 1908x 780x 398x 53x 345x 398x 382x 336x 46x 46x 46x 46x 1x 45x 45x 1907x 23x 23x 23x 23x 23x 23x 23x 785x 785x 785x 785x 785x 1864x 224x 1864x 1498x 1498x 1498x 1498x 1498x 11x 11x 11x 11x 1498x 1509x 1509x 1509x 11x 11x 11x 1498x 1498x 1501x 1501x 3x 1498x 1518x 1518x 1518x 1518x 26x 6x 6x 3x 6x 20x 1492x 23x 22x 1x 23x 1492x 22x 21x 1x 22x 1492x 1492x 1128x 1128x 11x 364x 366x 365x 778x 11x 767x 530x 767x 16x 16x 767x 12x 12x 767x 1x 1x 39x 39x 39x 39x 39x 19x 60x 60x 57x 57x 8x 8x 49x 3x 3x 49x 2x 2x 47x 47x 13x 20x 20x 11x 9x 20x 20x 1235x 1235x 181x 181x 25x 25x 25x 39x 2x 2x 39x 1x 4201x 1x 184x 1x 115x 115x 115x 1x 921x 1x 948x 1x 35x 32x 32x 3x 1x 1347x 32x 1315x | /*!
* VisualEditor DataModel Document class.
*
* @copyright See AUTHORS.txt
*/
/**
* DataModel document.
*
* WARNING: The data parameter is passed by reference. Do not modify a data array after passing
* it to this constructor, and do not construct multiple Documents with the same data array. If you
* need to do these things, make a deep copy (ve.copy) of the data array and operate on the
* copy.
*
* @class
* @extends ve.Document
* @constructor
* @param {Array|ve.dm.ElementLinearData} data Raw linear model data or ElementLinearData
* @param {HTMLDocument} [htmlDocument] HTML document the data was converted from, if any.
* If omitted, a new document will be created. If data is an HTMLDocument, this parameter is
* ignored.
* @param {ve.dm.Document} [parentDocument] Document to use as root for created nodes, used when cloning
* @param {ve.dm.InternalList} [internalList] Internal list to clone; passed when creating a document slice
* @param {Array.<string|undefined>} [innerWhitespace] Inner whitespace to clone; passed when creating a document slice
* @param {string} [lang] Language code
* @param {string} [dir='ltr'] Directionality (ltr/rtl)
* @param {ve.dm.Document} [originalDocument] Original document form which this was cloned.
* @param {boolean} [sourceMode] Document is in source mode
* @param {Object} [persistentStorage] Persistent storage object
*/
ve.dm.Document = function VeDmDocument( data, htmlDocument, parentDocument, internalList, innerWhitespace, lang, dir, originalDocument, sourceMode, persistentStorage ) {
// Parent constructor
ve.dm.Document.super.call( this, new ve.dm.DocumentNode() );
// Initialization
const doc = parentDocument || this;
const root = this.documentNode;
this.lang = lang || 'en';
this.dir = dir || 'ltr';
this.sourceMode = !!sourceMode;
this.documentNode.setRoot( root );
// ve.Document already called setDocument(), but it could be that doc !== this
// so call it again
this.documentNode.setDocument( doc );
this.internalList = internalList ? internalList.clone( this ) : new ve.dm.InternalList( this );
this.innerWhitespace = innerWhitespace ? ve.copy( innerWhitespace ) : new Array( 2 );
this.metaList = new ve.dm.MetaList( this );
// Properties
this.parentDocument = parentDocument || null;
this.originalDocument = originalDocument || null;
this.nodesByType = {};
this.origInternalListLength = null;
this.readOnly = false;
this.attachedRoot = this.documentNode;
// Sparse array
this.branchNodeFromOffsetCache = [];
if ( data instanceof ve.dm.ElementLinearData ) {
this.data = data;
} else Iif ( data instanceof ve.dm.FlatLinearData ) {
this.data = new ve.dm.ElementLinearData( data.getStore(), data.getData() );
} else {
this.data = new ve.dm.ElementLinearData(
new ve.dm.HashValueStore(),
Array.isArray( data ) ? data : []
);
}
this.store = this.data.getStore();
this.completeHistory = new ve.dm.Change();
// Use the store by reference inside the completeHistory
this.completeHistory.store = this.store;
if ( this.store.getLength() > 0 ) {
// Push an identity transaction and the initial store
this.completeHistory.transactions.push( new ve.dm.Transaction( [ {
type: 'retain',
length: this.data.data.length
} ] ) );
this.completeHistory.storeLengthAtTransaction.push( this.store.getLength() );
}
this.htmlDocument = htmlDocument || ve.createDocumentFromHtml( '' );
this.persistentStorage = persistentStorage || {};
};
/* Inheritance */
OO.inheritClass( ve.dm.Document, ve.Document );
/* Events */
/**
* Emitted when a transaction is about to be committed.
*
* @event ve.dm.Document#precommit
* @param {ve.dm.Transaction} tx Transaction that is about to be committed
*/
/**
* Emitted when a transaction has been committed.
*
* @event ve.dm.Document#transact
* @param {ve.dm.Transaction} tx Transaction that was just processed
*/
/**
* A value in persistent storage has changed
*
* @event ve.dm.Document#storage
*/
/* Static methods */
/**
* Apply annotations to content data.
*
* This method modifies data in place.
*
* @static
* @param {ve.dm.ElementLinearData|Array} data Data to apply annotations to
* @param {ve.dm.AnnotationSet} annotationSet Annotations to apply
* @param {boolean} [replaceComparable] Whether to remove annotations from the data which are comparable to those in annotationSet
* @param {ve.dm.HashValueStore} [store] Store associated with the data; only needs to be provided if that data is associated with a different store than annotationSet
* @param {boolean} [prepend] Whether to prepend annotationSet to the existing annotations
*/
ve.dm.Document.static.addAnnotationsToData = function ( data, annotationSet, replaceComparable, store, prepend ) {
const offset = prepend ? 0 : undefined;
let ignoreChildrenDepth = 0;
if ( annotationSet.isEmpty() ) {
// Nothing to do
return;
}
if ( store ) {
store.merge( annotationSet.getStore() );
} else {
store = annotationSet.getStore();
}
Eif ( !( data instanceof ve.dm.ElementLinearData ) ) {
data = new ve.dm.ElementLinearData( store, data );
}
// Apply annotations to data
for ( let i = 0, length = data.getLength(); i < length; i++ ) {
Iif ( data.isElementData( i ) && ve.dm.nodeFactory.shouldIgnoreChildren( data.getType( i ) ) ) {
ignoreChildrenDepth += data.isOpenElementData( i ) ? 1 : -1;
}
Iif ( ignoreChildrenDepth ) {
continue;
}
const allowedAnnotations = annotationSet.filter( ( ann ) => data.canTakeAnnotationAtOffset( i, ann, true ) );
const existingAnnotations = data.getAnnotationsFromOffset( i, true );
let newAnnotationSet;
if ( !existingAnnotations.isEmpty() ) {
newAnnotationSet = existingAnnotations;
Eif ( replaceComparable ) {
newAnnotationSet = newAnnotationSet.withoutComparableSet( allowedAnnotations );
}
newAnnotationSet.addSet( allowedAnnotations, offset );
} else {
newAnnotationSet = allowedAnnotations;
}
data.setAnnotationsAtOffset( i, newAnnotationSet );
}
};
/**
* Provide a new, empty Document.
*
* @param {string} [paragraphType='empty'] Paragraph type: 'empty', 'wrapper' or null for a regular paragraph
* @return {ve.dm.Document}
*/
ve.dm.Document.static.newBlankDocument = function ( paragraphType ) {
const paragraph = { type: 'paragraph' };
paragraphType = paragraphType === undefined ? 'empty' : paragraphType;
if ( paragraphType ) {
ve.setProp( paragraph, 'internal', 'generated', paragraphType );
}
return new ve.dm.Document( [
paragraph,
{ type: '/paragraph' },
{ type: 'internalList' },
{ type: '/internalList' }
] );
};
/* Methods */
/**
* @inheritdoc
*/
ve.dm.Document.prototype.getDocumentNode = function () {
if ( !this.documentNode.length && !this.documentNode.getDocument().buildingNodeTree ) {
this.buildNodeTree();
}
return this.documentNode;
};
/**
* Set the attached root node
*
* @param {ve.dm.BranchNode} attachedRoot Attached root
*/
ve.dm.Document.prototype.setAttachedRoot = function ( attachedRoot ) {
this.attachedRoot = attachedRoot;
};
/**
* Get the attached root node
*
* @return {ve.dm.BranchNode} Attached root
*/
ve.dm.Document.prototype.getAttachedRoot = function () {
return this.attachedRoot;
};
/**
* Get a range that spans the entire document (excluding the internal list)
*
* @return {ve.Range} Document range
*/
ve.dm.Document.prototype.getDocumentRange = function () {
return new ve.Range( 0, this.getInternalList().getListNode().getOuterRange().start );
};
/**
* Get a range that spans the attached root (excluding the internal list)
*
* @return {ve.Range} Attached root's range
*/
ve.dm.Document.prototype.getAttachedRootRange = function () {
return this.attachedRoot === this.documentNode ? this.getDocumentRange() : this.attachedRoot.getRange();
};
/**
* Build the node tree.
*/
ve.dm.Document.prototype.buildNodeTree = function () {
let textLength = 0,
inTextNode = false;
// Build a tree of nodes and nodes that will be added to them after a full scan is complete,
// then from the bottom up add nodes to their potential parents. This avoids massive length
// updates being broadcast upstream constantly while building is underway.
let currentStack = [];
let parentStack = [ this.documentNode ];
// Stack of stacks
const nodeStack = [ parentStack, currentStack ];
let currentNode = this.documentNode;
const doc = this.documentNode.getDocument();
for ( let i = 0, len = this.data.getLength(); i < len; i++ ) {
if ( !this.data.isElementData( i ) ) {
// Text node opening
if ( !inTextNode ) {
// Create a lengthless text node
const node = new ve.dm.TextNode();
// Put the node on the current inner stack
currentStack.push( node );
currentNode = node;
// Set a flag saying we're inside a text node
inTextNode = true;
}
// Track the length
textLength++;
} else {
// Text node closing
if ( inTextNode ) {
// Finish the text node by setting the length
currentNode.setLength( textLength );
// Put the state variables back as they were
currentNode = parentStack[ parentStack.length - 1 ];
inTextNode = false;
textLength = 0;
}
// Element open/close
if ( this.data.isOpenElementData( i ) ) {
// Branch or leaf node opening
// Create a childless node
const node = ve.dm.nodeFactory.createFromElement( this.data.getData( i ) );
// Put the childless node on the current inner stack
currentStack.push( node );
if ( ve.dm.nodeFactory.canNodeHaveChildren( node.getType() ) ) {
// Create a new inner stack for this node
parentStack = currentStack;
currentStack = [];
nodeStack.push( currentStack );
currentNode = node;
} else {
// Assert that the next element is a closing element for this node,
// and skip over it.
if (
!this.data.isCloseElementData( i + 1 ) ||
this.data.getType( i + 1 ) !== this.data.getType( i )
) {
throw new Error( 'Opening element for node that cannot have children must be followed by closing element' );
}
i++;
}
} else {
// Branch or leaf node closing
if ( this.data.getType( i ) !== currentNode.getType() ) {
throw new Error( 'Expected closing for ' + currentNode.getType() +
' but got closing for ' + this.data.getType( i ) );
}
// Pop this node's inner stack from the outer stack. It'll have all of the
// node's child nodes fully constructed
const children = nodeStack.pop();
currentStack = parentStack;
parentStack = nodeStack[ nodeStack.length - 2 ];
Iif ( !parentStack ) {
// This can only happen if we got unbalanced data
throw new Error( 'Unbalanced input passed to document' );
}
// Attach the children to the node
ve.batchSplice( currentNode, 0, 0, children );
currentNode = parentStack[ parentStack.length - 1 ];
}
}
}
if ( inTextNode ) {
// Text node ended by end-of-input rather than by an element
currentNode.setLength( textLength );
// Don't bother updating currentNode et al, we don't use them below
}
// State variable that allows nodes to know that they are being
// appended in order. Used by ve.dm.InternalList.
doc.buildingNodeTree = true;
// The end state is nodeStack = [ [this.documentNode], [ array, of, its, children ] ]
// so attach all nodes in currentStack to the root node
if ( nodeStack.length > 2 ) {
// A node was opened but never closed
throw new Error( 'Unbalanced input passed to document' );
}
ve.batchSplice( this.documentNode, 0, 0, currentStack );
this.updateNodesByType( [ this.documentNode ], [ this.documentNode ] );
doc.buildingNodeTree = false;
};
/**
* Get the length of the document. This is also the highest valid offset in the document.
*
* @return {number} Length of the document
*/
ve.dm.Document.prototype.getLength = function () {
return this.data.getLength();
};
/**
* Get the meta list.
*
* @return {ve.dm.MetaList} Meta list of the surface
*/
ve.dm.Document.prototype.getMetaList = function () {
// Ensure the DM tree has been built
this.getDocumentNode();
return this.metaList;
};
/**
* Set the read-only state of the document
*
* Actual locking of the model is done by the surface, but
* we pass through this flag so we can do some optimizations
* in read-only mode, such as caching node offsets.
*
* TODO: It might just be easier for Documents to know which
* Surface they belong to, although we should make sure that
* this doesn't violate the direction of data flow.
*
* @param {boolean} readOnly Mark document as read-only
*/
ve.dm.Document.prototype.setReadOnly = function ( readOnly ) {
this.readOnly = !!readOnly;
if ( !this.readOnly ) {
// Clear offset cache when leaving read-only mode
this.getDocumentNode().traverse( ( node ) => {
node.offset = null;
} );
}
};
/**
* Check if the document is read-only
*
* @return {boolean}
*/
ve.dm.Document.prototype.isReadOnly = function () {
return this.readOnly;
};
/**
* Apply a transaction's effects on the content data.
*
* @param {ve.dm.Transaction} transaction Transaction to apply
* @param {boolean} isStaging Transaction is being applied in staging mode
* @fires ve.dm.Document#precommit
* @fires ve.dm.Document#transact
* @throws {Error} Cannot commit a transaction that has already been committed
*/
ve.dm.Document.prototype.commit = function ( transaction, isStaging ) {
if ( transaction.hasBeenApplied() ) {
throw new Error( 'Cannot commit a transaction that has already been committed' );
}
this.emit( 'precommit', transaction );
this.branchNodeFromOffsetCache = [];
new ve.dm.TransactionProcessor( this, transaction, isStaging ).process();
this.completeHistory.pushTransaction( transaction, this.store.getLength() );
this.emit( 'transact', transaction );
};
/**
* Get a slice or copy of the document data.
*
* @param {ve.Range} [range] Range of data to get, all data will be given by default
* @param {boolean} [deep=false] Whether to return a deep copy (WARNING! This may be very slow)
* @return {Array} Slice or copy of document data
*/
ve.dm.Document.prototype.getData = function ( range, deep ) {
return this.data.getDataSlice( range, deep );
};
/**
* Get a copy of the document metadata.
*
* This is just a sparse shallow copy of the document data, with meta-item open tags only (i.e.
* with blanks in place of non-meta-items and meta-item close tags).
*
* @param {ve.Range} [range] Range of metadata to get, all metadata will be given by default
* @return {ve.dm.MetaItem[]} Sparse array of ve.dm.MetaItems.
*/
ve.dm.Document.prototype.getMetadata = function ( range ) {
Iif ( arguments.length > 1 ) {
throw new Error( 'Argument "deep" is no longer supported' );
}
const documentNode = this.getDocumentNode();
Eif ( !range ) {
range = new ve.Range( 0, documentNode.length );
}
const data = [];
documentNode.traverse( ( node ) => {
let offset;
Iif ( node instanceof ve.dm.MetaItem ) {
offset = node.getOffset();
if ( range.start <= offset && offset < range.end ) {
data[ offset - range.start ] = node;
}
}
} );
data.length = range.end - range.start;
return data;
};
/**
* Get the HTMLDocument associated with this document.
*
* @return {HTMLDocument} Associated document
*/
ve.dm.Document.prototype.getHtmlDocument = function () {
return this.htmlDocument;
};
/**
* Get the document model form which this document was cloned.
*
* @return {ve.dm.Document|null} Original document
*/
ve.dm.Document.prototype.getOriginalDocument = function () {
return this.originalDocument;
};
/**
* Get the document's hash-value store
*
* @return {ve.dm.HashValueStore} The document's hash-value store
*/
ve.dm.Document.prototype.getStore = function () {
return this.store;
};
/**
* Get the document's internal list
*
* @return {ve.dm.InternalList} The document's internal list
*/
ve.dm.Document.prototype.getInternalList = function () {
return this.internalList;
};
/**
* Get the document's inner whitespace
*
* @return {Array.<string|undefined>} The document's inner whitespace
*/
ve.dm.Document.prototype.getInnerWhitespace = function () {
return this.innerWhitespace;
};
/**
* Clone a sub-document from a shallow copy of this document.
*
* The new document's elements, internal list and store will only contain references to data within the slice.
*
* @param {ve.dm.Selection} selection Selection to create sub-document from
* @return {ve.dm.DocumentSlice} New document
*/
ve.dm.Document.prototype.shallowCloneFromSelection = function ( selection ) {
if ( selection instanceof ve.dm.LinearSelection ) {
return this.shallowCloneFromRange( selection.getRange() );
} else Eif ( selection instanceof ve.dm.TableSelection ) {
const data = [];
const ranges = selection.getTableSliceRanges( this );
for ( let i = 0, l = ranges.length; i < l; i++ ) {
ve.batchPush( data, this.data.slice( ranges[ i ].start, ranges[ i ].end ) );
}
const linearData = new ve.dm.ElementLinearData( this.getStore(), data );
const tableRange = new ve.Range( 0, data.length );
// Copy over the internal list
ve.batchSplice(
linearData.data, linearData.getLength(), 0,
this.getData( this.getInternalList().getListNode().getOuterRange(), true )
);
// The internalList is rebuilt by the document constructor
return new ve.dm.TableSlice(
linearData, this.getHtmlDocument(), undefined, this.getInternalList(), tableRange, this
);
} else {
return this.shallowCloneFromRange( new ve.Range( 0 ) );
}
};
/**
* Clone a sub-document from a shallow copy of this document.
*
* The new document's elements, internal list and store will only contain references to data within the slice.
*
* @param {ve.Range} [range] Range of data to slice; defaults to whole document
* @return {ve.dm.DocumentSlice} New document
*/
ve.dm.Document.prototype.shallowCloneFromRange = function ( range ) {
const balanceOpenings = [],
balanceClosings = [],
contextOpenings = [],
contextClosings = [];
let linearData, originalRange, balancedRange;
if ( !range ) {
// Default to the whole document
linearData = this.data.sliceObject();
originalRange = balancedRange = this.getDocumentRange();
} else {
const selection = this.selectNodes( range, 'siblings' );
const first = selection[ 0 ];
const last = selection[ selection.length - 1 ];
let firstNode = first.node;
let lastNode = last.node;
// Use first/lastNode if they are non-content branch nodes, otherwise use getBranchNodeFromOffset.
let startNode = !firstNode.hasChildren() && !firstNode.isContent() ? firstNode : this.getBranchNodeFromOffset( range.start );
let endNode = !lastNode.hasChildren() && !lastNode.isContent() ? lastNode : this.getBranchNodeFromOffset( range.end );
// Fix up selection to remove empty items in unwrapped nodes
// TODO: fix this is selectNodes
while ( selection[ 0 ] && selection[ 0 ].range && selection[ 0 ].range.isCollapsed() && !selection[ 0 ].node.isWrapped() ) {
selection.shift();
}
let i = selection.length - 1;
while ( selection[ i ] && selection[ i ].range && selection[ i ].range.isCollapsed() && !selection[ i ].node.isWrapped() ) {
selection.pop();
i--;
}
let balancedNodes;
if ( selection.length === 0 || range.isCollapsed() ) {
// Nothing selected
linearData = new ve.dm.ElementLinearData( this.getStore(), [
{ type: 'paragraph', internal: { generated: 'empty' } },
{ type: '/paragraph' }
] );
originalRange = balancedRange = new ve.Range( 1 );
} else if ( startNode === endNode ) {
// Nothing to balance
balancedNodes = selection;
} else {
// Selection is not balanced
while ( !firstNode.isWrapped() ) {
firstNode = firstNode.getParent();
}
while ( !lastNode.isWrapped() ) {
lastNode = lastNode.getParent();
}
Eif ( first.range ) {
while ( true ) {
while ( !startNode.isWrapped() ) {
startNode = startNode.getParent();
}
balanceOpenings.push( startNode.getClonedElement() );
if ( startNode === firstNode ) {
break;
}
startNode = startNode.getParent();
}
}
if ( last !== first && last.range ) {
while ( true ) {
while ( !endNode.isWrapped() ) {
endNode = endNode.getParent();
}
balanceClosings.push( { type: '/' + endNode.getType() } );
if ( endNode === lastNode ) {
break;
}
endNode = endNode.getParent();
}
}
balancedNodes = this.selectNodes(
new ve.Range( firstNode.getOuterRange().start, lastNode.getOuterRange().end ),
'covered'
);
}
// eslint-disable-next-line no-inner-declarations
function nodeNeedsContext( node ) {
return node.getParentNodeTypes() !== null || node.isContent();
}
if ( !balancedRange ) {
// Check if any of the balanced siblings need more context for insertion anywhere
let needsContext = false;
for ( i = balancedNodes.length - 1; i >= 0; i-- ) {
if ( nodeNeedsContext( balancedNodes[ i ].node ) ) {
needsContext = true;
break;
}
}
if ( needsContext ) {
startNode = balancedNodes[ 0 ].node;
// Keep wrapping until the outer node can be inserted anywhere
while ( startNode.getParent() && nodeNeedsContext( startNode ) ) {
const isContent = startNode.isContent();
startNode = startNode.getParent();
const contextElement = startNode.getClonedElement();
if ( isContent ) {
ve.setProp( contextElement, 'internal', 'generated', 'wrapper' );
}
contextOpenings.push( contextElement );
contextClosings.push( { type: '/' + contextElement.type } );
}
}
// Final data:
// contextOpenings + balanceOpenings + data slice + balanceClosings + contextClosings
linearData = new ve.dm.ElementLinearData(
this.getStore(),
[].concat(
contextOpenings.reverse(),
balanceOpenings.reverse(),
this.data.slice( range.start, range.end ),
balanceClosings,
contextClosings
)
);
originalRange = new ve.Range(
contextOpenings.length + balanceOpenings.length,
contextOpenings.length + balanceOpenings.length + range.getLength()
);
balancedRange = new ve.Range(
contextOpenings.length,
contextOpenings.length + balanceOpenings.length + range.getLength() + balanceClosings.length
);
}
// Shallow copy over the internal list
ve.batchSplice(
linearData.data, linearData.getLength(), 0,
this.getData( this.getInternalList().getListNode().getOuterRange() )
);
}
// The internalList is rebuilt by the document constructor
const slice = new ve.dm.DocumentSlice(
linearData, this.getHtmlDocument(), undefined, this.getInternalList(), originalRange, balancedRange, this
);
return slice;
};
/**
* Clone a sub-document from a range in this document. The new document's elements, store and internal list
* will be clones of the ones in this document.
*
* @param {ve.Range} [range] Range of data to clone, clones the whole document if ommitted.
* @param {boolean} [detachedCopy] The copy is not intended to be merged into the original
* @param {string} [mode] Mode for getting data, see #getFullData
* @return {ve.dm.Document} New document
*/
ve.dm.Document.prototype.cloneFromRange = function ( range, detachedCopy, mode ) {
const listRange = this.getInternalList().getListNode().getOuterRange();
const data = ve.copy( this.getFullData( range, mode || 'roundTrip' ) );
if ( range && ( range.start > listRange.start || range.end < listRange.end ) ) {
// The range does not include the entire internal list, so add it
ve.batchPush( data, this.getFullData( listRange ) );
}
return this.cloneWithData( data, true, detachedCopy );
};
/**
* Create a sub-document associated with this document like #cloneFromRange, but without cloning
* any data from a range in this document: instead, use the specified data.
*
* @param {Array|ve.dm.ElementLinearData} data Raw linear model data or ElementLinearData
* @param {boolean} [copyInternalList] Copy the internal list
* @param {boolean} [detachedCopy] The copy is not intended to be merged into the original
* @return {ve.dm.Document} New document
*/
ve.dm.Document.prototype.cloneWithData = function ( data, copyInternalList, detachedCopy ) {
Eif ( Array.isArray( data ) ) {
data = new ve.dm.ElementLinearData( this.getStore().slice(), data );
}
const newDoc = new this.constructor(
data,
// htmlDocument
this.getHtmlDocument(),
// parentDocument
undefined,
// internalList
copyInternalList ? this.getInternalList() : undefined,
// innerWhitespace
undefined,
// lang+dir
this.getLang(), this.getDir(),
// originalDocument
this,
// sourceMode
this.sourceMode,
// persistentStorage
this.getStorage()
);
if ( copyInternalList && !detachedCopy ) {
// Record the length of the internal list at the time the slice was created so we can
// reconcile additions properly
newDoc.origInternalListLength = this.internalList.getItemNodeCount();
}
return newDoc;
};
/**
* Get document data, possibly with inline MetaItem load offsets restored, possibly without metadata
*
* @param {ve.Range} [range] Range to get full data for. If omitted, all data will be returned
* @param {string} [mode] If 'roundTrip', restore load offsets of inlined meta items from unchanged
* branches. If 'noMetadata', don't include metadata items.
* @return {Array} Data, with load offset info removed (some items are referenced, others copied)
*/
ve.dm.Document.prototype.getFullData = function ( range, mode ) {
const insertedMetaItems = [],
insertions = {},
iLen = range ? range.end : this.data.getLength(),
result = [];
function stripMetaLoadInfo( element ) {
if ( !element || !element.internal ) {
return element;
}
element = ve.copy( element );
delete element.internal.changesSinceLoad;
delete element.internal.metaItems;
delete element.internal.loadMetaParentHash;
delete element.internal.loadMetaParentOffset;
delete element.internal.preservedAnnotations;
if ( Object.keys( element.internal ).length === 0 ) {
delete element.internal;
}
return element;
}
for ( let i = range ? range.start : 0; i < iLen; i++ ) {
const item = this.data.getData( i );
if (
ve.dm.LinearData.static.isOpenElementData( item ) &&
ve.dm.nodeFactory.isMetaData( item.type ) &&
(
mode === 'noMetadata' ||
mode === 'roundTrip' && (
// Already inserted
insertedMetaItems.indexOf( item.originalDomElementsHash ) !== -1 ||
// Removable meta item that was not handled yet, which means that its entire branch node
// must have been removed, so it's out of place and should be removed too
ve.dm.nodeFactory.isRemovableMetaData( item.type ) && ve.getProp( item, 'internal', 'loadMetaParentOffset' )
)
)
) {
// Skip this item and its matching close tag
i += 1;
continue;
}
let metaItem, metaItems, internal;
if (
mode === 'roundTrip' &&
( internal = item.internal ) &&
( metaItems = internal.metaItems )
) {
if ( !internal.changesSinceLoad ) {
this.data.modifyData( i, ( dataItem ) => {
// Re-fetch unfrozen metaItems.
metaItems = dataItem.internal.metaItems;
// No changes, so restore meta item offsets
for ( let j = 0, jLen = metaItems.length; j < jLen; j++ ) {
metaItem = metaItems[ j ];
const offset = i + metaItem.internal.loadMetaParentOffset;
if ( !insertions[ offset ] ) {
insertions[ offset ] = [];
}
delete metaItem.internal.loadBranchNodeHash;
delete metaItem.internal.loadBranchNodeOffset;
if ( metaItem.internal.preservedAnnotations ) {
metaItem.annotations = metaItem.internal.preservedAnnotations;
delete metaItem.internal.preservedAnnotations;
}
Iif ( Object.keys( metaItem.internal ).length === 0 ) {
delete metaItem.internal;
}
insertions[ offset ].push( stripMetaLoadInfo( metaItem ) );
insertedMetaItems.push( metaItem.originalDomElementsHash );
}
} );
} else {
// Had changes, so remove removable meta items that are out of place now
for ( let j = 0, jLen = metaItems.length; j < jLen; j++ ) {
metaItem = metaItems[ j ];
if ( ve.dm.nodeFactory.isRemovableMetaData( metaItem.type ) ) {
insertedMetaItems.push( metaItem.originalDomElementsHash );
}
}
}
}
result.push( stripMetaLoadInfo( item ) );
if ( mode === 'roundTrip' && insertions[ i ] ) {
// There are meta items to reinsert outside of ContentBranchNodes.
// TODO: we should strip annotations from such meta items
for ( let j = 0, jLen = insertions[ i ].length; j < jLen; j++ ) {
metaItem = insertions[ i ][ j ];
result.push( metaItem );
result.push( { type: '/' + metaItem.type } );
}
}
}
return result;
};
/**
* Get the nearest word boundary.
*
* @param {number} offset Offset to start from
* @param {number} [direction] Direction to prefer matching offset in, -1 for left and 1 for right
* @return {number} Nearest word boundary
*/
ve.dm.Document.prototype.getSiblingWordBoundary = function ( offset, direction ) {
const dataString = new ve.dm.DataString( this.getData() );
return unicodeJS.wordbreak.moveBreakOffset( direction, dataString, offset, true );
};
/**
* Get the relative word or character boundary.
*
* @param {number} offset Offset to start from
* @param {number} direction Direction to prefer matching offset in, -1 for left and 1 for right
* @param {string} [unit] Unit [word|character]
* @return {number} Relative offset
*/
ve.dm.Document.prototype.getRelativeOffset = function ( offset, direction, unit ) {
const data = this.data;
if ( unit === 'word' ) { // Word
// Method getSiblingWordBoundary does not "move/jump" over element data. If passed offset is
// an element data offset then the same offset is returned - and in such case this method
// fallback to the other path (character) which does "move/jump" over element data.
let newOffset = this.getSiblingWordBoundary( offset, direction );
if ( offset === newOffset ) {
newOffset = this.getRelativeOffset( offset, direction, 'character' );
}
return newOffset;
} else { // Character
// Check if we are adjacent to a focusable node
const adjacentDataOffset = offset + ( direction > 0 ? 0 : -1 );
if (
data.isElementData( adjacentDataOffset ) &&
ve.dm.nodeFactory.isNodeFocusable( data.getType( adjacentDataOffset ) )
) {
// We are adjacent to a focusableNode, move inside it
return offset + direction;
}
const relativeContentOffset = data.getRelativeContentOffset( offset, direction );
let relativeStructuralOffset = data.getRelativeStructuralOffset( offset, direction, true );
let isFocusable;
// Check the structural offset is not in the wrong direction
if ( ( relativeStructuralOffset - offset < 0 ? -1 : 1 ) !== direction ) {
relativeStructuralOffset = offset;
} else {
isFocusable = ( relativeStructuralOffset - offset < 0 ? -1 : 1 ) === direction &&
data.isElementData( relativeStructuralOffset + direction ) &&
ve.dm.nodeFactory.isNodeFocusable( data.getType( relativeStructuralOffset + direction ) );
}
// Check if we've moved into a slug or a focusableNode
if ( isFocusable || this.hasSlugAtOffset( relativeStructuralOffset ) ) {
if ( isFocusable ) {
relativeStructuralOffset += direction;
}
// Check if the relative content offset is in the opposite direction we are trying to go
if (
relativeContentOffset === offset ||
( relativeContentOffset - offset < 0 ? -1 : 1 ) !== direction
) {
return relativeStructuralOffset;
}
// There's a slug nearby, go into it if it's closer
return direction > 0 ?
Math.min( relativeContentOffset, relativeStructuralOffset ) :
Math.max( relativeContentOffset, relativeStructuralOffset );
} else {
// Don't allow the offset to move in the wrong direction
return direction > 0 ?
Math.max( relativeContentOffset, offset ) :
Math.min( relativeContentOffset, offset );
}
}
};
/**
* Get the relative range.
*
* @param {ve.Range} range Input range
* @param {number} direction Direction to look in, +1 or -1
* @param {string} unit Unit [word|character]
* @param {boolean} expand Expanding range
* @param {ve.Range} [limit] Optional limiting range. If the relative range is not in this range
* the input range is returned instead.
* @return {ve.Range} Relative range
*/
ve.dm.Document.prototype.getRelativeRange = function ( range, direction, unit, expand, limit ) {
let to = range.to;
// If you have a non-collapsed range and you move, collapse to the end
// in the direction you moved, provided you end up at a content or slug offset
if ( !range.isCollapsed() && !expand ) {
const newOffset = direction > 0 ? range.end : range.start;
if ( this.data.isContentOffset( newOffset ) || this.hasSlugAtOffset( newOffset ) ) {
return new ve.Range( newOffset );
} else {
to = newOffset;
}
}
const contentOrSlugOffset = this.getRelativeOffset( to, direction, unit );
const focusableNode = this.getNearestFocusableNode( to, direction, contentOrSlugOffset );
let newRange;
if ( focusableNode ) {
newRange = focusableNode.getOuterRange( direction === -1 );
} else {
newRange = new ve.Range( contentOrSlugOffset );
}
Iif ( limit && !limit.containsRange( newRange ) ) {
return range;
}
if ( expand ) {
return new ve.Range( range.from, newRange.to );
} else {
return newRange;
}
};
/**
* Get the nearest node matching a test.
*
* @param {Function} test Function to test whether a node matches, called with the nodeType
* @param {number} offset Offset to start looking at
* @param {number} direction Direction to look in, +1 or -1
* @param {number} limit Stop looking after reaching certain offset
* @return {ve.dm.Node|null} Nearest matching node, or null if not found
*/
ve.dm.Document.prototype.getNearestNodeMatching = function ( test, offset, direction, limit ) {
// It is never an offset of the node, but just an offset for which getNodeFromOffset should
// return that node. Usually it would be node offset + 1 or offset of node closing tag.
let coveredOffset;
this.data.getRelativeOffset(
offset,
direction === 1 ? 0 : -1,
function ( index, lim ) {
// Our result must be between offset and limit
if ( index >= Math.max( offset, lim ) || index < Math.min( offset, lim ) ) {
return true;
}
if (
this.isOpenElementData( index ) &&
test( this.getType( index ) )
) {
coveredOffset = index + 1;
return true;
}
if (
this.isCloseElementData( index ) &&
test( this.getType( index ) )
) {
coveredOffset = index;
return true;
}
},
limit
);
if ( coveredOffset ) {
return this.getDocumentNode().getNodeFromOffset( coveredOffset );
} else {
return null;
}
};
/**
* Get the nearest focusable node.
*
* @param {number} offset Offset to start looking at
* @param {number} direction Direction to look in, +1 or -1
* @param {number} limit Stop looking after reaching certain offset
* @return {ve.dm.Node|null} Nearest focusable node, or null if not found
*/
ve.dm.Document.prototype.getNearestFocusableNode = function ( offset, direction, limit ) {
return this.getNearestNodeMatching( ( nodeType ) => ve.dm.nodeFactory.isNodeFocusable( nodeType ), offset, direction, limit );
};
/**
* Get the nearest offset that a cursor can be placed at.
*
* Note that an offset in the other direction can be returned if there are no valid offsets in the
* preferred direction.
*
* @param {number} offset Offset to start looking at
* @param {number} [direction=-1] Direction to check first, +1 or -1; if 0, find the closest offset
* @return {number} Nearest offset a cursor can be placed at, or -1 if there are no valid offsets in
* data
*/
ve.dm.Document.prototype.getNearestCursorOffset = function ( offset, direction ) {
if ( direction === 0 ) {
const left = this.getNearestCursorOffset( offset, -1 );
const right = this.getNearestCursorOffset( offset, 1 );
// If only one of `left` and `right` is valid, return the valid one.
// If neither is valid, this returns -1.
Iif ( right === -1 ) {
return left;
} else Iif ( left === -1 ) {
return right;
}
return offset - left < right - offset ? left : right;
}
direction = direction > 0 ? 1 : -1;
if (
this.data.isContentOffset( offset ) ||
this.hasSlugAtOffset( offset )
) {
return offset;
}
const contentOffset = this.data.getNearestContentOffset( offset, direction );
const structuralOffset = this.data.getNearestStructuralOffset( offset, direction, true );
// If only one of `contentOffset` and `structuralOffset` is valid, return the valid one.
// If neither is valid, this returns -1.
if ( structuralOffset === -1 || !this.hasSlugAtOffset( structuralOffset ) ) {
return contentOffset;
} else Eif ( contentOffset === -1 ) {
return structuralOffset;
}
if ( direction === 1 ) {
if ( contentOffset < offset ) {
return structuralOffset;
} else {
return Math.min( contentOffset, structuralOffset );
}
} else {
if ( contentOffset > offset ) {
return structuralOffset;
} else {
return Math.max( contentOffset, structuralOffset );
}
}
};
/**
* @inheritdoc
*/
ve.dm.Document.prototype.getBranchNodeFromOffset = function ( offset ) {
Iif ( offset < 0 || offset > this.data.getLength() ) {
throw new Error( 've.dm.Document.getBranchNodeFromOffset(): offset ' + offset + ' is out of bounds' );
}
if ( !this.branchNodeFromOffsetCache[ offset ] ) {
this.branchNodeFromOffsetCache[ offset ] = ve.Document.prototype.getBranchNodeFromOffset.call( this, offset );
}
return this.branchNodeFromOffsetCache[ offset ];
};
/**
* Check if there is a slug at an offset.
*
* @param {number} offset Offset to check for a slug at
* @return {boolean} There is a slug at the offset
*/
ve.dm.Document.prototype.hasSlugAtOffset = function ( offset ) {
let node;
try {
node = this.getBranchNodeFromOffset( offset );
} catch ( e ) {
// Offset was out of bounds
}
return node ? node.hasSlugAtOffset( offset ) : false;
};
/**
* Get the content data of a node.
*
* @param {ve.dm.Node} node Node to get content data for
* @return {Array|null} List of content and elements inside node or null if node is not found
*/
ve.dm.Document.prototype.getDataFromNode = function ( node ) {
let offset = node.getOffset();
Eif ( offset >= 0 ) {
// FIXME T126023: If the node is wrapped in an element than we should increment
// the offset by one so we only return the content inside the element.
if ( node.isWrapped() ) {
offset++;
}
return this.data.slice( offset, offset + node.getLength() );
}
return null;
};
/**
* Rebuild the entire node tree from linear model data.
*/
ve.dm.Document.prototype.rebuildTree = function () {
// attachedRootRange is an inner range for a non-document node,
// so that we never rebuild above the attachedRoot node as that
// would destroy that node, and invalidate all references to it (T293254).
// When it is the full document it spans all nodes in the document,
// excluding the interna list.
const attachedRoot = this.getAttachedRoot();
this.rebuildTreeNode( attachedRoot );
};
/**
* Rebuild the node tree from linear model data from a specicifc range.
*
* @param {ve.dm.BranchNode} rootNode Node to rebuild
*/
ve.dm.Document.prototype.rebuildTreeNode = function ( rootNode ) {
Iif ( !rootNode.length ) {
this.buildNodeTree();
}
const range = rootNode.getRange();
const data = this.data.sliceObject( range.start, range.end );
// Build document fragment from data
// Use plain ve.dm.Document, instead of whatever this.constructor is.
const documentFragment = new ve.dm.Document( data, this.htmlDocument, this );
// Get generated child nodes from the document fragment
const addedNodes = documentFragment.getDocumentNode().getChildren();
// Replace nodes in the model tree
const removedNodes = ve.batchSplice( rootNode, 0, rootNode.getChildren().length, addedNodes );
this.updateNodesByType( addedNodes, removedNodes );
// Clear branch node cache
this.branchNodeFromOffsetCache = [];
};
/**
* Update the nodes-by-type index
*
* @param {ve.dm.Node[]} addedNodes Added nodes
* @param {ve.dm.Node[]} removedNodes Removed nodes
*/
ve.dm.Document.prototype.updateNodesByType = function ( addedNodes, removedNodes ) {
const remove = ( node ) => {
const type = node.getType(),
nodes = this.nodesByType[ type ] || [],
index = nodes.indexOf( node );
if ( index !== -1 ) {
nodes.splice( index, 1 );
if ( !nodes.length ) {
delete this.nodesByType[ type ];
}
}
};
const add = ( node ) => {
const type = node.getType(),
nodes = this.nodesByType[ type ] = this.nodesByType[ type ] || [];
nodes.push( node );
};
const traverse = ( nodes, action ) => {
nodes.forEach( ( node ) => {
if ( node.hasChildren() ) {
node.traverse( action );
}
action( node );
} );
};
traverse( removedNodes, remove );
traverse( addedNodes, add );
};
/**
* Get all nodes in the tree for a specific type
*
* If a string type is passed only nodes of that exact type will be returned,
* if a node class is passed, all sub types will be matched.
*
* String type matching will be faster than class matching.
*
* @param {string|Function} type Node type name or node constructor
* @param {boolean} sort Sort nodes by document order
* @return {ve.dm.Node[]} Nodes of a specific type
*/
ve.dm.Document.prototype.getNodesByType = function ( type, sort ) {
Eif ( !this.documentNode.length && !this.documentNode.getDocument().buildingNodeTree ) {
this.buildNodeTree();
}
let nodes;
Iif ( type instanceof Function ) {
nodes = [];
for ( const t in this.nodesByType ) {
const nodeType = ve.dm.nodeFactory.lookup( t );
if ( nodeType === type || nodeType.prototype instanceof type ) {
ve.batchPush( nodes, this.getNodesByType( t ) );
}
}
} else {
nodes = this.nodesByType[ type ] || [];
}
Iif ( sort ) {
nodes.sort( ( a, b ) => a.getOffset() - b.getOffset() );
}
return nodes;
};
/**
* @typedef FixedInsertion
* @memberof ve.dm.Document
* @property {Array} data Possibly modified copy of `data`
* @property {number} offset Possibly modified offset
* @property {number} remove Number of elements to remove after the modified `offset`
* @property {number} [insertedDataOffset] Offset of intended insertion within fixed up data
* @property {number} [insertedDataLength] Length of intended insertion within fixed up data
*/
/**
* Fix up data so it can safely be inserted into the document data at an offset.
*
* TODO: this function needs more work but it seems to work, mostly
*
* @param {Array} data Snippet of linear model data to insert
* @param {number} offset Offset in the linear model where the caller wants to insert data
* @return {ve.dm.Document.FixedInsertion}
*/
ve.dm.Document.prototype.fixupInsertion = function ( data, offset ) {
const
// Array where we build the return value
newData = [],
// Inserting block element into an empty content branch will replace it.
remove = 0,
// *** Stacks ***
// Array of element openings (object). Openings in data are pushed onto this stack
// when they are encountered and popped off when they are closed
openingStack = [],
// Array of node objects. Closings in data that close nodes that were
// not opened in data (i.e. were already in the document) are pushed onto this stack
// and popped off when balanced out by an opening in data
closingStack = [];
// Track the position of the original data in the fixed up data for range adjustments
let insertedDataOffset = 0,
insertedDataLength = data.length,
// *** State persisting across iterations of the outer loop ***
// The node (from the document) we're currently in. When in a node that was opened
// in data, this is set to its first ancestor that is already in the document
parentNode,
// The type of the node we're currently in, even if that node was opened within data
parentType,
// Whether we are currently in a text node
inTextNode,
// Whether this is the first child of its parent
// The test for last child isn't a loop so we don't need to cache it
isFirstChild = null;
/**
* Append a linear model element to newData and update the state.
*
* This function updates parentNode, parentType, openingStack and closingStack.
*
* @private
* @param {Object|Array|string} element Linear model element
* @param {number} index Index in data that the element came from (for error reporting only)
*/
function writeElement( element, index ) {
if ( element.type !== undefined ) {
// Content, do nothing
if ( element.type.charAt( 0 ) !== '/' ) {
// Opening
// Check if this opening balances an earlier closing of a node that was already in
// the document. This is only the case if openingStack is empty (otherwise we still
// have unclosed nodes from within data) and if this opening matches the top of
// closingStack
if ( openingStack.length === 0 && closingStack.length > 0 &&
closingStack[ closingStack.length - 1 ].getType() === element.type
) {
// The top of closingStack is now balanced out, so remove it
// Also restore parentNode from closingStack. While this is technically not
// entirely accurate (the current node is a new node that's a sibling of this
// node), it's good enough for the purposes of this algorithm
parentNode = closingStack.pop();
} else {
// This opens something new, put it on openingStack
openingStack.push( element );
}
parentType = element.type;
} else {
let expectedType;
// Closing
// Make sure that this closing matches the currently opened node
if ( openingStack.length > 0 ) {
// The opening was on openingStack, so we're closing a node that was opened
// within data. Don't track that on closingStack
expectedType = openingStack.pop().type;
} else {
// openingStack is empty, so we're closing a node that was already in the
// document. This means we have to reopen it later, so track this on
// closingStack
expectedType = parentNode.getType();
closingStack.push( parentNode );
parentNode = parentNode.getParent();
if ( !parentNode ) {
throw new Error( 'Inserted data is trying to close the root node ' +
'(at index ' + index + ')' );
}
parentType = expectedType;
// Validate
// FIXME this breaks certain input, should fix it up, not scream and die
// For now we fall back to inserting balanced data, but then we miss out on
// a lot of the nice content adoption abilities of just fixing up the data in
// the context of the insertion point - an example of how this will fail is if
// you try to insert "b</p></li></ul><p>c" into "<p>a[cursor]d</p>"
Iif (
element.type !== '/' + expectedType &&
(
// Only throw an error if the content can't be adopted from one content
// branch to another
!ve.dm.nodeFactory.canNodeContainContent( element.type.slice( 1 ) ) ||
!ve.dm.nodeFactory.canNodeContainContent( expectedType )
)
) {
throw new Error( 'Cannot adopt content from ' + element.type +
' nodes into ' + expectedType + ' nodes (at index ' + index + ')' );
}
}
}
}
newData.push( element );
}
/**
* Close the current element on the stack and arrange for its later reopening
*
* This function updates parentNode, parentType, closingStack, reopenElements, and closings.
*
* @private
* @param {Array} closings Closing elements array to be appended to
* @param {Array} reopenElements Opening elements array to be appended to
* @param {string} type Current element type we're considering (for error reporting only)
* @param {number} index Current index (for error reporting only)
*/
function closeElement( closings, reopenElements, type, index ) {
// Close the parent and try one level up
closings.push( { type: '/' + parentType } );
Iif ( openingStack.length > 0 ) {
const element = openingStack.pop();
parentType = element.type;
reopenElements.push( ve.copy( element ) );
// The opening was on openingStack, so we're closing a node that was opened
// within data. Don't track that on closingStack
} else {
Iif ( !parentNode.getParent() ) {
throw new Error( 'Cannot insert ' + type + ' even after closing ' +
'all containing nodes (at index ' + index + ')' );
}
// openingStack is empty, so we're closing a node that was already in the
// document. This means we have to reopen it later, so track this on
// closingStack
closingStack.push( parentNode );
reopenElements.push( parentNode.getClonedElement() );
parentNode = parentNode.getParent();
parentType = parentNode.getType();
}
}
parentNode = this.getBranchNodeFromOffset( offset );
parentType = parentNode.getType();
inTextNode = false;
isFirstChild = this.data.isOpenElementData( offset - 1 );
for ( let i = 0; i < data.length; i++ ) {
if ( inTextNode && data[ i ].type !== undefined ) {
parentType = openingStack.length > 0 ?
openingStack[ openingStack.length - 1 ].type : parentNode.getType();
}
if ( data[ i ].type === undefined || data[ i ].type.charAt( 0 ) !== '/' ) {
// The type of the node we're currently inserting. When the to-be-inserted node
// is wrapped, this is set to the type of the outer wrapper.
let childType = data[ i ].type || 'text';
// Array of opening elements to insert (for wrapping the to-be-inserted element)
const openings = [];
// Array of closing elements to insert (for splitting nodes)
const closings = [];
// Array of opening elements matching the elements in closings (in the same order)
const reopenElements = [];
// Opening or content
// Make sure that opening this element here does not violate the parent/children/content
// rules. If it does, insert stuff to fix it
// If this node is content, check that the containing node can contain content.
// If not, add a wrapper paragraph
if ( ve.dm.nodeFactory.isNodeContent( childType ) &&
!ve.dm.nodeFactory.canNodeContainContent( parentType )
) {
childType = 'paragraph';
const wrapper = ve.dm.nodeFactory.getDataElement( childType );
ve.setProp( wrapper, 'internal', 'generated', 'wrapper' );
openings.unshift( wrapper );
}
// Check that this node is allowed to have the containing node as its parent. If not,
// wrap it until it's fixed
let parentsOK;
do {
const allowedParents = ve.dm.nodeFactory.getParentNodeTypes( childType );
parentsOK = allowedParents === null ||
allowedParents.indexOf( parentType ) !== -1;
if ( !parentsOK ) {
// We can't have this as the parent
Iif ( allowedParents.length === 0 ) {
throw new Error( 'Cannot insert ' + childType + ' because it ' +
' cannot have a parent (at index ' + i + ')' );
}
// Open an allowed node around this node
childType = allowedParents[ 0 ];
openings.unshift( ve.dm.nodeFactory.getDataElement( childType ) );
}
} while ( !parentsOK );
// Check that the node is allowed to have the containing node as
// its parent. If not, close surrounding nodes until the node is
// contained in an acceptable parent.
const suggestedParents = ve.dm.nodeFactory.getSuggestedParentNodeTypes( childType );
let suggestedParentsOK;
do {
suggestedParentsOK = suggestedParents === null ||
suggestedParents.indexOf( parentType ) !== -1;
if ( !suggestedParentsOK ) {
closeElement( closings, reopenElements, childType, i );
}
} while ( !suggestedParentsOK );
// Check that the containing node can have this node as its child. If not, close nodes
// until it's fixed
let childrenOK;
do {
const allowedChildren = ve.dm.nodeFactory.getChildNodeTypes( parentType );
childrenOK = allowedChildren === null ||
allowedChildren.indexOf( childType ) !== -1;
// Also check if we're trying to insert structure into a node that has to contain
// content
childrenOK = childrenOK && !(
!ve.dm.nodeFactory.isNodeContent( childType ) &&
ve.dm.nodeFactory.canNodeContainContent( parentType )
);
if ( !childrenOK ) {
// We can't insert this into this parent
if ( isFirstChild ) {
// This element would be the first child of its parent, so
// abandon this fix up and try again one offset to the left
const insertion = this.fixupInsertion( data, offset - 1 );
if ( this.data.isCloseElementData( offset ) && !ve.dm.nodeFactory.isNodeInternal( parentType ) ) {
// This element would also be the last child, so that means parent is empty.
// Remove it entirely. (Never remove the internal list though, ugh...)
insertion.remove += 2;
}
return insertion;
}
// Close the parent and try one level up
closeElement( closings, reopenElements, childType, i );
}
} while ( !childrenOK );
for ( let j = 0; j < closings.length; j++ ) {
// writeElement() would update openingStack/closingStack, but we've already done
// that for closings
if ( i === 0 ) {
insertedDataOffset++;
} else {
insertedDataLength++;
}
newData.push( closings[ j ] );
}
for ( let j = 0; j < openings.length; j++ ) {
if ( i === 0 ) {
insertedDataOffset++;
} else {
insertedDataLength++;
}
writeElement( openings[ j ], i );
}
writeElement( data[ i ], i );
if ( data[ i ].type === undefined ) {
// Special treatment for text nodes
inTextNode = true;
if ( openings.length > 0 ) {
// We wrapped the text node, update parentType
parentType = childType;
}
// If we didn't wrap the text node, then the node we're inserting into can have
// content, so we couldn't have closed anything
} else {
parentType = data[ i ].type;
}
} else {
// Closing
writeElement( data[ i ], i );
parentType = openingStack.length > 0 ?
openingStack[ openingStack.length - 1 ].type : parentNode.getType();
}
}
if ( closingStack.length > 0 && this.data.isCloseElementData( offset ) ) {
// This element would be the last child of its parent, so
// abandon this fix up and try again one offset to the right
return this.fixupInsertion( data, offset + 1 );
}
if ( inTextNode ) {
parentType = openingStack.length > 0 ?
openingStack[ openingStack.length - 1 ].type : parentNode.getType();
}
// Close unclosed openings
while ( openingStack.length > 0 ) {
const popped = openingStack[ openingStack.length - 1 ];
// writeElement() will perform the actual pop() that removes
// popped from openingStack
writeElement( { type: '/' + popped.type }, data.length );
}
// Re-open closed nodes
while ( closingStack.length > 0 ) {
const popped = closingStack[ closingStack.length - 1 ];
// writeElement() will perform the actual pop() that removes
// popped from closingStack
writeElement( popped.getClonedElement(), data.length );
}
return {
offset: offset,
data: newData,
remove: remove,
insertedDataOffset: insertedDataOffset !== 0 ? insertedDataOffset : undefined,
insertedDataLength: insertedDataLength !== newData.length ? insertedDataLength : undefined
};
};
/**
* Create a document given an HTML string or document.
*
* @param {string|HTMLDocument} html HTML string or document to insert
* @param {Object} [importRules] The import rules with which to sanitize the HTML, if importing
* @return {ve.dm.Document} New document
*/
ve.dm.Document.prototype.newFromHtml = function ( html, importRules ) {
const htmlDoc = typeof html === 'string' ? ve.createDocumentFromHtml( html ) : html,
doc = ve.dm.converter.getModelFromDom( htmlDoc, {
targetDoc: this.getHtmlDocument(),
fromClipboard: !!importRules
} ),
data = doc.data;
if ( importRules ) {
data.sanitize( importRules.external || {} );
data.sanitize( importRules.all || {} );
}
data.remapInternalListKeys( this.getInternalList() );
// Initialize node tree
// BUG T75569: This shouldn't be needed
doc.buildNodeTree();
return doc;
};
/**
* Find a text string within the document
*
* @param {string|RegExp} query Text to find, string or regex with no flags
* @param {Object} [options] Search options
* @param {boolean} [options.searchRange] Range to search. Defaults to the attached root.
* @param {boolean} [options.caseSensitiveString] Case sensitive search for a string query. Ignored by regexes (use 'i' flag).
* @param {boolean} [options.diacriticInsensitiveString] Diacritic insensitive search for a string query. Ignored by regexes.
* Only works in browsers which support the Internationalization API
* @param {boolean} [options.noOverlaps] Avoid overlapping matches
* @param {boolean} [options.wholeWord] Only match whole-word occurrences
* @return {ve.Range[]} List of ranges where the string was found
*/
ve.dm.Document.prototype.findText = function ( query, options ) {
options = options || {};
const data = this.data,
searchRange = options.searchRange || this.getAttachedRootRange();
let ranges = [];
if ( query instanceof RegExp ) {
// Avoid multi-line matching by only matching within content (text or content elements)
data.forEachRunOfContent( searchRange, ( off, line ) => {
query.lastIndex = 0;
let match;
while ( ( match = query.exec( line ) ) !== null ) {
let matchText = match[ 0 ];
// Skip empty string matches (e.g. with .*)
if ( matchText.length === 0 ) {
// Set lastIndex to the next character to avoid an infinite
// loop. Browsers differ in whether they do this for you
// for empty matches; see
// http://blog.stevenlevithan.com/archives/exec-bugs
query.lastIndex = match.index + 1;
continue;
}
// Content elements' open/close data is replaced by the replacement character U+FFFC.
// Ensure that matches of U+FFFC contain the entire element (opening and closing data).
// The U+FFFC placeholder is only used for elements which "are content" (.static.isContent
// is true), and such elements are guaranteed to not contain content, so this is safe.
// Note, however, that this character is allowed to appear in normal text (eww),
// so we consult the actual document data to make sure we actually matched an element.
// 1/2: If we matched opening U+FFFC at the end, extend the match forwards by 1.
if (
matchText[ matchText.length - 1 ] === '\uFFFC' &&
data.isOpenElementData( off + match.index + matchText.length - 1 ) &&
data.isCloseElementData( off + match.index + matchText.length )
) {
matchText += '\uFFFC';
query.lastIndex += 1;
}
// 2/2: If we matched closing U+FFFC at the beginning, skip the match.
// (We do not extend the match backwards to avoid overlapping matches.)
if (
matchText[ 0 ] === '\uFFFC' &&
data.isOpenElementData( off + match.index - 1 ) &&
data.isCloseElementData( off + match.index )
) {
// Continue matching at the next character, rather than the end of this match.
query.lastIndex = match.index + 1;
continue;
}
ranges.push( new ve.Range(
off + match.index,
off + match.index + matchText.length
) );
if ( !options.noOverlaps ) {
query.lastIndex = match.index + 1;
}
}
} );
} else {
const qLen = query.length;
let sensitivity;
if ( options.diacriticInsensitiveString ) {
sensitivity = options.caseSensitiveString ? 'case' : 'base';
} else {
sensitivity = options.caseSensitiveString ? 'variant' : 'accent';
}
// Intl is only used browser clients
const compare = new Intl.Collator( this.lang, { sensitivity: sensitivity } ).compare;
// Iterate up to (and including) offset textLength - queryLength. Beyond that point
// there is not enough room for the query to exist
for ( let offset = searchRange.start, l = searchRange.end - qLen; offset <= l; offset++ ) {
let j = 0;
while ( compare( data.getCharacterData( offset + j ), query[ j ] ) === 0 ) {
j++;
if ( j === qLen ) {
ranges.push( new ve.Range( offset, offset + qLen ) );
offset += options.noOverlaps ? qLen - 1 : 0;
break;
}
}
}
}
if ( options.wholeWord ) {
const dataString = new ve.dm.DataString( this.getData() );
ranges = ranges.filter( ( range ) => unicodeJS.wordbreak.isBreak( dataString, range.start ) &&
unicodeJS.wordbreak.isBreak( dataString, range.end ) );
}
return ranges;
};
/**
* Get the length of the complete history. This is also the current pointer.
*
* @return {number} Length of the complete history stack
*/
ve.dm.Document.prototype.getCompleteHistoryLength = function () {
return this.completeHistory.getLength();
};
/**
* Get all the transactions in the complete history since a specified pointer.
*
* @param {number} start Pointer from where to start the slice
* @return {ve.dm.Transaction[]} Array of transaction objects
*/
ve.dm.Document.prototype.getCompleteHistorySince = function ( start ) {
return this.completeHistory.transactions.slice( start );
};
/**
* Single change containing most recent transactions in history stack
*
* @param {number} start Pointer from where to start slicing transactions
* @return {ve.dm.Change} Single change containing transactions since pointer
*/
ve.dm.Document.prototype.getChangeSince = function ( start ) {
const change = this.completeHistory.mostRecent( start );
// Remove any selections that might have been added by e.g. ve.dm.Change#addToHistory
change.selections = {};
return change;
};
/**
* Get the content language
*
* @return {string} Language code
*/
ve.dm.Document.prototype.getLang = function () {
return this.lang;
};
/**
* Get the content directionality
*
* @return {string} Directionality (ltr/rtl)
*/
ve.dm.Document.prototype.getDir = function () {
return this.dir;
};
/**
* Set a key/value pair in persistent static storage, or restore the whole store
*
* Storage is used for static variables related to document state,
* such as InternalList's nextUniqueNumber.
*
* @param {string|Object} [keyOrStorage] Key, or storage object to restore
* @param {any} [value] Serializable value, if key is set
* @fires ve.dm.Document#storage
*/
ve.dm.Document.prototype.setStorage = function ( keyOrStorage, value ) {
if ( typeof keyOrStorage === 'string' ) {
this.persistentStorage[ keyOrStorage ] = value;
this.emit( 'storage' );
} else {
this.persistentStorage = keyOrStorage;
}
};
/**
* Get a value from the persistent static storage, or the whole store
*
* @param {string} [key] Key
* @return {any|Object} Value at key, or whole storage object if key not provided
*/
ve.dm.Document.prototype.getStorage = function ( key ) {
if ( key ) {
return this.persistentStorage[ key ];
} else {
return this.persistentStorage;
}
};
|