_test/vendor/scotteh/php-dom-wrapper/README.md

   1 # PHP DOM Wrapper
   2 [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/scotteh/php-dom-wrapper/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/scotteh/php-dom-wrapper/?branch=master)
   3
   4 ## Intro
   5
   6 PHP DOM Wrapper is a simple DOM wrapper library to manipulate and traverse HTML documents. Based around jQuery's manipulation and traversal methods, largely mimicking the behaviour of it's jQuery counterparts.
   7
   8 ## Author
   9
  10  - Andrew Scott (andrew@andrewscott.net.au)
  11
  12 ## Requirements
  13
  14  - PHP 7.1 or later
  15  - PSR-4 compatible autoloader
  16
  17 ## Install
  18
  19 Install with [Composer](https://getcomposer.org/doc/).
  20
  21 ```
  22 composer require scotteh/php-dom-wrapper
  23 ```
  24
  25 ## Autoloading
  26
  27 This library requires an autoloader, if you aren't already using one you can include [Composers autoloader](https://getcomposer.org/doc/01-basic-usage.md#autoloading).
  28
  29 ``` php
  30 require 'vendor/autoload.php';
  31 ```
  32
  33 ## Methods
  34
  35 ### Manipulation
  36
  37 | Method | jQuery Equivalent *(if different)* |
  38 |--------|------------------------------|
  39 | [addClass()](#addClass)    |
  40 | [follow()](#follow)       | *after()* |
  41 | [appendWith()](#appendWith)      | *append()* |
  42 | [appendTo()](#appendTo)    |
  43 | [attr()](#attr)        |
  44 | [clone()](#clone)       |
  45 | [destroy()](#destroy)      | *remove()* |
  46 | [detach()](#detach)      |
  47 | [empty()](#empty)       |
  48 | [hasClass()](#hasClass)    |
  49 | [html()](#html)        |
  50 | [precede()](#precede)      | *before()* |
  51 | [prependWith()](#prependWith)     | *prepend()* |
  52 | [prependTo()](#prependTo)   |
  53 | [removeAttr()](#removeAttr)  |
  54 | [removeClass()](#removeClass) |
  55 | [substituteWith()](#substituteWith) | *replaceWith()* |
  56 | [text()](#text)        |
  57 | [unwrap()](#unwrap)      |
  58 | [wrap()](#wrap)        |
  59 | [wrapAll()](#wrapAll)     |
  60 | [wrapInner()](#wrapInner)   |
  61
  62 ### Traversal
  63
  64 | Method | jQuery Equivalent *(if different)* |
  65 |--------|------------------------------|
  66 | [add()](#add)          |
  67 | [children()](#children)     |
  68 | [closest()](#closest)      |
  69 | [contents()](#contents)     |
  70 | [eq()](#eq)           |
  71 | [filter()](#filter)       |
  72 | [find()](#find)         |
  73 | [first()](#first)        |
  74 | [has()](#has)          |
  75 | [is()](#is)           |
  76 | [last()](#last)         |
  77 | [map()](#map)          |
  78 | [following()](#following)         | *next()* |
  79 | [followingAll()](#followingAll)      | *nextAll()* |
  80 | [followingUntil()](#followingUntil)    | *nextUntil()* |
  81 | [not()](#not)          |
  82 | [parent()](#parent)       |
  83 | [parents()](#parents)      |
  84 | [parentsUntil()](#parentsUntil) |
  85 | [preceding()](#preceding)         | *prev()* |
  86 | [precedingAll()](#precedingAll)      | *prevAll()* |
  87 | [precedingUntil()](#precedingUntil)    | *prevUntil()* |
  88 | [siblings()](#siblings)     |
  89 | [slice()](#slice)        |
  90
  91 ### Other
  92
  93 | Method | jQuery Equivalent *(if different)* |
  94 |--------|------------------------------|
  95 | [count()](#count)        | *length* (property) |
  96 | [each()](#each)
  97
  98 ## Usage
  99
 100 Example #1:
 101 ``` php
 102 use DOMWrap\Document;
 103
 104 $html = '<ul><li>First</li><li>Second</li><li>Third</li></ul>';
 105
 106 $doc = new Document();
 107 $doc->html($html);
 108 $nodes = $doc->find('li');
 109
 110 // Returns '3'
 111 var_dump($nodes->count());
 112
 113 // Append as a child node to each <li>
 114 $nodes->appendWith('<b>!</b>');
 115
 116 // Returns: <html><body><ul><li>First<b>!</b></li><li>Second<b>!</b></li><li>Third<b>!</b></li></ul></body></html>
 117 var_dump($doc->html());
 118 ```
 119
 120 ---
 121
 122 ## Methods
 123
 124 ### Manipulation
 125
 126 #### addClass
 127
 128 ```
 129 self addClass(string|callable $class)
 130 ```
 131
 132 ##### Example
 133
 134 ```php
 135 $doc = (new Document())->html('<p>first paragraph</p><p>second paragraph</p>');
 136 $doc->find('p')->addClass('text-center');
 137 ```
 138
 139 *Result:*
 140
 141 ``` html
 142 <p class="text-center">first paragraph</p><p class="text-center">second paragraph</p>
 143 ```
 144
 145 ---
 146
 147 #### follow
 148
 149 ```
 150 self follow(string|NodeList|\DOMNode|callable $input)
 151 ```
 152
 153 Insert the argument as a sibling directly after each of the nodes operated on.
 154
 155 ##### Example
 156
 157 ``` php
 158 $doc = (new Document())->html('<ul><li>first</li><li>second</li></ul>');
 159 $doc->find('li')->first()->follow('<li>first-and-a-half</li>');
 160
 161 ```
 162
 163 *Result:*
 164
 165 ``` html
 166 <ul>
 167     <li>first</li>
 168     <li>first-and-a-half</li>
 169     <li>second</li>
 170 </ul>
 171 ```
 172
 173 ---
 174
 175 #### appendWith
 176
 177 ```
 178 self appendWith(string|NodeList|\DOMNode|callable $input)
 179 ```
 180
 181 ##### Example
 182
 183 ``` php
 184 $doc = (new Document())->html('<div>The quick brown fox jumps over the lazy dog</div>');
 185 $doc->find('div')->appendWith('<strong> Appended!</strong>');
 186 ```
 187
 188 *Result:*
 189
 190 ``` html
 191 <div>The quick brown fox jumps over the lazy dog<strong> Appended!</strong></div>
 192 ```
 193
 194 ---
 195
 196 #### appendTo
 197
 198 ```
 199 self appendTo(string|NodeList|\DOMNode $selector)
 200 ```
 201
 202 ##### Example
 203
 204 ``` php
 205 $doc = (new Document())->html('<div>The quick brown fox jumps over the lazy dog</div>');
 206 $doc->create('<strong> Appended!</strong>')->appendTo('div');
 207 ```
 208
 209 *Result:*
 210 ``` html
 211 <div>The quick brown fox jumps over the lazy dog<strong> Appended!</strong></div>
 212 ```
 213
 214 ---
 215
 216 #### attr
 217
 218 ```
 219 self|string attr(string $name[, mixed $value = null])
 220 ```
 221
 222 ##### Example #1 (Set)
 223
 224 ``` php
 225 $doc = (new Document())->html('<div class="text-center"></div>');
 226 $doc->attr('class', 'text-left');
 227 ```
 228
 229 *Result:*
 230
 231 ``` html
 232 <div class="text-left"></div>
 233 ```
 234
 235 ##### Example #2 (Get)
 236
 237 ``` php
 238 $doc = (new Document())->html('<div class="text-center"></div>');
 239 echo $doc->attr('text-center');
 240 ```
 241
 242 *Result:*
 243
 244 ``` html
 245 text-center
 246 ```
 247
 248 ---
 249
 250 #### precede
 251
 252 ```
 253 self precede(string|NodeList|\DOMNode|callable $input)
 254 ```
 255
 256 Insert the argument as a sibling just before each of the nodes operated on.
 257
 258 ##### Example
 259
 260 ``` php
 261 $doc = (new Document())->html('<ul><li>first</li><li>second</li></ul>');
 262 doc->find('li')->first()->precede('<li>zeroth</li>');
 263 ```
 264
 265 *Result:*
 266
 267 ``` html
 268 <ul>
 269     <li>zeroth</li>
 270     <li>first</li>
 271     <li>second</li>
 272 </ul>
 273 ```
 274
 275 ---
 276
 277 #### clone
 278
 279 ```
 280 NodeList|\DOMNode clone()
 281 ```
 282
 283 ##### Example
 284
 285 ``` php
 286 $doc = (new Document())->html('<ul><li>Item</li></ul>');
 287 $doc->find('div')->clone()->appendTo('ul');
 288 ```
 289
 290 *Result:*
 291
 292 ``` html
 293 <ul><li>Item</li><li>Item</li></ul>
 294 ```
 295
 296 ---
 297
 298 #### destroy
 299
 300 ```
 301 self destroy([string $selector = null])
 302 ```
 303
 304 ##### Example
 305
 306 ``` php
 307 $doc = (new Document())->html('<ul><li class="first"></li><li class="second"></li></ul>');
 308 $doc->find('.first')->destroy();
 309 ```
 310
 311 *Result:*
 312 ``` html
 313 <ul><li class="second"></li></ul>
 314 ```
 315
 316 ---
 317
 318 #### detach
 319
 320 ```
 321 NodeList detach([string $selector = null])
 322 ```
 323
 324 ##### Example
 325
 326 ``` php
 327 $doc = (new Document())->html('<ul class="first"><li>Item</li></ul><ul class="second"></ul>');
 328 $el = $doc->find('ul.first li')->detach();
 329 $doc->first('ul.second').append($el);
 330 ```
 331
 332 *Result:*
 333
 334 ``` html
 335 <ul class="first"></ul><ul class="second"><li>Item</li></ul>
 336 ```
 337
 338 ---
 339
 340 #### empty
 341
 342 ```
 343 self empty()
 344 ```
 345
 346 ##### Example
 347
 348 ``` php
 349 $doc = (new Document())->html('<div>The quick brown fox jumps over the lazy dog</div>');
 350 $doc->find('div')->empty();
 351 ```
 352
 353 *Result:*
 354
 355 ``` html
 356 <div></div>
 357 ```
 358
 359 ---
 360
 361 #### hasClass
 362
 363 ```
 364 bool hasClass(string $class)
 365 ```
 366
 367 ##### Example
 368
 369 ``` php
 370 $doc = (new Document())->html('<div class="text-center"></div>');
 371 echo $doc->first('div')->hasClass('text-center');
 372 ```
 373
 374 *Result:*
 375
 376 ``` html
 377 true
 378 ```
 379
 380 ---
 381
 382 #### html
 383
 384 ```
 385 string|self html([string|NodeList|\DOMNode|callable $input = null])
 386 ```
 387
 388 ##### Example #1 (Set)
 389
 390 ``` php
 391 $doc = (new Document());
 392 $doc->html('<div class="example"></div>');
 393 ```
 394
 395 *Result:*
 396
 397 ``` html
 398 <div class="example"></div>
 399 ```
 400
 401 ##### Example #1 (Get)
 402
 403 ``` php
 404 $doc = (new Document())->html('<div class="example"></div>');
 405 $doc->find('div')->appendWith('<span>Example!</span>');
 406 echo $doc->html();
 407 ```
 408
 409 *Result:*
 410
 411 ``` html
 412 <div class="example"><span>Example!</span></div>
 413 ```
 414
 415 ---
 416
 417 #### prependWith
 418
 419 ```
 420 self prependWith(string|NodeList|\DOMNode|callable $input)
 421 ```
 422
 423 ##### Example
 424
 425 ``` php
 426 $doc = (new Document())->html('<div>The quick brown fox jumps over the lazy dog</div>');
 427 $doc->find('div')->prependWith('<strong>Prepended! </strong>');
 428 ```
 429
 430 *Result:*
 431
 432 ``` html
 433 <div><strong>Prepended! </strong>The quick brown fox jumps over the lazy dog</div>
 434 ```
 435
 436 ---
 437
 438 #### prependTo
 439
 440 ```
 441 self prependTo(string|NodeList|\DOMNode $selector)
 442 ```
 443
 444 ##### Example
 445
 446 ``` php
 447 $doc = (new Document())->html('<div>The quick brown fox jumps over the lazy dog</div>');
 448 $doc->create('<strong>Prepended! </strong>')->appendTo('div');
 449 ```
 450
 451 *Result:*
 452 ``` html
 453 <div><strong>Prepended! </strong>The quick brown fox jumps over the lazy dog</div>
 454 ```
 455
 456 ---
 457
 458 #### removeAttr
 459
 460 ```
 461 self removeAttr(string $name)
 462 ```
 463
 464 ##### Example
 465
 466 ``` php
 467 $doc = (new Document())->html('<div class="first second"></div>');
 468 $doc->find('div').removeAttr('class');
 469 ```
 470
 471 *Result:*
 472 ``` html
 473 <div></div>
 474 ```
 475
 476 ---
 477
 478 #### removeClass
 479
 480 ```
 481 self removeClass(string|callable $class)
 482 ```
 483
 484 ##### Example
 485
 486 ``` php
 487 $doc = (new Document())->html('<div class="first second"></div>');
 488 $doc->find('div').removeClass('first');
 489 ```
 490
 491 *Result:*
 492 ``` html
 493 <div class="second"></div>
 494 ```
 495
 496 ---
 497
 498 #### substituteWith
 499
 500 ```
 501 self substituteWith(string|NodeList|\DOMNode|callable $input)
 502 ```
 503
 504 ##### Example
 505
 506 ``` php
 507 ```
 508
 509 ---
 510
 511 #### text
 512
 513 ```
 514 string|self text([string|NodeList|\DOMNode|callable $input = null])
 515 ```
 516
 517 ##### Example
 518
 519 ``` php
 520 ```
 521
 522 ---
 523
 524 #### unwrap
 525
 526 ```
 527 self unwrap()
 528 ```
 529
 530 Unwrap each current node by removing its parent, replacing the parent
 531 with its children (i.e. the current node and its siblings).
 532
 533 Note that each node is operated on separately, so when you call
 534 `unwrap()` on a `NodeList` containing two siblings, *two* parents will
 535 be removed.
 536
 537 ##### Example
 538
 539 ``` php
 540 $doc = (new Document())->html('<div id="outer"><div id="first"/><div id="second"/></div>');
 541 $doc->find('#first')->unwrap();
 542 ```
 543
 544 *Result:*
 545
 546 ``` html
 547 <div id="first"></div>
 548 <div id="second"></div>
 549 ```
 550
 551 ---
 552
 553 #### wrap
 554
 555 ```
 556 self wrap(string|NodeList|\DOMNode|callable $input)
 557 ```
 558
 559 Wrap the current node or nodes in the given structure.
 560
 561 The wrapping structure can be nested, but should only contain one node
 562 on each level (any extra siblings are removed). The outermost node
 563 replaces the node operated on, while the node operated on is put into
 564 the innermost node.
 565
 566 If called on a `NodeList`, each of nodes in the list will be separately
 567 wrapped. When such a list contains multiple nodes, the argument to
 568 wrap() cannot be a `NodeList` or `\DOMNode`, since those can be used
 569 to wrap a node only once. A string or callable returning a string or a
 570 unique `NodeList` or `\DomNode` every time can be used in this case.
 571
 572 When a callable is passed, it is called once for each node operated on,
 573 passing that node and its index. The callable should return either a
 574 string, or a unique `NodeList` or `\DOMNode` ever time it is called.
 575
 576 Note that this returns the original node like all other methods, not the
 577 (new) node(s) wrapped around it.
 578
 579 ##### Example
 580
 581 ``` php
 582 $doc = (new Document())->html('<span>foo<span><span>bar</span>');
 583 $doc->find->('span')->wrap('<div><p/></div>');
 584 ```
 585
 586 *Result:*
 587
 588 ``` html
 589 <div><p><span>foo</span></p></div>
 590 <div><p><span>bar</span></p></div>
 591 ```
 592
 593
 594 ---
 595
 596 #### wrapAll
 597
 598 ```
 599 self wrapAll(string|NodeList|\DOMNode|callable $input)
 600 ```
 601
 602 Like [wrap()](#wrap), but when operating on multiple nodes, all of them
 603 will be wrapped together in a single instance of the given structure,
 604 rather than each of them individually.
 605
 606 Note that the wrapping structure replaces the first node operated on, so
 607 if the other nodes operated on are not siblings of the first, they will
 608 be moved inside the document.
 609
 610 ##### Example
 611
 612 ``` php
 613 $doc = (new Document())->html('<span>foo<span><span>bar</span>');
 614 $doc->find->('span')->wrapAll('<div><p/></div>');
 615 ```
 616
 617 *Result:*
 618
 619 ``` html
 620 <div><p>
 621     <span>foo</span>
 622     <span>bar</span>
 623 </p></div>
 624 ```
 625
 626 ---
 627
 628 #### wrapInner
 629
 630 ```
 631 self wrapInner(string|NodeList|\DOMNode|callable $input)
 632 ```
 633
 634 Like [wrap()](#wrap), but rather than wrapping the nodes that are being
 635 operated on, this wraps their contents.
 636
 637 ##### Example
 638
 639 ``` php
 640 $doc = (new Document())->html('<span>foo<span><span>bar</span>');
 641 $doc->find('span')->wrapInner('<b><i/></b>');
 642 ```
 643
 644 *Result:*
 645
 646 ``` html
 647 <span><b><i>foo</i></b></span>
 648 <span><b><i>bar</i></b></span>
 649 ```
 650
 651 ---
 652
 653
 654 ### Traversal
 655
 656 #### add
 657
 658 ```
 659 NodeList add(string|NodeList|\DOMNode $input)
 660 ```
 661
 662 Add additional node(s) to the existing set.
 663
 664 ##### Example
 665
 666 ``` php
 667 $nodes = $doc->find('a');
 668 $nodes->add($doc->find('p'));
 669 ```
 670
 671 ---
 672
 673 #### children
 674
 675 ```
 676 NodeList children()
 677 ```
 678
 679 Return all children of each element node in the current set.
 680
 681 ##### Example
 682
 683 ``` php
 684 $nodes = $doc->find('p');
 685 $childrenOfParagraphs = $nodes->children();
 686 ```
 687
 688 ---
 689
 690 #### closest
 691
 692 ```
 693 Element|NodeList|null closest(string|NodeList|\DOMNode|callable $input)
 694 ```
 695
 696 Return the first element matching the supplied input by traversing up through the ancestors of each node in the current set.
 697
 698 ##### Example
 699
 700 ``` php
 701 $nodes = $doc->find('a');
 702 $closestAncestors = $nodes->closest('p');
 703 ```
 704
 705 ---
 706
 707 #### contents
 708
 709 ```
 710 NodeList contents()
 711 ```
 712
 713 Return all children of each node in the current set.
 714
 715 ##### Example
 716
 717 ``` php
 718 $nodes = $doc->find('p');
 719 $contents = $nodes->contents();
 720 ```
 721
 722 ---
 723
 724 #### eq
 725
 726 ```
 727 \DOMNode|null eq(int $index)
 728 ```
 729
 730 Return node in the current set at the specified index.
 731
 732 ##### Example
 733
 734 ``` php
 735 $nodes = $doc->find('a');
 736 $nodeAtIndexOne = $nodes->eq(1);
 737 ```
 738
 739 ---
 740
 741 #### filter
 742
 743 ```
 744 NodeList filter(string|NodeList|\DOMNode|callable $input)
 745 ```
 746
 747 Return nodes in the current set that match the input.
 748
 749 ##### Example
 750
 751 ``` php
 752 $nodes = $doc->filter('a')
 753 $exampleATags = $nodes->filter('[href*=https://example.org/]');
 754 ```
 755
 756 ---
 757
 758 #### find
 759
 760 ```
 761 NodeList find(string $selector[, string $prefix = 'descendant::'])
 762 ```
 763
 764 Return the decendants of the current set filtered by the selector and optional XPath axes.
 765
 766 ##### Example
 767
 768 ``` php
 769 $nodes = $doc->find('a');
 770 ```
 771
 772 ---
 773
 774 #### first
 775
 776 ```
 777 mixed first()
 778 ```
 779
 780 Return the first node of the current set.
 781
 782 ##### Example
 783
 784 ``` php
 785 $nodes = $doc->find('a');
 786 $firstNode = $nodes->first();
 787 ```
 788
 789 ---
 790
 791 #### has
 792
 793 ```
 794 NodeList has(string|NodeList|\DOMNode|callable $input)
 795 ```
 796
 797 Return nodes with decendants of the current set matching the input.
 798
 799 ##### Example
 800
 801 ``` php
 802 $nodes = $doc->find('a');
 803 $anchorTags = $nodes->has('span');
 804 ```
 805
 806 ---
 807
 808 #### is
 809
 810 ```
 811 bool is(string|NodeList|\DOMNode|callable $input)
 812 ```
 813
 814 Test if nodes from the current set match the input.
 815
 816 ##### Example
 817
 818 ``` php
 819 $nodes = $doc->find('a');
 820 $isAnchor = $nodes->is('[anchor]');
 821 ```
 822
 823 ---
 824
 825 #### last
 826
 827 ```
 828 mixed last()
 829 ```
 830
 831 Return the last node of the current set.
 832
 833 ##### Example
 834
 835 ``` php
 836 $nodes = $doc->find('a');
 837 $lastNode = $nodes->last();
 838 ```
 839
 840 ---
 841
 842 #### map
 843
 844 ```
 845 NodeList map(callable $function)
 846 ```
 847
 848 Apply a callback to nodes in the current set and return a new NodeList.
 849
 850 ##### Example
 851
 852 ``` php
 853 $nodes = $doc->find('a');
 854 $nodeValues = $nodes->map(function($node) {
 855     return $node->nodeValue;
 856 });
 857 ```
 858
 859 ---
 860
 861 #### following
 862
 863 ```
 864 \DOMNode|null following([string|NodeList|\DOMNode|callable $selector = null])
 865 ```
 866
 867 Return the sibling immediately following each element node in the current set.
 868
 869 *Optionally filtered by selector.*
 870
 871 ##### Example
 872
 873 ``` php
 874 $nodes = $doc->find('a');
 875 $follwingNodes = $nodes->following();
 876 ```
 877
 878 ---
 879
 880 #### followingAll
 881
 882 ```
 883 NodeList followingAll([string|NodeList|\DOMNode|callable $selector = null])
 884 ```
 885
 886 Return all siblings following each element node in the current set.
 887
 888 *Optionally filtered by selector.*
 889
 890 ##### Example
 891
 892 ``` php
 893 $nodes = $doc->find('a');
 894 $follwingAllNodes = $nodes->followingAll('[anchor]');
 895 ```
 896
 897 ---
 898
 899 #### followingUntil
 900
 901 ```
 902 NodeList followingUntil([[string|NodeList|\DOMNode|callable $input = null], string|NodeList|\DOMNode|callable $selector = null])
 903 ```
 904
 905 Return all siblings following each element node in the current set upto but not including the node matched by $input.
 906
 907 *Optionally filtered by input.*<br>
 908 *Optionally filtered by selector.*
 909
 910 ##### Example
 911
 912 ``` php
 913 $nodes = $doc->find('a');
 914 $follwingUntilNodes = $nodes->followingUntil('.submit');
 915 ```
 916
 917 ---
 918
 919 #### not
 920
 921 ```
 922 NodeList not(string|NodeList|\DOMNode|callable $input)
 923 ```
 924
 925 Return element nodes from the current set not matching the input.
 926
 927 ##### Example
 928
 929 ``` php
 930 $nodes = $doc->find('a');
 931 $missingHrefAttribute = $nodes->not('[href]');
 932 ```
 933
 934 ---
 935
 936 #### parent
 937
 938 ```
 939 Element|NodeList|null parent([string|NodeList|\DOMNode|callable $selector = null])
 940 ```
 941
 942 Return the immediate parent of each element node in the current set.
 943
 944 *Optionally filtered by selector.*
 945
 946 ##### Example
 947
 948 ``` php
 949 $nodes = $doc->find('a');
 950 $parentNodes = $nodes->parent();
 951 ```
 952
 953 ---
 954
 955 #### parents
 956
 957 ```
 958 NodeList parent([string $selector = null])
 959 ```
 960
 961 Return the ancestors of each element node in the current set.
 962
 963 *Optionally filtered by selector.*
 964
 965 ##### Example
 966
 967 ``` php
 968 $nodes = $doc->find('a');
 969 $ancestorDivNodes = $nodes->parents('div');
 970 ```
 971
 972 ---
 973
 974 #### parentsUntil
 975
 976 ```
 977 NodeList parentsUntil([[string|NodeList|\DOMNode|callable $input, [string|NodeList|\DOMNode|callable $selector = null])
 978 ```
 979
 980 Return the ancestors of each element node in the current set upto but not including the node matched by $selector.
 981
 982 *Optionally filtered by input.*<br>
 983 *Optionally filtered by selector.*
 984
 985 ##### Example
 986
 987 ``` php
 988 $nodes = $doc->find('a');
 989 $ancestorDivNodes = $nodes->parentsUntil('div');
 990 ```
 991
 992 ---
 993
 994 #### preceding
 995
 996 ```
 997 \DOMNode|null preceding([string|NodeList|\DOMNode|callable $selector = null])
 998 ```
 999
1000 Return the sibling immediately preceding each element node in the current set.
1001
1002 *Optionally filtered by selector.*
1003
1004 ##### Example
1005
1006 ``` php
1007 $nodes = $doc->find('a');
1008 $precedingNodes = $nodes->preceding();
1009 ```
1010
1011 ---
1012
1013 #### precedingAll
1014
1015 ```
1016 NodeList precedingAll([string|NodeList|\DOMNode|callable $selector = null])
1017 ```
1018
1019 Return all siblings preceding each element node in the current set.
1020
1021 *Optionally filtered by selector.*
1022
1023 ##### Example
1024
1025 ``` php
1026 $nodes = $doc->find('a');
1027 $precedingAllNodes = $nodes->precedingAll('[anchor]');
1028 ```
1029
1030 ---
1031 #### precedingUntil
1032
1033 ```
1034 NodeList precedingUntil([[string|NodeList|\DOMNode|callable $input = null], string|NodeList|\DOMNode|callable $selector = null])
1035 ```
1036
1037 Return all siblings preceding each element node in the current set upto but not including the node matched by $input.
1038
1039 *Optionally filtered by input.*<br>
1040 *Optionally filtered by selector.*
1041
1042 ##### Example
1043
1044 ``` php
1045 $nodes = $doc->find('a');
1046 $precedingUntilNodes = $nodes->precedingUntil('.submit');
1047 ```
1048
1049 ---
1050
1051 #### siblings
1052
1053 ```
1054 NodeList siblings([[string|NodeList|\DOMNode|callable $selector = null])
1055 ```
1056
1057 Return siblings of each element node in the current set.
1058
1059 *Optionally filtered by selector.*
1060
1061 ##### Example
1062
1063 ``` php
1064 $nodes = $doc->find('p');
1065 $siblings = $nodes->siblings();
1066 ```
1067
1068 ---
1069
1070 #### slice
1071
1072 ```
1073 NodeList slice(int $start[, int $end])
1074 ```
1075
1076 Return a subset of the current set based on the start and end indexes.
1077
1078 ##### Example
1079
1080 ``` php
1081 $nodes = $doc->find('p');
1082 // Return nodes 1 through to 3 as a new NodeList
1083 $slicedNodes = $nodes->slice(1, 3);
1084 ```
1085
1086 ---
1087
1088 ### Additional Methods
1089
1090 #### count
1091
1092 ```
1093 int count()
1094 ```
1095
1096 ##### Example
1097
1098 ``` php
1099 $nodes = $doc->find('p');
1100
1101 echo $nodes->count();
1102 ```
1103
1104 ---
1105
1106 #### each
1107
1108 ```
1109 self each(callable $function)
1110 ```
1111
1112 ##### Example
1113
1114 ``` php
1115 $nodes = $doc->find('p');
1116
1117 $nodes->each(function($node){
1118     echo $node->nodeName . "\n";
1119 });
1120 ```
1121
1122 ## Licensing
1123
1124 PHP DOM Wrapper is licensed by Andrew Scott under the BSD 3-Clause License, see the LICENSE file for more details.