08-27-周三_17-09-29
This commit is contained in:
576
node_modules/cheerio/History.md
generated
vendored
Normal file
576
node_modules/cheerio/History.md
generated
vendored
Normal file
@@ -0,0 +1,576 @@
|
||||
|
||||
0.22.0 / 2016-08-23
|
||||
==================
|
||||
|
||||
* Return undefined in .prop if given an invalid element or tag (#880)
|
||||
* Merge pull request #884 from cheeriojs/readme-cleanup
|
||||
* readme updates
|
||||
* Merge pull request #881 from piamancini/patch-1
|
||||
* Added backers and sponsors from OpenCollective
|
||||
* Use jQuery from the jquery module in benchmarks (#871)
|
||||
* Document, test, and extend static `$.text` method (#855)
|
||||
* Fix typo on calling _.extend (#861)
|
||||
* Update versions (#870)
|
||||
* Use individual lodash functions (#864)
|
||||
* Added `.serialize()` support. Fixes #69 (#827)
|
||||
* Update Readme.md (#857)
|
||||
* add extension for JSON require call
|
||||
* remove gittask badge
|
||||
* Merge pull request #672 from underdogio/dev/checkbox.radio.values.sqwished
|
||||
* Added default value for checkboxes/radios
|
||||
|
||||
0.20.0 / 2016-02-01
|
||||
==================
|
||||
|
||||
* Add coveralls badge, remove link to old report (Felix Böhm)
|
||||
* Update lodash dependeny to 4.1.0 (leif.hanack)
|
||||
* Fix PR #726 adding 'appendTo()' and 'prependTo()' (Delgan)
|
||||
* Added appendTo and prependTo with tests #641 (digihaven)
|
||||
* Fix #780 by changing options context in '.find()' (Felix Böhm)
|
||||
* Add an unit test checking the query of child (Delgan)
|
||||
* fix #667: attr({foo: null}) removes attribute foo, like attr('foo', null) (Ray Waldin)
|
||||
* Include reference to dedicated "Loading" section (Mike Pennisi)
|
||||
* Added load method to $ (alanev)
|
||||
* update css-select to 1.2.0 (Felix Böhm)
|
||||
* Fixing Grammatical Error (Dan Corman)
|
||||
* Test against node v0.12 --> v4.2 (Jason Kurian)
|
||||
* Correct output in example (Felix Böhm)
|
||||
* Fix npm files filter (Bogdan Chadkin)
|
||||
* Enable setting data on all elements in selection (Mike Pennisi)
|
||||
* Reinstate `$.fn.toArray` (Mike Pennisi)
|
||||
* update css-select to 1.1.0 (Thomas Shafer)
|
||||
* Complete implementation of `wrap` (Mike Pennisi)
|
||||
* Correct name of unit test (Mike Pennisi)
|
||||
* Correct grammar in test titles (Mike Pennisi)
|
||||
* Normalize whitespace (Mike Pennisi)
|
||||
* Insert omitted assertion (Mike Pennisi)
|
||||
* Update invocation of `children` (Mike Pennisi)
|
||||
* Begin implementation of `wrap` method (Dandlezzz)
|
||||
* Update Readme.md (Sven Slootweg)
|
||||
* fix document's mistake in Readme.md (exoticknight)
|
||||
* Add tests for setting text and html as non-strings (Ryc O'Chet)
|
||||
* Fix for passing non-string values to .html or .text (Ryc O'Chet)
|
||||
* use a selector to filter form elements (fb55)
|
||||
* fix README.md typo (Yutian Li)
|
||||
* README: fix spelling (Chris Rebert)
|
||||
* Added support for options without a `value` attribute. Fixes #633 (Todd Wolfson)
|
||||
* responding to pull request feedback - remove item() method and related tests (Ray Waldin)
|
||||
* add length property and item method to object returned by prop('style'), plus tests (Ray Waldin)
|
||||
* Added .prop method to readme (Artem Burtsev)
|
||||
* Added .prop method (Artem Burtsev)
|
||||
* Added Gitter badge (The Gitter Badger)
|
||||
|
||||
0.19.0 / 2015-03-21
|
||||
==================
|
||||
|
||||
* fixed allignment (fb55)
|
||||
* added test case for malformed json in data attributes (fb55)
|
||||
* fix: handle some extreme cases like `data-custom="{{templatevar}}"`. There is possibility error while parsing json . (Harish.K)
|
||||
* Add missing optional selector doc for {prev,next}{All,Until} (Jérémie Astori)
|
||||
* update to dom-serializer@0.1.0 (Felix Böhm)
|
||||
* Document `Cheerio#serialzeArray` (Mike Pennisi)
|
||||
* Fixed up `serializeArray()` and added multiple support (Todd Wolfson)
|
||||
* Implement serializeArray() (Jarno Leppänen)
|
||||
* recognize options in $.xml() (fb55)
|
||||
* lib/static.js: text(): rm errant space before ++ (Chris Rebert)
|
||||
* Do not expose internal `children` array (Mike Pennisi)
|
||||
* Change lodash dependencies to ^3.1.0 (Samy Pessé)
|
||||
* Update lodash@3.1.0 (Samy Pessé)
|
||||
* Updates Readme.md: .not(function (index, elem)) (Patrick Ward)
|
||||
* update to css-select@1.0.0 (fb55)
|
||||
* Allow failures in Node.js v0.11 (Mike Pennisi)
|
||||
* Added: Gittask badge (Matthew Mueller)
|
||||
* Isolate prototypes of functions created via `load` (Mike Pennisi)
|
||||
* Updates Readme.md: adds JS syntax highlighting (frankcash)
|
||||
* #608 -- Add support for insertBefore/insertAfter syntax. Supports target types of: $, [$], selector (both single and multiple results) (Ben Cochran)
|
||||
* Clone input nodes when inserting over a set (Mike Pennisi)
|
||||
* Move unit test files (Mike Pennisi)
|
||||
* remove unnecessarily tricky code (David Chambers)
|
||||
* pass options to $.html in toString (fb55)
|
||||
* add license info to package.json (Chris Rebert)
|
||||
* xyz@~0.5.0 (David Chambers)
|
||||
* Remove unofficial signature of `children` (Mike Pennisi)
|
||||
* Fix bug in `css` method (Mike Pennisi)
|
||||
* Correct bug in implementation of `Cheerio#val` (Mike Pennisi)
|
||||
|
||||
0.18.0 / 2014-11-06
|
||||
==================
|
||||
|
||||
* bump htmlparser2 dependency to ~3.8.1 (Chris Rebert)
|
||||
* Correct unit test titles (Mike Pennisi)
|
||||
* Correct behavior of `after` and `before` (Mike Pennisi)
|
||||
* implement jQuery's .has() (Chris Rebert)
|
||||
* Update repository url (haqii)
|
||||
* attr() should return undefined or name for booleans (Raoul Millais)
|
||||
* Update Readme.md (Ryan Breen)
|
||||
* Implement `Cheerio#not` (Mike Pennisi)
|
||||
* Clone nodes according to original parsing options (Mike Pennisi)
|
||||
* fix lint error (David Chambers)
|
||||
* Add explicit tests for DOM level 1 API (Mike Pennisi)
|
||||
* Expose DOM level 1 API for Node-like objects (Mike Pennisi)
|
||||
* Correct error in documentation (Mike Pennisi)
|
||||
* Return a fully-qualified Function from `$.load` (Mike Pennisi)
|
||||
* Update tests to avoid duck typing (Mike Pennisi)
|
||||
* Alter "loaded" functions to produce true instances (Mike Pennisi)
|
||||
* Organize tests for `cheerio.load` (Mike Pennisi)
|
||||
* Complete `$.prototype.find` (Mike Pennisi)
|
||||
* Use JSHint's `extends` option (Mike Pennisi)
|
||||
* Remove aliases for exported methods (Mike Pennisi)
|
||||
* Disallow unused variables (Mike Pennisi)
|
||||
* Remove unused internal variables (Mike Pennisi)
|
||||
* Remove unused variables from unit tests (Mike Pennisi)
|
||||
* Remove unused API method references (Mike Pennisi)
|
||||
* Move tests for `contains` method (Mike Pennisi)
|
||||
* xyz@0.4.0 (David Chambers)
|
||||
* Created a wiki for companies using cheerio in production (Matthew Mueller)
|
||||
* Implement `$.prototype.index` (Mike Pennisi)
|
||||
* Implement `$.prototype.addBack` (Mike Pennisi)
|
||||
* Added double quotes to radio attribute name to account for characters such as brackets (akant10)
|
||||
* Update History.md (Gabriel Falkenberg)
|
||||
* add 0.17.0 changelog (David Chambers)
|
||||
* exit prepublish script if tag not found (David Chambers)
|
||||
* alphabetize devDependencies (fb55)
|
||||
* ignore coverage dir (fb55)
|
||||
* submit coverage to coveralls (fb55)
|
||||
* replace jscoverage with istanbul (fb55)
|
||||
|
||||
0.17.0 / 2014-06-10
|
||||
==================
|
||||
|
||||
* Fix bug in internal `uniqueSplice` function (Mike Pennisi)
|
||||
* accept buffer argument to cheerio.load (David Chambers)
|
||||
* Respect options on the element level (Alex Indigo)
|
||||
* Change state definition to more readable (Artem Burtsev)
|
||||
* added test (0xBADC0FFEE)
|
||||
* add class only if doesn't exist (Artem Burtsev)
|
||||
* Made it less insane. (Alex Indigo)
|
||||
* Implement `Cheerio#add` (Mike Pennisi)
|
||||
* Use "loaded" instance of Cheerio in unit tests (Mike Pennisi)
|
||||
* Be more strict with object check. (Alex Indigo)
|
||||
* Added options argument to .html() static method. (Alex Indigo)
|
||||
* Fixed encoding mishaps. Adjusted tests. (Alex Indigo)
|
||||
* use dom-serializer module (fb55)
|
||||
* don't test on 0.8, don't ignore 0.11 (Felix Böhm)
|
||||
* parse: rm unused variables (coderaiser)
|
||||
* cheerio: rm unused variable (coderaiser)
|
||||
* Fixed test (Avi Kohn)
|
||||
* Added test (Avi Kohn)
|
||||
* Changed == to === (Avi Kohn)
|
||||
* Fixed a bug in removing type="hidden" attr (Avi Kohn)
|
||||
* sorted (Alexey Raspopov)
|
||||
* add `muted` attr to booleanAttributes (Alexey Raspopov)
|
||||
* fixed context of `this` in .html (Felix Böhm)
|
||||
* append new elements for each element in selection (fb55)
|
||||
|
||||
0.16.0 / 2014-05-08
|
||||
==================
|
||||
|
||||
* fix `make bench` (David Chambers)
|
||||
* makefile: add release-* targets (David Chambers)
|
||||
* alphabetize dependencies (David Chambers)
|
||||
* Rewrite `data` internals with caching behavior (Mike Pennisi)
|
||||
* Fence .val example as js (Kevin Sawicki)
|
||||
* Fixed typos. Deleted trailing whitespace from test/render.js (Nattaphoom Ch)
|
||||
* Fix manipulation APIs with removed elements (kpdecker)
|
||||
* Perform manual string parsing for hasClass (kpdecker)
|
||||
* Fix existing element removal (kpdecker)
|
||||
* update render tests (Felix Böhm)
|
||||
* fixed cheerio path (Felix Böhm)
|
||||
* use `entities.escape` for attribute values (Felix Böhm)
|
||||
* bump entities version (Felix Böhm)
|
||||
* remove lowerCaseTags option from readme (Felix Böhm)
|
||||
* added test case for .html in xmlMode (fb55)
|
||||
* render xml in `html()` when `xmlMode: true` (fb55)
|
||||
* use a map for booleanAttributes (fb55)
|
||||
* update singleTags, use utils.isTag (fb55)
|
||||
* update travis badge URL (Felix Böhm)
|
||||
* use typeof instead of _.isString and _.isNumber (fb55)
|
||||
* use Array.isArray instead of _.isArray (fb55)
|
||||
* replace _.isFunction with typeof (fb55)
|
||||
* removed unnecessary error message (fb55)
|
||||
* decode entities in htmlparser2 (fb55)
|
||||
* pass options object to CSSselect (fb55)
|
||||
|
||||
0.15.0 / 2014-04-08
|
||||
==================
|
||||
|
||||
* Update callbacks to pass element per docs (@kpdecker)
|
||||
* preserve options (@fb55)
|
||||
* Use SVG travis badge (@t3chnoboy)
|
||||
* only use static requires (@fb55)
|
||||
* Optimize manipulation methods (@kpdecker)
|
||||
* Optimize add and remove class cases (@kpdecker)
|
||||
* accept dom of DomHandler to cheerio.load (@nleush)
|
||||
* added parentsUntil method (@finspin)
|
||||
* Add performance optimization and bug fix `empty` method (@kpdecker)
|
||||
|
||||
0.14.0 / 2014-04-01
|
||||
==================
|
||||
|
||||
* call encodeXML and directly expose decodeHTML (@fb55)
|
||||
* use latest htmlparser2 and entities versions (@fb55)
|
||||
* Deprecate `$.fn.toArray` (@jugglinmike)
|
||||
* Implement `$.fn.get` (@jugglinmike)
|
||||
* .replaceWith now replaces all selected elements. (@xavi-)
|
||||
* Correct arguments for 'replaceWith' callback (@jugglinmike)
|
||||
* switch to lodash (@fb55)
|
||||
* update to entities@0.5.0 (@fb55)
|
||||
* Fix attr when $ collection contains text modules (@kpdecker)
|
||||
* Update to latest version of expect.js (@jugglinmike)
|
||||
* Remove nodes from their previous structures (@jugglinmike)
|
||||
* Update render.js (@stevenvachon)
|
||||
* CDATA test (@stevenvachon)
|
||||
* only ever one child index for cdata (@stevenvachon)
|
||||
* don't loop through cdata children array (@stevenvachon)
|
||||
* proper rendering of CDATA (@stevenvachon)
|
||||
* Add cheerio-only bench option (@kpdecker)
|
||||
* Avoid delete operations (@kpdecker)
|
||||
* Add independent html benchmark (@kpdecker)
|
||||
* Cache tag check in render (@kpdecker)
|
||||
* Simplify attribute rendering step (@kpdecker)
|
||||
* Add html rendering bench case (@kpdecker)
|
||||
* Remove unnecessary check from removeAttr (@kpdecker)
|
||||
* Remove unnecessary encoding step for attrs (@kpdecker)
|
||||
* Add test for removeAttr+attr on boolean attributes (@kpdecker)
|
||||
* Add single element benchmark case (@kpdecker)
|
||||
* Optimize filter with selector (@kpdecker)
|
||||
* Fix passing context as dom node (@alfred-nsh)
|
||||
* Fix bug in `nextUntil` (@jugglinmike)
|
||||
* Fix bug in `nextAll` (@jugglinmike)
|
||||
* Implement `selector` argument of `next` method (@jugglinmike)
|
||||
* Fix bug in `prevUntil` (@jugglinmike)
|
||||
* Implement `selector` argument of `prev` method (@jugglinmike)
|
||||
* Fix bug in `prevAll` (@jugglinmike)
|
||||
* Fix bug in `siblings` (@jugglinmike)
|
||||
* Avoid unnecessary indexOf from toggleClass (@kpdecker)
|
||||
* Use strict equality rather than falsy check in eq (@kpdecker)
|
||||
* Add benchmark coverage for all $ APIs (@kpdecker)
|
||||
* Optimize filter Cheerio intermediate creation (@kpdecker)
|
||||
* Optimize siblings cheerio instance creation (@kpdecker)
|
||||
* Optimize identity cases for first/last/eq (@kpdecker)
|
||||
* Use domEach for traversal (@kpdecker)
|
||||
* Inline children lookup in find (@kpdecker)
|
||||
* Use domEach in data accessor (@kpdecker)
|
||||
* Avoid cheerio creation in add/remove/toggleClass (@kpdecker)
|
||||
* Implement getAttr local helper (@kpdecker)
|
||||
|
||||
0.13.1 / 2014-01-07
|
||||
==================
|
||||
|
||||
* Fix select with context in Cheerio function (@jugglinmike)
|
||||
* Remove unecessary DOM maintenance logic (@jugglinmike)
|
||||
* Deprecate support for node 0.6
|
||||
|
||||
0.13.0 / 2013-12-30
|
||||
==================
|
||||
|
||||
* Remove "root" node (@jugglinmike)
|
||||
* Fix bug in `prevAll`, `prev`, `nextAll`, `next`, `prevUntil`, `nextUntil` (@jugglinmike)
|
||||
* Fix `replaceWith` method (@jugglinmike)
|
||||
* added nextUntil() and prevUntil() (@finspin)
|
||||
* Remove internal `connect` function (@jugglinmike)
|
||||
* Rename `Cheerio#make` to document private status (@jugginmike)
|
||||
* Remove extraneous call to `_.uniq` (@jugglinmike)
|
||||
* Use CSSselect library directly (@jugglinmike)
|
||||
* Run CI against Node v0.11 as an allowed failure (@jugginmike)
|
||||
* Correct bug in `Cheerio#parents` (@jugglinmike)
|
||||
* Implement `$.fn.end` (@jugginmike)
|
||||
* Ignore colons inside of url(.*) when parsing css (@Meekohi)
|
||||
* Introduce rudimentary benchmark suite (@jugglinmike)
|
||||
* Update HtmlParser2 version (@jugglinmike)
|
||||
* Correct inconsistency in `$.fn.map` (@jugglinmike)
|
||||
* fixed traversing tests (@finspin)
|
||||
* Simplify `make` method (@jugglinmike)
|
||||
* Avoid shadowing instance methods from arrays (@jugglinmike)
|
||||
|
||||
0.12.4 / 2013-11-12
|
||||
==================
|
||||
|
||||
* Coerce JSON values returned by `data` (@jugglinmike)
|
||||
* issue #284: when rendering HTML, use original data attributes (@Trott)
|
||||
* Introduce JSHint for automated code linting (@jugglinmike)
|
||||
* Prevent `find` from returning duplicate elements (@jugglinmike)
|
||||
* Implement function signature of `replaceWith` (@jugglinmike)
|
||||
* Implement function signature of `before` (@jugglinmike)
|
||||
* Implement function signature of `after` (@jugglinmike)
|
||||
* Implement function signature of `append`/`prepend` (@jugglinmike)
|
||||
* Extend iteration methods to accept nodes (@jugglinmike)
|
||||
* Improve `removeClass` (@jugglinmike)
|
||||
* Complete function signature of `addClass` (@jugglinmike)
|
||||
* Fix bug in `removeClass` (@jugglinmike)
|
||||
* Improve contributing.md (@jugglinmike)
|
||||
* Fix and document .css() (@jugglinmike)
|
||||
|
||||
0.12.3 / 2013-10-04
|
||||
===================
|
||||
|
||||
* Add .toggleClass() function (@cyberthom)
|
||||
* Add contributing guidelines (@jugglinmike)
|
||||
* Fix bug in `siblings` (@jugglinmike)
|
||||
* Correct the implementation `filter` and `is` (@jugglinmike)
|
||||
* add .data() function (@andi-neck)
|
||||
* add .css() (@yields)
|
||||
* Implements contents() (@jlep)
|
||||
|
||||
0.12.2 / 2013-09-04
|
||||
==================
|
||||
|
||||
* Correct implementation of `$.fn.text` (@jugglinmike)
|
||||
* Refactor Cheerio array creation (@jugglinmike)
|
||||
* Extend manipulation methods to accept Arrays (@jugglinmike)
|
||||
* support .attr(attributeName, function(index, attr)) (@xiaohwan)
|
||||
|
||||
0.12.1 / 2013-07-30
|
||||
==================
|
||||
|
||||
* Correct behavior of `Cheerio#parents` (@jugglinmike)
|
||||
* Double quotes inside attributes kills HTML (@khoomeister)
|
||||
* Making next({}) and prev({}) return empty object (@absentTelegraph)
|
||||
* Implement $.parseHTML (@jugglinmike)
|
||||
* Correct bug in jQuery.fn.closest (@jugglinmike)
|
||||
* Correct behavior of $.fn.val on 'option' elements (@jugglinmike)
|
||||
|
||||
0.12.0 / 2013-06-09
|
||||
===================
|
||||
|
||||
* Breaking Change: Changed context from parent to the actual passed one (@swissmanu)
|
||||
* Fixed: jquery checkbox val behavior (@jhubble)
|
||||
* Added: output xml with $.xml() (@Maciek416)
|
||||
* Bumped: htmlparser2 to 3.1.1
|
||||
* Fixed: bug in attr(key, val) on empty objects (@farhadi)
|
||||
* Added: prevAll, nextAll (@lessmind)
|
||||
* Fixed: Safety check in parents and closest (@zero21xxx)
|
||||
* Added: .is(sel) (@zero21xxx)
|
||||
|
||||
0.11.0 / 2013-04-22
|
||||
==================
|
||||
|
||||
* Added: .closest() (@jeremy-dentel)
|
||||
* Added: .parents() (@zero21xxx)
|
||||
* Added: .val() (@rschmukler & @leahciMic)
|
||||
* Added: Travis support for node 0.10.0 (@jeremy-dentel)
|
||||
* Fixed: .find() if no selector (@davidchambers)
|
||||
* Fixed: Propagate syntax errors caused by invalid selectors (@davidchambers)
|
||||
|
||||
0.10.8 / 2013-03-11
|
||||
==================
|
||||
|
||||
* Add slice method (SBoudrias)
|
||||
|
||||
0.10.7 / 2013-02-10
|
||||
==================
|
||||
|
||||
* Code & doc cleanup (davidchambers)
|
||||
* Fixed bug in filter (jugglinmike)
|
||||
|
||||
0.10.6 / 2013-01-29
|
||||
==================
|
||||
|
||||
* Added `$.contains(...)` (jugglinmike)
|
||||
* formatting cleanup (davidchambers)
|
||||
* Bug fix for `.children()` (jugglinmike & davidchambers)
|
||||
* Remove global `render` bug (wvl)
|
||||
|
||||
0.10.5 / 2012-12-18
|
||||
===================
|
||||
|
||||
* Fixed botched publish from 0.10.4 - changes should now be present
|
||||
|
||||
0.10.4 / 2012-12-16
|
||||
==================
|
||||
|
||||
* $.find should query descendants only (@jugglinmike)
|
||||
* Tighter underscore dependency
|
||||
|
||||
0.10.3 / 2012-11-18
|
||||
===================
|
||||
|
||||
* fixed outer html bug
|
||||
* Updated documentation for $(...).html() and $.html()
|
||||
|
||||
0.10.2 / 2012-11-17
|
||||
===================
|
||||
|
||||
* Added a toString() method (@bensheldon)
|
||||
* use `_.each` and `_.map` to simplify cheerio namesakes (@davidchambers)
|
||||
* Added filter() with tests and updated readme (@bensheldon & @davidchambers)
|
||||
* Added spaces between attributes rewritten by removeClass (@jos3000)
|
||||
* updated docs to remove reference to size method (@ironchefpython)
|
||||
* removed HTML tidy/pretty print from cheerio
|
||||
|
||||
0.10.1 / 2012-10-04
|
||||
===================
|
||||
|
||||
* Fixed regression, filtering with a context (#106)
|
||||
|
||||
0.10.0 / 2012-09-24
|
||||
===================
|
||||
|
||||
* Greatly simplified and reorganized the library, reducing the loc by 30%
|
||||
* Now supports mocha's test-coverage
|
||||
* Deprecated self-closing tags (HTML5 doesn't require them)
|
||||
* Fixed error thrown in removeClass(...) @robashton
|
||||
|
||||
0.9.2 / 2012-08-10
|
||||
==================
|
||||
|
||||
* added $(...).map(fn)
|
||||
* manipulation: refactor `makeCheerioArray`
|
||||
* make .removeClass() remove *all* occurrences (#64)
|
||||
|
||||
0.9.1 / 2012-08-03
|
||||
==================
|
||||
|
||||
* fixed bug causing options not to make it to the parser
|
||||
|
||||
0.9.0 / 2012-07-24
|
||||
==================
|
||||
|
||||
* Added node 8.x support
|
||||
* Removed node 4.x support
|
||||
* Add html(dom) support (@wvl)
|
||||
* fixed xss vulnerabilities on .attr(), .text(), & .html() (@benatkin, @FB55)
|
||||
* Rewrote tests into javascript, removing coffeescript dependency (@davidchambers)
|
||||
* Tons of cleanup (@davidchambers)
|
||||
|
||||
0.8.3 / 2012-06-12
|
||||
==================
|
||||
|
||||
* Fixed minor package regression (closes #60)
|
||||
|
||||
0.8.2 / 2012-06-11
|
||||
==================
|
||||
|
||||
* Now fails gracefully in cases that involve special chars, which is inline with jQuery (closes #59)
|
||||
* text() now decode special entities (closes #52)
|
||||
* updated travis.yml to test node 4.x
|
||||
|
||||
0.8.1 / 2012-06-02
|
||||
==================
|
||||
|
||||
* fixed regression where if you created an element, it would update the root
|
||||
* compatible with node 4.x (again)
|
||||
|
||||
0.8.0 / 2012-05-27
|
||||
==================
|
||||
|
||||
* Updated CSS parser to use FB55/CSSselect. Cheerio now supports most CSS3 psuedo selectors thanks to @FB55.
|
||||
* ignoreWhitespace now on by default again. See #55 for context.
|
||||
* Changed $(':root') to $.root(), cleaned up $.clone()
|
||||
* Support for .eq(i) thanks to @alexbardas
|
||||
* Removed support for node 0.4.x
|
||||
* Fixed memory leak where package.json was continually loaded
|
||||
* Tons more tests
|
||||
|
||||
0.7.0 / 2012-04-08
|
||||
==================
|
||||
|
||||
* Now testing with node v0.7.7
|
||||
* Added travis-ci integration
|
||||
* Replaced should.js with expect.js. Browser testing to come
|
||||
* Fixed spacing between attributes and their values
|
||||
* Added HTML tidy/pretty print
|
||||
* Exposed node-htmlparser2 parsing options
|
||||
* Revert .replaceWith(...) to be consistent with jQuery
|
||||
|
||||
0.6.2 / 2012-02-12
|
||||
==================
|
||||
|
||||
* Fixed .replaceWith(...) regression
|
||||
|
||||
0.6.1 / 2012-02-12
|
||||
==================
|
||||
|
||||
* Added .first(), .last(), and .clone() commands.
|
||||
* Option to parse using whitespace added to `.load`.
|
||||
* Many bug fixes to make cheerio more aligned with jQuery.
|
||||
* Added $(':root') to select the highest level element.
|
||||
|
||||
Many thanks to the contributors that made this release happen: @ironchefpython and @siddMahen
|
||||
|
||||
0.6.0 / 2012-02-07
|
||||
==================
|
||||
|
||||
* *Important:* `$(...).html()` now returns inner HTML, which is in line with the jQuery spec
|
||||
* `$.html()` returns the full HTML string. `$.html([cheerioObject])` will return the outer(selected element's tag) and inner HTML of that object
|
||||
* Fixed bug that prevented HTML strings with depth (eg. `append('<ul><li><li></ul>')`) from getting `parent`, `next`, `prev` attributes.
|
||||
* Halted [htmlparser2](https://github.com/FB55/node-htmlparser) at v2.2.2 until single attributes bug gets fixed.
|
||||
|
||||
0.5.1 / 2012-02-05
|
||||
==================
|
||||
|
||||
* Fixed minor regression: $(...).text(fn) would fail
|
||||
|
||||
0.5.1 / 2012-02-05
|
||||
==================
|
||||
|
||||
* Fixed regression: HTML pages with comments would fail
|
||||
|
||||
0.5.0 / 2012-02-04
|
||||
==================
|
||||
|
||||
* Transitioned from Coffeescript back to Javascript
|
||||
* Parser now ignores whitespace
|
||||
* Fixed issue with double slashes on self-enclosing tags
|
||||
* Added boolean attributes to html rendering
|
||||
|
||||
0.4.2 / 2012-01-16
|
||||
==================
|
||||
|
||||
* Multiple selectors support: $('.apple, .orange'). Thanks @siddMahen!
|
||||
* Update package.json to always use latest cheerio-soupselect
|
||||
* Fix memory leak in index.js
|
||||
|
||||
0.4.1 / 2011-12-19
|
||||
==================
|
||||
* Minor packaging changes to allow `make test` to work from npm installation
|
||||
|
||||
0.4.0 / 2011-12-19
|
||||
==================
|
||||
|
||||
* Rewrote all unit tests as cheerio transitioned from vows -> mocha
|
||||
* Internally, renderer.render -> render(...), parser.parse -> parse(...)
|
||||
* Append, prepend, html, before, after all work with only text (no tags)
|
||||
* Bugfix: Attributes can now be removed from script and style tags
|
||||
* Added yield as a single tag
|
||||
* Cheerio now compatible with node >=0.4.7
|
||||
|
||||
0.3.2 / 2011-12-1
|
||||
=================
|
||||
|
||||
* Fixed $(...).text(...) to work with "root" element
|
||||
|
||||
0.3.1 / 2011-11-25
|
||||
==================
|
||||
|
||||
* Now relying on cheerio-soupselect instead of node-soupselect
|
||||
* Removed all lingering htmlparser dependencies
|
||||
* parser now returns parent "root" element. Root now never needs to be updated when there is multiple roots. This fixes ongoing issues with before(...), after(...) and other manipulation functions
|
||||
* Added jQuery's $(...).replaceWith(...)
|
||||
|
||||
0.3.0 / 2011-11-19
|
||||
==================
|
||||
|
||||
* Now using htmlparser2 for parsing (2x speed increase, cleaner, actively developed)
|
||||
* Added benchmark directory for future speed tests
|
||||
* $('...').dom() was funky, so it was removed in favor of $('...').get(). $.dom() still works the same.
|
||||
* $.root now correctly static across all instances of $
|
||||
* Added a screencast
|
||||
|
||||
0.2.2 / 2011-11-9
|
||||
=================
|
||||
|
||||
* Traversing will select `<script>` and `<style>` tags (Closes Issue: #8)
|
||||
* .text(string) now working with empty elements (Closes Issue: #7)
|
||||
* Fixed before(...) & after(...) again if there is no parent (Closes Issue: #2)
|
||||
|
||||
0.2.1 / 2011-11-5
|
||||
=================
|
||||
|
||||
* Fixed before(...) & after(...) if there is no parent (Closes Issue: #2)
|
||||
* Comments now rendered correctly (Closes Issue: #5)
|
||||
|
||||
< 0.2.0 / 2011-10-31
|
||||
====================
|
||||
|
||||
* Initial release (untracked development)
|
||||
1093
node_modules/cheerio/Readme.md
generated
vendored
Normal file
1093
node_modules/cheerio/Readme.md
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
11
node_modules/cheerio/index.js
generated
vendored
Normal file
11
node_modules/cheerio/index.js
generated
vendored
Normal file
@@ -0,0 +1,11 @@
|
||||
/**
|
||||
* Export cheerio (with )
|
||||
*/
|
||||
|
||||
exports = module.exports = require('./lib/cheerio');
|
||||
|
||||
/*
|
||||
Export the version
|
||||
*/
|
||||
|
||||
exports.version = require('./package.json').version;
|
||||
495
node_modules/cheerio/lib/api/attributes.js
generated
vendored
Normal file
495
node_modules/cheerio/lib/api/attributes.js
generated
vendored
Normal file
@@ -0,0 +1,495 @@
|
||||
var $ = require('../static'),
|
||||
utils = require('../utils'),
|
||||
isTag = utils.isTag,
|
||||
domEach = utils.domEach,
|
||||
hasOwn = Object.prototype.hasOwnProperty,
|
||||
camelCase = utils.camelCase,
|
||||
cssCase = utils.cssCase,
|
||||
rspace = /\s+/,
|
||||
dataAttrPrefix = 'data-',
|
||||
_ = {
|
||||
forEach: require('lodash.foreach'),
|
||||
extend: require('lodash.assignin'),
|
||||
some: require('lodash.some')
|
||||
},
|
||||
|
||||
// Lookup table for coercing string data-* attributes to their corresponding
|
||||
// JavaScript primitives
|
||||
primitives = {
|
||||
null: null,
|
||||
true: true,
|
||||
false: false
|
||||
},
|
||||
|
||||
// Attributes that are booleans
|
||||
rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
|
||||
// Matches strings that look like JSON objects or arrays
|
||||
rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
|
||||
|
||||
|
||||
var getAttr = function(elem, name) {
|
||||
if (!elem || !isTag(elem)) return;
|
||||
|
||||
if (!elem.attribs) {
|
||||
elem.attribs = {};
|
||||
}
|
||||
|
||||
// Return the entire attribs object if no attribute specified
|
||||
if (!name) {
|
||||
return elem.attribs;
|
||||
}
|
||||
|
||||
if (hasOwn.call(elem.attribs, name)) {
|
||||
// Get the (decoded) attribute
|
||||
return rboolean.test(name) ? name : elem.attribs[name];
|
||||
}
|
||||
|
||||
// Mimic the DOM and return text content as value for `option's`
|
||||
if (elem.name === 'option' && name === 'value') {
|
||||
return $.text(elem.children);
|
||||
}
|
||||
|
||||
// Mimic DOM with default value for radios/checkboxes
|
||||
if (elem.name === 'input' &&
|
||||
(elem.attribs.type === 'radio' || elem.attribs.type === 'checkbox') &&
|
||||
name === 'value') {
|
||||
return 'on';
|
||||
}
|
||||
};
|
||||
|
||||
var setAttr = function(el, name, value) {
|
||||
|
||||
if (value === null) {
|
||||
removeAttribute(el, name);
|
||||
} else {
|
||||
el.attribs[name] = value+'';
|
||||
}
|
||||
};
|
||||
|
||||
exports.attr = function(name, value) {
|
||||
// Set the value (with attr map support)
|
||||
if (typeof name === 'object' || value !== undefined) {
|
||||
if (typeof value === 'function') {
|
||||
return domEach(this, function(i, el) {
|
||||
setAttr(el, name, value.call(el, i, el.attribs[name]));
|
||||
});
|
||||
}
|
||||
return domEach(this, function(i, el) {
|
||||
if (!isTag(el)) return;
|
||||
|
||||
if (typeof name === 'object') {
|
||||
_.forEach(name, function(value, name) {
|
||||
setAttr(el, name, value);
|
||||
});
|
||||
} else {
|
||||
setAttr(el, name, value);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return getAttr(this[0], name);
|
||||
};
|
||||
|
||||
var getProp = function (el, name) {
|
||||
if (!el || !isTag(el)) return;
|
||||
|
||||
return el.hasOwnProperty(name)
|
||||
? el[name]
|
||||
: rboolean.test(name)
|
||||
? getAttr(el, name) !== undefined
|
||||
: getAttr(el, name);
|
||||
};
|
||||
|
||||
var setProp = function (el, name, value) {
|
||||
el[name] = rboolean.test(name) ? !!value : value;
|
||||
};
|
||||
|
||||
exports.prop = function (name, value) {
|
||||
var i = 0,
|
||||
property;
|
||||
|
||||
if (typeof name === 'string' && value === undefined) {
|
||||
|
||||
switch (name) {
|
||||
case 'style':
|
||||
property = this.css();
|
||||
|
||||
_.forEach(property, function (v, p) {
|
||||
property[i++] = p;
|
||||
});
|
||||
|
||||
property.length = i;
|
||||
|
||||
break;
|
||||
case 'tagName':
|
||||
case 'nodeName':
|
||||
property = this[0].name.toUpperCase();
|
||||
break;
|
||||
default:
|
||||
property = getProp(this[0], name);
|
||||
}
|
||||
|
||||
return property;
|
||||
}
|
||||
|
||||
if (typeof name === 'object' || value !== undefined) {
|
||||
|
||||
if (typeof value === 'function') {
|
||||
return domEach(this, function(i, el) {
|
||||
setProp(el, name, value.call(el, i, getProp(el, name)));
|
||||
});
|
||||
}
|
||||
|
||||
return domEach(this, function(i, el) {
|
||||
if (!isTag(el)) return;
|
||||
|
||||
if (typeof name === 'object') {
|
||||
|
||||
_.forEach(name, function(val, name) {
|
||||
setProp(el, name, val);
|
||||
});
|
||||
|
||||
} else {
|
||||
setProp(el, name, value);
|
||||
}
|
||||
});
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
var setData = function(el, name, value) {
|
||||
if (!el.data) {
|
||||
el.data = {};
|
||||
}
|
||||
|
||||
if (typeof name === 'object') return _.extend(el.data, name);
|
||||
if (typeof name === 'string' && value !== undefined) {
|
||||
el.data[name] = value;
|
||||
} else if (typeof name === 'object') {
|
||||
_.extend(el.data, name);
|
||||
}
|
||||
};
|
||||
|
||||
// Read the specified attribute from the equivalent HTML5 `data-*` attribute,
|
||||
// and (if present) cache the value in the node's internal data store. If no
|
||||
// attribute name is specified, read *all* HTML5 `data-*` attributes in this
|
||||
// manner.
|
||||
var readData = function(el, name) {
|
||||
var readAll = arguments.length === 1;
|
||||
var domNames, domName, jsNames, jsName, value, idx, length;
|
||||
|
||||
if (readAll) {
|
||||
domNames = Object.keys(el.attribs).filter(function(attrName) {
|
||||
return attrName.slice(0, dataAttrPrefix.length) === dataAttrPrefix;
|
||||
});
|
||||
jsNames = domNames.map(function(domName) {
|
||||
return camelCase(domName.slice(dataAttrPrefix.length));
|
||||
});
|
||||
} else {
|
||||
domNames = [dataAttrPrefix + cssCase(name)];
|
||||
jsNames = [name];
|
||||
}
|
||||
|
||||
for (idx = 0, length = domNames.length; idx < length; ++idx) {
|
||||
domName = domNames[idx];
|
||||
jsName = jsNames[idx];
|
||||
if (hasOwn.call(el.attribs, domName)) {
|
||||
value = el.attribs[domName];
|
||||
|
||||
if (hasOwn.call(primitives, value)) {
|
||||
value = primitives[value];
|
||||
} else if (value === String(Number(value))) {
|
||||
value = Number(value);
|
||||
} else if (rbrace.test(value)) {
|
||||
try {
|
||||
value = JSON.parse(value);
|
||||
} catch(e){ }
|
||||
}
|
||||
|
||||
el.data[jsName] = value;
|
||||
}
|
||||
}
|
||||
|
||||
return readAll ? el.data : value;
|
||||
};
|
||||
|
||||
exports.data = function(name, value) {
|
||||
var elem = this[0];
|
||||
|
||||
if (!elem || !isTag(elem)) return;
|
||||
|
||||
if (!elem.data) {
|
||||
elem.data = {};
|
||||
}
|
||||
|
||||
// Return the entire data object if no data specified
|
||||
if (!name) {
|
||||
return readData(elem);
|
||||
}
|
||||
|
||||
// Set the value (with attr map support)
|
||||
if (typeof name === 'object' || value !== undefined) {
|
||||
domEach(this, function(i, el) {
|
||||
setData(el, name, value);
|
||||
});
|
||||
return this;
|
||||
} else if (hasOwn.call(elem.data, name)) {
|
||||
return elem.data[name];
|
||||
}
|
||||
|
||||
return readData(elem, name);
|
||||
};
|
||||
|
||||
/**
|
||||
* Get the value of an element
|
||||
*/
|
||||
|
||||
exports.val = function(value) {
|
||||
var querying = arguments.length === 0,
|
||||
element = this[0];
|
||||
|
||||
if(!element) return;
|
||||
|
||||
switch (element.name) {
|
||||
case 'textarea':
|
||||
return this.text(value);
|
||||
case 'input':
|
||||
switch (this.attr('type')) {
|
||||
case 'radio':
|
||||
if (querying) {
|
||||
return this.attr('value');
|
||||
} else {
|
||||
this.attr('value', value);
|
||||
return this;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return this.attr('value', value);
|
||||
}
|
||||
return;
|
||||
case 'select':
|
||||
var option = this.find('option:selected'),
|
||||
returnValue;
|
||||
if (option === undefined) return undefined;
|
||||
if (!querying) {
|
||||
if (!this.attr().hasOwnProperty('multiple') && typeof value == 'object') {
|
||||
return this;
|
||||
}
|
||||
if (typeof value != 'object') {
|
||||
value = [value];
|
||||
}
|
||||
this.find('option').removeAttr('selected');
|
||||
for (var i = 0; i < value.length; i++) {
|
||||
this.find('option[value="' + value[i] + '"]').attr('selected', '');
|
||||
}
|
||||
return this;
|
||||
}
|
||||
returnValue = option.attr('value');
|
||||
if (this.attr().hasOwnProperty('multiple')) {
|
||||
returnValue = [];
|
||||
domEach(option, function(i, el) {
|
||||
returnValue.push(getAttr(el, 'value'));
|
||||
});
|
||||
}
|
||||
return returnValue;
|
||||
case 'option':
|
||||
if (!querying) {
|
||||
this.attr('value', value);
|
||||
return this;
|
||||
}
|
||||
return this.attr('value');
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove an attribute
|
||||
*/
|
||||
|
||||
var removeAttribute = function(elem, name) {
|
||||
if (!elem.attribs || !hasOwn.call(elem.attribs, name))
|
||||
return;
|
||||
|
||||
delete elem.attribs[name];
|
||||
};
|
||||
|
||||
|
||||
exports.removeAttr = function(name) {
|
||||
domEach(this, function(i, elem) {
|
||||
removeAttribute(elem, name);
|
||||
});
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.hasClass = function(className) {
|
||||
return _.some(this, function(elem) {
|
||||
var attrs = elem.attribs,
|
||||
clazz = attrs && attrs['class'],
|
||||
idx = -1,
|
||||
end;
|
||||
|
||||
if (clazz) {
|
||||
while ((idx = clazz.indexOf(className, idx+1)) > -1) {
|
||||
end = idx + className.length;
|
||||
|
||||
if ((idx === 0 || rspace.test(clazz[idx-1]))
|
||||
&& (end === clazz.length || rspace.test(clazz[end]))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
exports.addClass = function(value) {
|
||||
// Support functions
|
||||
if (typeof value === 'function') {
|
||||
return domEach(this, function(i, el) {
|
||||
var className = el.attribs['class'] || '';
|
||||
exports.addClass.call([el], value.call(el, i, className));
|
||||
});
|
||||
}
|
||||
|
||||
// Return if no value or not a string or function
|
||||
if (!value || typeof value !== 'string') return this;
|
||||
|
||||
var classNames = value.split(rspace),
|
||||
numElements = this.length;
|
||||
|
||||
|
||||
for (var i = 0; i < numElements; i++) {
|
||||
// If selected element isn't a tag, move on
|
||||
if (!isTag(this[i])) continue;
|
||||
|
||||
// If we don't already have classes
|
||||
var className = getAttr(this[i], 'class'),
|
||||
numClasses,
|
||||
setClass;
|
||||
|
||||
if (!className) {
|
||||
setAttr(this[i], 'class', classNames.join(' ').trim());
|
||||
} else {
|
||||
setClass = ' ' + className + ' ';
|
||||
numClasses = classNames.length;
|
||||
|
||||
// Check if class already exists
|
||||
for (var j = 0; j < numClasses; j++) {
|
||||
var appendClass = classNames[j] + ' ';
|
||||
if (setClass.indexOf(' ' + appendClass) < 0)
|
||||
setClass += appendClass;
|
||||
}
|
||||
|
||||
setAttr(this[i], 'class', setClass.trim());
|
||||
}
|
||||
}
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
var splitClass = function(className) {
|
||||
return className ? className.trim().split(rspace) : [];
|
||||
};
|
||||
|
||||
exports.removeClass = function(value) {
|
||||
var classes,
|
||||
numClasses,
|
||||
removeAll;
|
||||
|
||||
// Handle if value is a function
|
||||
if (typeof value === 'function') {
|
||||
return domEach(this, function(i, el) {
|
||||
exports.removeClass.call(
|
||||
[el], value.call(el, i, el.attribs['class'] || '')
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
classes = splitClass(value);
|
||||
numClasses = classes.length;
|
||||
removeAll = arguments.length === 0;
|
||||
|
||||
return domEach(this, function(i, el) {
|
||||
if (!isTag(el)) return;
|
||||
|
||||
if (removeAll) {
|
||||
// Short circuit the remove all case as this is the nice one
|
||||
el.attribs.class = '';
|
||||
} else {
|
||||
var elClasses = splitClass(el.attribs.class),
|
||||
index,
|
||||
changed;
|
||||
|
||||
for (var j = 0; j < numClasses; j++) {
|
||||
index = elClasses.indexOf(classes[j]);
|
||||
|
||||
if (index >= 0) {
|
||||
elClasses.splice(index, 1);
|
||||
changed = true;
|
||||
|
||||
// We have to do another pass to ensure that there are not duplicate
|
||||
// classes listed
|
||||
j--;
|
||||
}
|
||||
}
|
||||
if (changed) {
|
||||
el.attribs.class = elClasses.join(' ');
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
exports.toggleClass = function(value, stateVal) {
|
||||
// Support functions
|
||||
if (typeof value === 'function') {
|
||||
return domEach(this, function(i, el) {
|
||||
exports.toggleClass.call(
|
||||
[el],
|
||||
value.call(el, i, el.attribs['class'] || '', stateVal),
|
||||
stateVal
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
// Return if no value or not a string or function
|
||||
if (!value || typeof value !== 'string') return this;
|
||||
|
||||
var classNames = value.split(rspace),
|
||||
numClasses = classNames.length,
|
||||
state = typeof stateVal === 'boolean' ? stateVal ? 1 : -1 : 0,
|
||||
numElements = this.length,
|
||||
elementClasses,
|
||||
index;
|
||||
|
||||
for (var i = 0; i < numElements; i++) {
|
||||
// If selected element isn't a tag, move on
|
||||
if (!isTag(this[i])) continue;
|
||||
|
||||
elementClasses = splitClass(this[i].attribs.class);
|
||||
|
||||
// Check if class already exists
|
||||
for (var j = 0; j < numClasses; j++) {
|
||||
// Check if the class name is currently defined
|
||||
index = elementClasses.indexOf(classNames[j]);
|
||||
|
||||
// Add if stateValue === true or we are toggling and there is no value
|
||||
if (state >= 0 && index < 0) {
|
||||
elementClasses.push(classNames[j]);
|
||||
} else if (state <= 0 && index >= 0) {
|
||||
// Otherwise remove but only if the item exists
|
||||
elementClasses.splice(index, 1);
|
||||
}
|
||||
}
|
||||
|
||||
this[i].attribs.class = elementClasses.join(' ');
|
||||
}
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.is = function (selector) {
|
||||
if (selector) {
|
||||
return this.filter(selector).length > 0;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
121
node_modules/cheerio/lib/api/css.js
generated
vendored
Normal file
121
node_modules/cheerio/lib/api/css.js
generated
vendored
Normal file
@@ -0,0 +1,121 @@
|
||||
var domEach = require('../utils').domEach,
|
||||
_ = {
|
||||
pick: require('lodash.pick'),
|
||||
};
|
||||
|
||||
var toString = Object.prototype.toString;
|
||||
|
||||
/**
|
||||
* Set / Get css.
|
||||
*
|
||||
* @param {String|Object} prop
|
||||
* @param {String} val
|
||||
* @return {self}
|
||||
* @api public
|
||||
*/
|
||||
|
||||
exports.css = function(prop, val) {
|
||||
if (arguments.length === 2 ||
|
||||
// When `prop` is a "plain" object
|
||||
(toString.call(prop) === '[object Object]')) {
|
||||
return domEach(this, function(idx, el) {
|
||||
setCss(el, prop, val, idx);
|
||||
});
|
||||
} else {
|
||||
return getCss(this[0], prop);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Set styles of all elements.
|
||||
*
|
||||
* @param {String|Object} prop
|
||||
* @param {String} val
|
||||
* @param {Number} idx - optional index within the selection
|
||||
* @return {self}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
function setCss(el, prop, val, idx) {
|
||||
if ('string' == typeof prop) {
|
||||
var styles = getCss(el);
|
||||
if (typeof val === 'function') {
|
||||
val = val.call(el, idx, styles[prop]);
|
||||
}
|
||||
|
||||
if (val === '') {
|
||||
delete styles[prop];
|
||||
} else if (val != null) {
|
||||
styles[prop] = val;
|
||||
}
|
||||
|
||||
el.attribs.style = stringify(styles);
|
||||
} else if ('object' == typeof prop) {
|
||||
Object.keys(prop).forEach(function(k){
|
||||
setCss(el, k, prop[k]);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parsed styles of the first element.
|
||||
*
|
||||
* @param {String} prop
|
||||
* @return {Object}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
function getCss(el, prop) {
|
||||
var styles = parse(el.attribs.style);
|
||||
if (typeof prop === 'string') {
|
||||
return styles[prop];
|
||||
} else if (Array.isArray(prop)) {
|
||||
return _.pick(styles, prop);
|
||||
} else {
|
||||
return styles;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stringify `obj` to styles.
|
||||
*
|
||||
* @param {Object} obj
|
||||
* @return {Object}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
function stringify(obj) {
|
||||
return Object.keys(obj || {})
|
||||
.reduce(function(str, prop){
|
||||
return str += ''
|
||||
+ (str ? ' ' : '')
|
||||
+ prop
|
||||
+ ': '
|
||||
+ obj[prop]
|
||||
+ ';';
|
||||
}, '');
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse `styles`.
|
||||
*
|
||||
* @param {String} styles
|
||||
* @return {Object}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
function parse(styles) {
|
||||
styles = (styles || '').trim();
|
||||
|
||||
if (!styles) return {};
|
||||
|
||||
return styles
|
||||
.split(';')
|
||||
.reduce(function(obj, str){
|
||||
var n = str.indexOf(':');
|
||||
// skip if there is no :, or if it is the first/last character
|
||||
if (n < 1 || n === str.length-1) return obj;
|
||||
obj[str.slice(0,n).trim()] = str.slice(n+1).trim();
|
||||
return obj;
|
||||
}, {});
|
||||
}
|
||||
65
node_modules/cheerio/lib/api/forms.js
generated
vendored
Normal file
65
node_modules/cheerio/lib/api/forms.js
generated
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
// https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js
|
||||
// https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js
|
||||
var submittableSelector = 'input,select,textarea,keygen',
|
||||
r20 = /%20/g,
|
||||
rCRLF = /\r?\n/g,
|
||||
_ = {
|
||||
map: require('lodash.map')
|
||||
};
|
||||
|
||||
exports.serialize = function() {
|
||||
// Convert form elements into name/value objects
|
||||
var arr = this.serializeArray();
|
||||
|
||||
// Serialize each element into a key/value string
|
||||
var retArr = _.map(arr, function(data) {
|
||||
return encodeURIComponent(data.name) + '=' + encodeURIComponent(data.value);
|
||||
});
|
||||
|
||||
// Return the resulting serialization
|
||||
return retArr.join('&').replace(r20, '+');
|
||||
};
|
||||
|
||||
exports.serializeArray = function() {
|
||||
// Resolve all form elements from either forms or collections of form elements
|
||||
var Cheerio = this.constructor;
|
||||
return this.map(function() {
|
||||
var elem = this;
|
||||
var $elem = Cheerio(elem);
|
||||
if (elem.name === 'form') {
|
||||
return $elem.find(submittableSelector).toArray();
|
||||
} else {
|
||||
return $elem.filter(submittableSelector).toArray();
|
||||
}
|
||||
}).filter(
|
||||
// Verify elements have a name (`attr.name`) and are not disabled (`:disabled`)
|
||||
'[name!=""]:not(:disabled)'
|
||||
// and cannot be clicked (`[type=submit]`) or are used in `x-www-form-urlencoded` (`[type=file]`)
|
||||
+ ':not(:submit, :button, :image, :reset, :file)'
|
||||
// and are either checked/don't have a checkable state
|
||||
+ ':matches([checked], :not(:checkbox, :radio))'
|
||||
// Convert each of the elements to its value(s)
|
||||
).map(function(i, elem) {
|
||||
var $elem = Cheerio(elem);
|
||||
var name = $elem.attr('name');
|
||||
var val = $elem.val();
|
||||
|
||||
// If there is no value set (e.g. `undefined`, `null`), then return nothing
|
||||
if (val == null) {
|
||||
return null;
|
||||
} else {
|
||||
// If we have an array of values (e.g. `<select multiple>`), return an array of key/value pairs
|
||||
if (Array.isArray(val)) {
|
||||
return _.map(val, function(val) {
|
||||
// We trim replace any line endings (e.g. `\r` or `\r\n` with `\r\n`) to guarantee consistency across platforms
|
||||
// These can occur inside of `<textarea>'s`
|
||||
return {name: name, value: val.replace( rCRLF, '\r\n' )};
|
||||
});
|
||||
// Otherwise (e.g. `<input type="text">`, return only one key/value pair
|
||||
} else {
|
||||
return {name: name, value: val.replace( rCRLF, '\r\n' )};
|
||||
}
|
||||
}
|
||||
// Convert our result to an array
|
||||
}).get();
|
||||
};
|
||||
425
node_modules/cheerio/lib/api/manipulation.js
generated
vendored
Normal file
425
node_modules/cheerio/lib/api/manipulation.js
generated
vendored
Normal file
@@ -0,0 +1,425 @@
|
||||
var parse = require('../parse'),
|
||||
$ = require('../static'),
|
||||
updateDOM = parse.update,
|
||||
evaluate = parse.evaluate,
|
||||
utils = require('../utils'),
|
||||
domEach = utils.domEach,
|
||||
cloneDom = utils.cloneDom,
|
||||
isHtml = utils.isHtml,
|
||||
slice = Array.prototype.slice,
|
||||
_ = {
|
||||
flatten: require('lodash.flatten'),
|
||||
bind: require('lodash.bind'),
|
||||
forEach: require('lodash.foreach')
|
||||
};
|
||||
|
||||
// Create an array of nodes, recursing into arrays and parsing strings if
|
||||
// necessary
|
||||
exports._makeDomArray = function makeDomArray(elem, clone) {
|
||||
if (elem == null) {
|
||||
return [];
|
||||
} else if (elem.cheerio) {
|
||||
return clone ? cloneDom(elem.get(), elem.options) : elem.get();
|
||||
} else if (Array.isArray(elem)) {
|
||||
return _.flatten(elem.map(function(el) {
|
||||
return this._makeDomArray(el, clone);
|
||||
}, this));
|
||||
} else if (typeof elem === 'string') {
|
||||
return evaluate(elem, this.options);
|
||||
} else {
|
||||
return clone ? cloneDom([elem]) : [elem];
|
||||
}
|
||||
};
|
||||
|
||||
var _insert = function(concatenator) {
|
||||
return function() {
|
||||
var elems = slice.call(arguments),
|
||||
lastIdx = this.length - 1;
|
||||
|
||||
return domEach(this, function(i, el) {
|
||||
var dom, domSrc;
|
||||
|
||||
if (typeof elems[0] === 'function') {
|
||||
domSrc = elems[0].call(el, i, $.html(el.children));
|
||||
} else {
|
||||
domSrc = elems;
|
||||
}
|
||||
|
||||
dom = this._makeDomArray(domSrc, i < lastIdx);
|
||||
concatenator(dom, el.children, el);
|
||||
});
|
||||
};
|
||||
};
|
||||
|
||||
/*
|
||||
* Modify an array in-place, removing some number of elements and adding new
|
||||
* elements directly following them.
|
||||
*
|
||||
* @param {Array} array Target array to splice.
|
||||
* @param {Number} spliceIdx Index at which to begin changing the array.
|
||||
* @param {Number} spliceCount Number of elements to remove from the array.
|
||||
* @param {Array} newElems Elements to insert into the array.
|
||||
*
|
||||
* @api private
|
||||
*/
|
||||
var uniqueSplice = function(array, spliceIdx, spliceCount, newElems, parent) {
|
||||
var spliceArgs = [spliceIdx, spliceCount].concat(newElems),
|
||||
prev = array[spliceIdx - 1] || null,
|
||||
next = array[spliceIdx] || null;
|
||||
var idx, len, prevIdx, node, oldParent;
|
||||
|
||||
// Before splicing in new elements, ensure they do not already appear in the
|
||||
// current array.
|
||||
for (idx = 0, len = newElems.length; idx < len; ++idx) {
|
||||
node = newElems[idx];
|
||||
oldParent = node.parent || node.root;
|
||||
prevIdx = oldParent && oldParent.children.indexOf(newElems[idx]);
|
||||
|
||||
if (oldParent && prevIdx > -1) {
|
||||
oldParent.children.splice(prevIdx, 1);
|
||||
if (parent === oldParent && spliceIdx > prevIdx) {
|
||||
spliceArgs[0]--;
|
||||
}
|
||||
}
|
||||
|
||||
node.root = null;
|
||||
node.parent = parent;
|
||||
|
||||
if (node.prev) {
|
||||
node.prev.next = node.next || null;
|
||||
}
|
||||
|
||||
if (node.next) {
|
||||
node.next.prev = node.prev || null;
|
||||
}
|
||||
|
||||
node.prev = newElems[idx - 1] || prev;
|
||||
node.next = newElems[idx + 1] || next;
|
||||
}
|
||||
|
||||
if (prev) {
|
||||
prev.next = newElems[0];
|
||||
}
|
||||
if (next) {
|
||||
next.prev = newElems[newElems.length - 1];
|
||||
}
|
||||
return array.splice.apply(array, spliceArgs);
|
||||
};
|
||||
|
||||
exports.appendTo = function(target) {
|
||||
if (!target.cheerio) {
|
||||
target = this.constructor.call(this.constructor, target, null, this._originalRoot);
|
||||
}
|
||||
|
||||
target.append(this);
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.prependTo = function(target) {
|
||||
if (!target.cheerio) {
|
||||
target = this.constructor.call(this.constructor, target, null, this._originalRoot);
|
||||
}
|
||||
|
||||
target.prepend(this);
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.append = _insert(function(dom, children, parent) {
|
||||
uniqueSplice(children, children.length, 0, dom, parent);
|
||||
});
|
||||
|
||||
exports.prepend = _insert(function(dom, children, parent) {
|
||||
uniqueSplice(children, 0, 0, dom, parent);
|
||||
});
|
||||
|
||||
exports.wrap = function(wrapper) {
|
||||
var wrapperFn = typeof wrapper === 'function' && wrapper,
|
||||
lastIdx = this.length - 1;
|
||||
|
||||
_.forEach(this, _.bind(function(el, i) {
|
||||
var parent = el.parent || el.root,
|
||||
siblings = parent.children,
|
||||
dom, index;
|
||||
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (wrapperFn) {
|
||||
wrapper = wrapperFn.call(el, i);
|
||||
}
|
||||
|
||||
if (typeof wrapper === 'string' && !isHtml(wrapper)) {
|
||||
wrapper = this.parents().last().find(wrapper).clone();
|
||||
}
|
||||
|
||||
dom = this._makeDomArray(wrapper, i < lastIdx).slice(0, 1);
|
||||
index = siblings.indexOf(el);
|
||||
|
||||
updateDOM([el], dom[0]);
|
||||
// The previous operation removed the current element from the `siblings`
|
||||
// array, so the `dom` array can be inserted without removing any
|
||||
// additional elements.
|
||||
uniqueSplice(siblings, index, 0, dom, parent);
|
||||
}, this));
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.after = function() {
|
||||
var elems = slice.call(arguments),
|
||||
lastIdx = this.length - 1;
|
||||
|
||||
domEach(this, function(i, el) {
|
||||
var parent = el.parent || el.root;
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
var siblings = parent.children,
|
||||
index = siblings.indexOf(el),
|
||||
domSrc, dom;
|
||||
|
||||
// If not found, move on
|
||||
if (index < 0) return;
|
||||
|
||||
if (typeof elems[0] === 'function') {
|
||||
domSrc = elems[0].call(el, i, $.html(el.children));
|
||||
} else {
|
||||
domSrc = elems;
|
||||
}
|
||||
dom = this._makeDomArray(domSrc, i < lastIdx);
|
||||
|
||||
// Add element after `this` element
|
||||
uniqueSplice(siblings, index + 1, 0, dom, parent);
|
||||
});
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.insertAfter = function(target) {
|
||||
var clones = [],
|
||||
self = this;
|
||||
if (typeof target === 'string') {
|
||||
target = this.constructor.call(this.constructor, target, null, this._originalRoot);
|
||||
}
|
||||
target = this._makeDomArray(target);
|
||||
self.remove();
|
||||
domEach(target, function(i, el) {
|
||||
var clonedSelf = self._makeDomArray(self.clone());
|
||||
var parent = el.parent || el.root;
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
var siblings = parent.children,
|
||||
index = siblings.indexOf(el);
|
||||
|
||||
// If not found, move on
|
||||
if (index < 0) return;
|
||||
|
||||
// Add cloned `this` element(s) after target element
|
||||
uniqueSplice(siblings, index + 1, 0, clonedSelf, parent);
|
||||
clones.push(clonedSelf);
|
||||
});
|
||||
return this.constructor.call(this.constructor, this._makeDomArray(clones));
|
||||
};
|
||||
|
||||
exports.before = function() {
|
||||
var elems = slice.call(arguments),
|
||||
lastIdx = this.length - 1;
|
||||
|
||||
domEach(this, function(i, el) {
|
||||
var parent = el.parent || el.root;
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
var siblings = parent.children,
|
||||
index = siblings.indexOf(el),
|
||||
domSrc, dom;
|
||||
|
||||
// If not found, move on
|
||||
if (index < 0) return;
|
||||
|
||||
if (typeof elems[0] === 'function') {
|
||||
domSrc = elems[0].call(el, i, $.html(el.children));
|
||||
} else {
|
||||
domSrc = elems;
|
||||
}
|
||||
|
||||
dom = this._makeDomArray(domSrc, i < lastIdx);
|
||||
|
||||
// Add element before `el` element
|
||||
uniqueSplice(siblings, index, 0, dom, parent);
|
||||
});
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.insertBefore = function(target) {
|
||||
var clones = [],
|
||||
self = this;
|
||||
if (typeof target === 'string') {
|
||||
target = this.constructor.call(this.constructor, target, null, this._originalRoot);
|
||||
}
|
||||
target = this._makeDomArray(target);
|
||||
self.remove();
|
||||
domEach(target, function(i, el) {
|
||||
var clonedSelf = self._makeDomArray(self.clone());
|
||||
var parent = el.parent || el.root;
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
var siblings = parent.children,
|
||||
index = siblings.indexOf(el);
|
||||
|
||||
// If not found, move on
|
||||
if (index < 0) return;
|
||||
|
||||
// Add cloned `this` element(s) after target element
|
||||
uniqueSplice(siblings, index, 0, clonedSelf, parent);
|
||||
clones.push(clonedSelf);
|
||||
});
|
||||
return this.constructor.call(this.constructor, this._makeDomArray(clones));
|
||||
};
|
||||
|
||||
/*
|
||||
remove([selector])
|
||||
*/
|
||||
exports.remove = function(selector) {
|
||||
var elems = this;
|
||||
|
||||
// Filter if we have selector
|
||||
if (selector)
|
||||
elems = elems.filter(selector);
|
||||
|
||||
domEach(elems, function(i, el) {
|
||||
var parent = el.parent || el.root;
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
var siblings = parent.children,
|
||||
index = siblings.indexOf(el);
|
||||
|
||||
if (index < 0) return;
|
||||
|
||||
siblings.splice(index, 1);
|
||||
if (el.prev) {
|
||||
el.prev.next = el.next;
|
||||
}
|
||||
if (el.next) {
|
||||
el.next.prev = el.prev;
|
||||
}
|
||||
el.prev = el.next = el.parent = el.root = null;
|
||||
});
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.replaceWith = function(content) {
|
||||
var self = this;
|
||||
|
||||
domEach(this, function(i, el) {
|
||||
var parent = el.parent || el.root;
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
var siblings = parent.children,
|
||||
dom = self._makeDomArray(typeof content === 'function' ? content.call(el, i, el) : content),
|
||||
index;
|
||||
|
||||
// In the case that `dom` contains nodes that already exist in other
|
||||
// structures, ensure those nodes are properly removed.
|
||||
updateDOM(dom, null);
|
||||
|
||||
index = siblings.indexOf(el);
|
||||
|
||||
// Completely remove old element
|
||||
uniqueSplice(siblings, index, 1, dom, parent);
|
||||
el.parent = el.prev = el.next = el.root = null;
|
||||
});
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.empty = function() {
|
||||
domEach(this, function(i, el) {
|
||||
_.forEach(el.children, function(el) {
|
||||
el.next = el.prev = el.parent = null;
|
||||
});
|
||||
|
||||
el.children.length = 0;
|
||||
});
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Set/Get the HTML
|
||||
*/
|
||||
exports.html = function(str) {
|
||||
if (str === undefined) {
|
||||
if (!this[0] || !this[0].children) return null;
|
||||
return $.html(this[0].children, this.options);
|
||||
}
|
||||
|
||||
var opts = this.options;
|
||||
|
||||
domEach(this, function(i, el) {
|
||||
_.forEach(el.children, function(el) {
|
||||
el.next = el.prev = el.parent = null;
|
||||
});
|
||||
|
||||
var content = str.cheerio ? str.clone().get() : evaluate('' + str, opts);
|
||||
|
||||
updateDOM(content, el);
|
||||
});
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.toString = function() {
|
||||
return $.html(this, this.options);
|
||||
};
|
||||
|
||||
exports.text = function(str) {
|
||||
// If `str` is undefined, act as a "getter"
|
||||
if (str === undefined) {
|
||||
return $.text(this);
|
||||
} else if (typeof str === 'function') {
|
||||
// Function support
|
||||
return domEach(this, function(i, el) {
|
||||
var $el = [el];
|
||||
return exports.text.call($el, str.call(el, i, $.text($el)));
|
||||
});
|
||||
}
|
||||
|
||||
// Append text node to each selected elements
|
||||
domEach(this, function(i, el) {
|
||||
_.forEach(el.children, function(el) {
|
||||
el.next = el.prev = el.parent = null;
|
||||
});
|
||||
|
||||
var elem = {
|
||||
data: '' + str,
|
||||
type: 'text',
|
||||
parent: el,
|
||||
prev: null,
|
||||
next: null,
|
||||
children: []
|
||||
};
|
||||
|
||||
updateDOM(elem, el);
|
||||
});
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.clone = function() {
|
||||
return this._make(cloneDom(this.get(), this.options));
|
||||
};
|
||||
429
node_modules/cheerio/lib/api/traversing.js
generated
vendored
Normal file
429
node_modules/cheerio/lib/api/traversing.js
generated
vendored
Normal file
@@ -0,0 +1,429 @@
|
||||
var select = require('css-select'),
|
||||
utils = require('../utils'),
|
||||
domEach = utils.domEach,
|
||||
uniqueSort = require('htmlparser2').DomUtils.uniqueSort,
|
||||
isTag = utils.isTag,
|
||||
_ = {
|
||||
bind: require('lodash.bind'),
|
||||
forEach: require('lodash.foreach'),
|
||||
reject: require('lodash.reject'),
|
||||
filter: require('lodash.filter'),
|
||||
reduce: require('lodash.reduce')
|
||||
};
|
||||
|
||||
exports.find = function(selectorOrHaystack) {
|
||||
var elems = _.reduce(this, function(memo, elem) {
|
||||
return memo.concat(_.filter(elem.children, isTag));
|
||||
}, []);
|
||||
var contains = this.constructor.contains;
|
||||
var haystack;
|
||||
|
||||
if (selectorOrHaystack && typeof selectorOrHaystack !== 'string') {
|
||||
if (selectorOrHaystack.cheerio) {
|
||||
haystack = selectorOrHaystack.get();
|
||||
} else {
|
||||
haystack = [selectorOrHaystack];
|
||||
}
|
||||
|
||||
return this._make(haystack.filter(function(elem) {
|
||||
var idx, len;
|
||||
for (idx = 0, len = this.length; idx < len; ++idx) {
|
||||
if (contains(this[idx], elem)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}, this));
|
||||
}
|
||||
|
||||
var options = {__proto__: this.options, context: this.toArray()};
|
||||
|
||||
return this._make(select(selectorOrHaystack, elems, options));
|
||||
};
|
||||
|
||||
// Get the parent of each element in the current set of matched elements,
|
||||
// optionally filtered by a selector.
|
||||
exports.parent = function(selector) {
|
||||
var set = [];
|
||||
|
||||
domEach(this, function(idx, elem) {
|
||||
var parentElem = elem.parent;
|
||||
if (parentElem && set.indexOf(parentElem) < 0) {
|
||||
set.push(parentElem);
|
||||
}
|
||||
});
|
||||
|
||||
if (arguments.length) {
|
||||
set = exports.filter.call(set, selector, this);
|
||||
}
|
||||
|
||||
return this._make(set);
|
||||
};
|
||||
|
||||
exports.parents = function(selector) {
|
||||
var parentNodes = [];
|
||||
|
||||
// When multiple DOM elements are in the original set, the resulting set will
|
||||
// be in *reverse* order of the original elements as well, with duplicates
|
||||
// removed.
|
||||
this.get().reverse().forEach(function(elem) {
|
||||
traverseParents(this, elem.parent, selector, Infinity)
|
||||
.forEach(function(node) {
|
||||
if (parentNodes.indexOf(node) === -1) {
|
||||
parentNodes.push(node);
|
||||
}
|
||||
}
|
||||
);
|
||||
}, this);
|
||||
|
||||
return this._make(parentNodes);
|
||||
};
|
||||
|
||||
exports.parentsUntil = function(selector, filter) {
|
||||
var parentNodes = [], untilNode, untilNodes;
|
||||
|
||||
if (typeof selector === 'string') {
|
||||
untilNode = select(selector, this.parents().toArray(), this.options)[0];
|
||||
} else if (selector && selector.cheerio) {
|
||||
untilNodes = selector.toArray();
|
||||
} else if (selector) {
|
||||
untilNode = selector;
|
||||
}
|
||||
|
||||
// When multiple DOM elements are in the original set, the resulting set will
|
||||
// be in *reverse* order of the original elements as well, with duplicates
|
||||
// removed.
|
||||
|
||||
this.toArray().reverse().forEach(function(elem) {
|
||||
while ((elem = elem.parent)) {
|
||||
if ((untilNode && elem !== untilNode) ||
|
||||
(untilNodes && untilNodes.indexOf(elem) === -1) ||
|
||||
(!untilNode && !untilNodes)) {
|
||||
if (isTag(elem) && parentNodes.indexOf(elem) === -1) { parentNodes.push(elem); }
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}, this);
|
||||
|
||||
return this._make(filter ? select(filter, parentNodes, this.options) : parentNodes);
|
||||
};
|
||||
|
||||
// For each element in the set, get the first element that matches the selector
|
||||
// by testing the element itself and traversing up through its ancestors in the
|
||||
// DOM tree.
|
||||
exports.closest = function(selector) {
|
||||
var set = [];
|
||||
|
||||
if (!selector) {
|
||||
return this._make(set);
|
||||
}
|
||||
|
||||
domEach(this, function(idx, elem) {
|
||||
var closestElem = traverseParents(this, elem, selector, 1)[0];
|
||||
|
||||
// Do not add duplicate elements to the set
|
||||
if (closestElem && set.indexOf(closestElem) < 0) {
|
||||
set.push(closestElem);
|
||||
}
|
||||
}.bind(this));
|
||||
|
||||
return this._make(set);
|
||||
};
|
||||
|
||||
exports.next = function(selector) {
|
||||
if (!this[0]) { return this; }
|
||||
var elems = [];
|
||||
|
||||
_.forEach(this, function(elem) {
|
||||
while ((elem = elem.next)) {
|
||||
if (isTag(elem)) {
|
||||
elems.push(elem);
|
||||
return;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return selector ?
|
||||
exports.filter.call(elems, selector, this) :
|
||||
this._make(elems);
|
||||
};
|
||||
|
||||
exports.nextAll = function(selector) {
|
||||
if (!this[0]) { return this; }
|
||||
var elems = [];
|
||||
|
||||
_.forEach(this, function(elem) {
|
||||
while ((elem = elem.next)) {
|
||||
if (isTag(elem) && elems.indexOf(elem) === -1) {
|
||||
elems.push(elem);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return selector ?
|
||||
exports.filter.call(elems, selector, this) :
|
||||
this._make(elems);
|
||||
};
|
||||
|
||||
exports.nextUntil = function(selector, filterSelector) {
|
||||
if (!this[0]) { return this; }
|
||||
var elems = [], untilNode, untilNodes;
|
||||
|
||||
if (typeof selector === 'string') {
|
||||
untilNode = select(selector, this.nextAll().get(), this.options)[0];
|
||||
} else if (selector && selector.cheerio) {
|
||||
untilNodes = selector.get();
|
||||
} else if (selector) {
|
||||
untilNode = selector;
|
||||
}
|
||||
|
||||
_.forEach(this, function(elem) {
|
||||
while ((elem = elem.next)) {
|
||||
if ((untilNode && elem !== untilNode) ||
|
||||
(untilNodes && untilNodes.indexOf(elem) === -1) ||
|
||||
(!untilNode && !untilNodes)) {
|
||||
if (isTag(elem) && elems.indexOf(elem) === -1) {
|
||||
elems.push(elem);
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return filterSelector ?
|
||||
exports.filter.call(elems, filterSelector, this) :
|
||||
this._make(elems);
|
||||
};
|
||||
|
||||
exports.prev = function(selector) {
|
||||
if (!this[0]) { return this; }
|
||||
var elems = [];
|
||||
|
||||
_.forEach(this, function(elem) {
|
||||
while ((elem = elem.prev)) {
|
||||
if (isTag(elem)) {
|
||||
elems.push(elem);
|
||||
return;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return selector ?
|
||||
exports.filter.call(elems, selector, this) :
|
||||
this._make(elems);
|
||||
};
|
||||
|
||||
exports.prevAll = function(selector) {
|
||||
if (!this[0]) { return this; }
|
||||
var elems = [];
|
||||
|
||||
_.forEach(this, function(elem) {
|
||||
while ((elem = elem.prev)) {
|
||||
if (isTag(elem) && elems.indexOf(elem) === -1) {
|
||||
elems.push(elem);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return selector ?
|
||||
exports.filter.call(elems, selector, this) :
|
||||
this._make(elems);
|
||||
};
|
||||
|
||||
exports.prevUntil = function(selector, filterSelector) {
|
||||
if (!this[0]) { return this; }
|
||||
var elems = [], untilNode, untilNodes;
|
||||
|
||||
if (typeof selector === 'string') {
|
||||
untilNode = select(selector, this.prevAll().get(), this.options)[0];
|
||||
} else if (selector && selector.cheerio) {
|
||||
untilNodes = selector.get();
|
||||
} else if (selector) {
|
||||
untilNode = selector;
|
||||
}
|
||||
|
||||
_.forEach(this, function(elem) {
|
||||
while ((elem = elem.prev)) {
|
||||
if ((untilNode && elem !== untilNode) ||
|
||||
(untilNodes && untilNodes.indexOf(elem) === -1) ||
|
||||
(!untilNode && !untilNodes)) {
|
||||
if (isTag(elem) && elems.indexOf(elem) === -1) {
|
||||
elems.push(elem);
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return filterSelector ?
|
||||
exports.filter.call(elems, filterSelector, this) :
|
||||
this._make(elems);
|
||||
};
|
||||
|
||||
exports.siblings = function(selector) {
|
||||
var parent = this.parent();
|
||||
|
||||
var elems = _.filter(
|
||||
parent ? parent.children() : this.siblingsAndMe(),
|
||||
_.bind(function(elem) { return isTag(elem) && !this.is(elem); }, this)
|
||||
);
|
||||
|
||||
if (selector !== undefined) {
|
||||
return exports.filter.call(elems, selector, this);
|
||||
} else {
|
||||
return this._make(elems);
|
||||
}
|
||||
};
|
||||
|
||||
exports.children = function(selector) {
|
||||
|
||||
var elems = _.reduce(this, function(memo, elem) {
|
||||
return memo.concat(_.filter(elem.children, isTag));
|
||||
}, []);
|
||||
|
||||
if (selector === undefined) return this._make(elems);
|
||||
|
||||
return exports.filter.call(elems, selector, this);
|
||||
};
|
||||
|
||||
exports.contents = function() {
|
||||
return this._make(_.reduce(this, function(all, elem) {
|
||||
all.push.apply(all, elem.children);
|
||||
return all;
|
||||
}, []));
|
||||
};
|
||||
|
||||
exports.each = function(fn) {
|
||||
var i = 0, len = this.length;
|
||||
while (i < len && fn.call(this[i], i, this[i]) !== false) ++i;
|
||||
return this;
|
||||
};
|
||||
|
||||
exports.map = function(fn) {
|
||||
return this._make(_.reduce(this, function(memo, el, i) {
|
||||
var val = fn.call(el, i, el);
|
||||
return val == null ? memo : memo.concat(val);
|
||||
}, []));
|
||||
};
|
||||
|
||||
var makeFilterMethod = function(filterFn) {
|
||||
return function(match, container) {
|
||||
var testFn;
|
||||
container = container || this;
|
||||
|
||||
if (typeof match === 'string') {
|
||||
testFn = select.compile(match, container.options);
|
||||
} else if (typeof match === 'function') {
|
||||
testFn = function(el, i) {
|
||||
return match.call(el, i, el);
|
||||
};
|
||||
} else if (match.cheerio) {
|
||||
testFn = match.is.bind(match);
|
||||
} else {
|
||||
testFn = function(el) {
|
||||
return match === el;
|
||||
};
|
||||
}
|
||||
|
||||
return container._make(filterFn(this, testFn));
|
||||
};
|
||||
};
|
||||
|
||||
exports.filter = makeFilterMethod(_.filter);
|
||||
exports.not = makeFilterMethod(_.reject);
|
||||
|
||||
exports.has = function(selectorOrHaystack) {
|
||||
var that = this;
|
||||
return exports.filter.call(this, function() {
|
||||
return that._make(this).find(selectorOrHaystack).length > 0;
|
||||
});
|
||||
};
|
||||
|
||||
exports.first = function() {
|
||||
return this.length > 1 ? this._make(this[0]) : this;
|
||||
};
|
||||
|
||||
exports.last = function() {
|
||||
return this.length > 1 ? this._make(this[this.length - 1]) : this;
|
||||
};
|
||||
|
||||
// Reduce the set of matched elements to the one at the specified index.
|
||||
exports.eq = function(i) {
|
||||
i = +i;
|
||||
|
||||
// Use the first identity optimization if possible
|
||||
if (i === 0 && this.length <= 1) return this;
|
||||
|
||||
if (i < 0) i = this.length + i;
|
||||
return this[i] ? this._make(this[i]) : this._make([]);
|
||||
};
|
||||
|
||||
// Retrieve the DOM elements matched by the jQuery object.
|
||||
exports.get = function(i) {
|
||||
if (i == null) {
|
||||
return Array.prototype.slice.call(this);
|
||||
} else {
|
||||
return this[i < 0 ? (this.length + i) : i];
|
||||
}
|
||||
};
|
||||
|
||||
// Search for a given element from among the matched elements.
|
||||
exports.index = function(selectorOrNeedle) {
|
||||
var $haystack, needle;
|
||||
|
||||
if (arguments.length === 0) {
|
||||
$haystack = this.parent().children();
|
||||
needle = this[0];
|
||||
} else if (typeof selectorOrNeedle === 'string') {
|
||||
$haystack = this._make(selectorOrNeedle);
|
||||
needle = this[0];
|
||||
} else {
|
||||
$haystack = this;
|
||||
needle = selectorOrNeedle.cheerio ? selectorOrNeedle[0] : selectorOrNeedle;
|
||||
}
|
||||
|
||||
return $haystack.get().indexOf(needle);
|
||||
};
|
||||
|
||||
exports.slice = function() {
|
||||
return this._make([].slice.apply(this, arguments));
|
||||
};
|
||||
|
||||
function traverseParents(self, elem, selector, limit) {
|
||||
var elems = [];
|
||||
while (elem && elems.length < limit) {
|
||||
if (!selector || exports.filter.call([elem], selector, self).length) {
|
||||
elems.push(elem);
|
||||
}
|
||||
elem = elem.parent;
|
||||
}
|
||||
return elems;
|
||||
}
|
||||
|
||||
// End the most recent filtering operation in the current chain and return the
|
||||
// set of matched elements to its previous state.
|
||||
exports.end = function() {
|
||||
return this.prevObject || this._make([]);
|
||||
};
|
||||
|
||||
exports.add = function(other, context) {
|
||||
var selection = this._make(other, context);
|
||||
var contents = uniqueSort(selection.get().concat(this.get()));
|
||||
|
||||
for (var i = 0; i < contents.length; ++i) {
|
||||
selection[i] = contents[i];
|
||||
}
|
||||
selection.length = contents.length;
|
||||
|
||||
return selection;
|
||||
};
|
||||
|
||||
// Add the previous set of elements on the stack to the current set, optionally
|
||||
// filtered by a selector.
|
||||
exports.addBack = function(selector) {
|
||||
return this.add(
|
||||
arguments.length ? this.prevObject.filter(selector) : this.prevObject
|
||||
);
|
||||
};
|
||||
148
node_modules/cheerio/lib/cheerio.js
generated
vendored
Normal file
148
node_modules/cheerio/lib/cheerio.js
generated
vendored
Normal file
@@ -0,0 +1,148 @@
|
||||
/*
|
||||
Module dependencies
|
||||
*/
|
||||
|
||||
var parse = require('./parse'),
|
||||
isHtml = require('./utils').isHtml,
|
||||
_ = {
|
||||
extend: require('lodash.assignin'),
|
||||
bind: require('lodash.bind'),
|
||||
forEach: require('lodash.foreach'),
|
||||
defaults: require('lodash.defaults')
|
||||
};
|
||||
|
||||
/*
|
||||
* The API
|
||||
*/
|
||||
|
||||
var api = [
|
||||
require('./api/attributes'),
|
||||
require('./api/traversing'),
|
||||
require('./api/manipulation'),
|
||||
require('./api/css'),
|
||||
require('./api/forms')
|
||||
];
|
||||
|
||||
/*
|
||||
* Instance of cheerio
|
||||
*/
|
||||
|
||||
var Cheerio = module.exports = function(selector, context, root, options) {
|
||||
if (!(this instanceof Cheerio)) return new Cheerio(selector, context, root, options);
|
||||
|
||||
this.options = _.defaults(options || {}, this.options);
|
||||
|
||||
// $(), $(null), $(undefined), $(false)
|
||||
if (!selector) return this;
|
||||
|
||||
if (root) {
|
||||
if (typeof root === 'string') root = parse(root, this.options);
|
||||
this._root = Cheerio.call(this, root);
|
||||
}
|
||||
|
||||
// $($)
|
||||
if (selector.cheerio) return selector;
|
||||
|
||||
// $(dom)
|
||||
if (isNode(selector))
|
||||
selector = [selector];
|
||||
|
||||
// $([dom])
|
||||
if (Array.isArray(selector)) {
|
||||
_.forEach(selector, _.bind(function(elem, idx) {
|
||||
this[idx] = elem;
|
||||
}, this));
|
||||
this.length = selector.length;
|
||||
return this;
|
||||
}
|
||||
|
||||
// $(<html>)
|
||||
if (typeof selector === 'string' && isHtml(selector)) {
|
||||
return Cheerio.call(this, parse(selector, this.options).children);
|
||||
}
|
||||
|
||||
// If we don't have a context, maybe we have a root, from loading
|
||||
if (!context) {
|
||||
context = this._root;
|
||||
} else if (typeof context === 'string') {
|
||||
if (isHtml(context)) {
|
||||
// $('li', '<ul>...</ul>')
|
||||
context = parse(context, this.options);
|
||||
context = Cheerio.call(this, context);
|
||||
} else {
|
||||
// $('li', 'ul')
|
||||
selector = [context, selector].join(' ');
|
||||
context = this._root;
|
||||
}
|
||||
// $('li', node), $('li', [nodes])
|
||||
} else if (!context.cheerio) {
|
||||
context = Cheerio.call(this, context);
|
||||
}
|
||||
|
||||
// If we still don't have a context, return
|
||||
if (!context) return this;
|
||||
|
||||
// #id, .class, tag
|
||||
return context.find(selector);
|
||||
};
|
||||
|
||||
/**
|
||||
* Mix in `static`
|
||||
*/
|
||||
|
||||
_.extend(Cheerio, require('./static'));
|
||||
|
||||
/*
|
||||
* Set a signature of the object
|
||||
*/
|
||||
|
||||
Cheerio.prototype.cheerio = '[cheerio object]';
|
||||
|
||||
/*
|
||||
* Cheerio default options
|
||||
*/
|
||||
|
||||
Cheerio.prototype.options = {
|
||||
withDomLvl1: true,
|
||||
normalizeWhitespace: false,
|
||||
xmlMode: false,
|
||||
decodeEntities: true
|
||||
};
|
||||
|
||||
/*
|
||||
* Make cheerio an array-like object
|
||||
*/
|
||||
|
||||
Cheerio.prototype.length = 0;
|
||||
Cheerio.prototype.splice = Array.prototype.splice;
|
||||
|
||||
/*
|
||||
* Make a cheerio object
|
||||
*
|
||||
* @api private
|
||||
*/
|
||||
|
||||
Cheerio.prototype._make = function(dom, context) {
|
||||
var cheerio = new this.constructor(dom, context, this._root, this.options);
|
||||
cheerio.prevObject = this;
|
||||
return cheerio;
|
||||
};
|
||||
|
||||
/**
|
||||
* Turn a cheerio object into an array
|
||||
*/
|
||||
|
||||
Cheerio.prototype.toArray = function() {
|
||||
return this.get();
|
||||
};
|
||||
|
||||
/**
|
||||
* Plug in the API
|
||||
*/
|
||||
api.forEach(function(mod) {
|
||||
_.extend(Cheerio.prototype, mod);
|
||||
});
|
||||
|
||||
var isNode = function(obj) {
|
||||
return obj.name || obj.type === 'text' || obj.type === 'comment';
|
||||
};
|
||||
86
node_modules/cheerio/lib/parse.js
generated
vendored
Normal file
86
node_modules/cheerio/lib/parse.js
generated
vendored
Normal file
@@ -0,0 +1,86 @@
|
||||
/*
|
||||
Module Dependencies
|
||||
*/
|
||||
var htmlparser = require('htmlparser2');
|
||||
|
||||
/*
|
||||
Parser
|
||||
*/
|
||||
exports = module.exports = function(content, options) {
|
||||
var dom = exports.evaluate(content, options),
|
||||
// Generic root element
|
||||
root = exports.evaluate('<root></root>', options)[0];
|
||||
|
||||
root.type = 'root';
|
||||
|
||||
// Update the dom using the root
|
||||
exports.update(dom, root);
|
||||
|
||||
return root;
|
||||
};
|
||||
|
||||
exports.evaluate = function(content, options) {
|
||||
// options = options || $.fn.options;
|
||||
|
||||
var dom;
|
||||
|
||||
if (typeof content === 'string' || Buffer.isBuffer(content)) {
|
||||
dom = htmlparser.parseDOM(content, options);
|
||||
} else {
|
||||
dom = content;
|
||||
}
|
||||
|
||||
return dom;
|
||||
};
|
||||
|
||||
/*
|
||||
Update the dom structure, for one changed layer
|
||||
*/
|
||||
exports.update = function(arr, parent) {
|
||||
// normalize
|
||||
if (!Array.isArray(arr)) arr = [arr];
|
||||
|
||||
// Update parent
|
||||
if (parent) {
|
||||
parent.children = arr;
|
||||
} else {
|
||||
parent = null;
|
||||
}
|
||||
|
||||
// Update neighbors
|
||||
for (var i = 0; i < arr.length; i++) {
|
||||
var node = arr[i];
|
||||
|
||||
// Cleanly remove existing nodes from their previous structures.
|
||||
var oldParent = node.parent || node.root,
|
||||
oldSiblings = oldParent && oldParent.children;
|
||||
if (oldSiblings && oldSiblings !== arr) {
|
||||
oldSiblings.splice(oldSiblings.indexOf(node), 1);
|
||||
if (node.prev) {
|
||||
node.prev.next = node.next;
|
||||
}
|
||||
if (node.next) {
|
||||
node.next.prev = node.prev;
|
||||
}
|
||||
}
|
||||
|
||||
if (parent) {
|
||||
node.prev = arr[i - 1] || null;
|
||||
node.next = arr[i + 1] || null;
|
||||
} else {
|
||||
node.prev = node.next = null;
|
||||
}
|
||||
|
||||
if (parent && parent.type === 'root') {
|
||||
node.root = parent;
|
||||
node.parent = null;
|
||||
} else {
|
||||
node.root = null;
|
||||
node.parent = parent;
|
||||
}
|
||||
}
|
||||
|
||||
return parent;
|
||||
};
|
||||
|
||||
// module.exports = $.extend(exports);
|
||||
187
node_modules/cheerio/lib/static.js
generated
vendored
Normal file
187
node_modules/cheerio/lib/static.js
generated
vendored
Normal file
@@ -0,0 +1,187 @@
|
||||
/**
|
||||
* Module dependencies
|
||||
*/
|
||||
|
||||
var serialize = require('dom-serializer'),
|
||||
select = require('css-select'),
|
||||
parse = require('./parse'),
|
||||
_ = {
|
||||
merge: require('lodash.merge'),
|
||||
defaults: require('lodash.defaults')
|
||||
};
|
||||
|
||||
/**
|
||||
* $.load(str)
|
||||
*/
|
||||
|
||||
exports.load = function(content, options) {
|
||||
var Cheerio = require('./cheerio');
|
||||
|
||||
options = _.defaults(options || {}, Cheerio.prototype.options);
|
||||
|
||||
var root = parse(content, options);
|
||||
|
||||
var initialize = function(selector, context, r, opts) {
|
||||
if (!(this instanceof initialize)) {
|
||||
return new initialize(selector, context, r, opts);
|
||||
}
|
||||
opts = _.defaults(opts || {}, options);
|
||||
return Cheerio.call(this, selector, context, r || root, opts);
|
||||
};
|
||||
|
||||
// Ensure that selections created by the "loaded" `initialize` function are
|
||||
// true Cheerio instances.
|
||||
initialize.prototype = Object.create(Cheerio.prototype);
|
||||
initialize.prototype.constructor = initialize;
|
||||
|
||||
// Mimic jQuery's prototype alias for plugin authors.
|
||||
initialize.fn = initialize.prototype;
|
||||
|
||||
// Keep a reference to the top-level scope so we can chain methods that implicitly
|
||||
// resolve selectors; e.g. $("<span>").(".bar"), which otherwise loses ._root
|
||||
initialize.prototype._originalRoot = root;
|
||||
|
||||
// Add in the static methods
|
||||
_.merge(initialize, exports);
|
||||
|
||||
// Add in the root
|
||||
initialize._root = root;
|
||||
// store options
|
||||
initialize._options = options;
|
||||
|
||||
return initialize;
|
||||
};
|
||||
|
||||
/*
|
||||
* Helper function
|
||||
*/
|
||||
|
||||
function render(that, dom, options) {
|
||||
if (!dom) {
|
||||
if (that._root && that._root.children) {
|
||||
dom = that._root.children;
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
} else if (typeof dom === 'string') {
|
||||
dom = select(dom, that._root, options);
|
||||
}
|
||||
|
||||
return serialize(dom, options);
|
||||
}
|
||||
|
||||
/**
|
||||
* $.html([selector | dom], [options])
|
||||
*/
|
||||
|
||||
exports.html = function(dom, options) {
|
||||
var Cheerio = require('./cheerio');
|
||||
|
||||
// be flexible about parameters, sometimes we call html(),
|
||||
// with options as only parameter
|
||||
// check dom argument for dom element specific properties
|
||||
// assume there is no 'length' or 'type' properties in the options object
|
||||
if (Object.prototype.toString.call(dom) === '[object Object]' && !options && !('length' in dom) && !('type' in dom))
|
||||
{
|
||||
options = dom;
|
||||
dom = undefined;
|
||||
}
|
||||
|
||||
// sometimes $.html() used without preloading html
|
||||
// so fallback non existing options to the default ones
|
||||
options = _.defaults(options || {}, this._options, Cheerio.prototype.options);
|
||||
|
||||
return render(this, dom, options);
|
||||
};
|
||||
|
||||
/**
|
||||
* $.xml([selector | dom])
|
||||
*/
|
||||
|
||||
exports.xml = function(dom) {
|
||||
var options = _.defaults({xmlMode: true}, this._options);
|
||||
|
||||
return render(this, dom, options);
|
||||
};
|
||||
|
||||
/**
|
||||
* $.text(dom)
|
||||
*/
|
||||
|
||||
exports.text = function(elems) {
|
||||
if (!elems) {
|
||||
elems = this.root();
|
||||
}
|
||||
|
||||
var ret = '',
|
||||
len = elems.length,
|
||||
elem;
|
||||
|
||||
for (var i = 0; i < len; i++) {
|
||||
elem = elems[i];
|
||||
if (elem.type === 'text') ret += elem.data;
|
||||
else if (elem.children && elem.type !== 'comment') {
|
||||
ret += exports.text(elem.children);
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
};
|
||||
|
||||
/**
|
||||
* $.parseHTML(data [, context ] [, keepScripts ])
|
||||
* Parses a string into an array of DOM nodes. The `context` argument has no
|
||||
* meaning for Cheerio, but it is maintained for API compatibility with jQuery.
|
||||
*/
|
||||
exports.parseHTML = function(data, context, keepScripts) {
|
||||
var parsed;
|
||||
|
||||
if (!data || typeof data !== 'string') {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (typeof context === 'boolean') {
|
||||
keepScripts = context;
|
||||
}
|
||||
|
||||
parsed = this.load(data);
|
||||
if (!keepScripts) {
|
||||
parsed('script').remove();
|
||||
}
|
||||
|
||||
// The `children` array is used by Cheerio internally to group elements that
|
||||
// share the same parents. When nodes created through `parseHTML` are
|
||||
// inserted into previously-existing DOM structures, they will be removed
|
||||
// from the `children` array. The results of `parseHTML` should remain
|
||||
// constant across these operations, so a shallow copy should be returned.
|
||||
return parsed.root()[0].children.slice();
|
||||
};
|
||||
|
||||
/**
|
||||
* $.root()
|
||||
*/
|
||||
exports.root = function() {
|
||||
return this(this._root);
|
||||
};
|
||||
|
||||
/**
|
||||
* $.contains()
|
||||
*/
|
||||
exports.contains = function(container, contained) {
|
||||
|
||||
// According to the jQuery API, an element does not "contain" itself
|
||||
if (contained === container) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Step up the descendants, stopping when the root element is reached
|
||||
// (signaled by `.parent` returning a reference to the same object)
|
||||
while (contained && contained !== contained.parent) {
|
||||
contained = contained.parent;
|
||||
if (contained === container) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
83
node_modules/cheerio/lib/utils.js
generated
vendored
Normal file
83
node_modules/cheerio/lib/utils.js
generated
vendored
Normal file
@@ -0,0 +1,83 @@
|
||||
var parse = require('./parse'),
|
||||
render = require('dom-serializer');
|
||||
|
||||
/**
|
||||
* HTML Tags
|
||||
*/
|
||||
|
||||
var tags = { tag: true, script: true, style: true };
|
||||
|
||||
/**
|
||||
* Check if the DOM element is a tag
|
||||
*
|
||||
* isTag(type) includes <script> and <style> tags
|
||||
*/
|
||||
|
||||
exports.isTag = function(type) {
|
||||
if (type.type) type = type.type;
|
||||
return tags[type] || false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a string to camel case notation.
|
||||
* @param {String} str String to be converted.
|
||||
* @return {String} String in camel case notation.
|
||||
*/
|
||||
|
||||
exports.camelCase = function(str) {
|
||||
return str.replace(/[_.-](\w|$)/g, function(_, x) {
|
||||
return x.toUpperCase();
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a string from camel case to "CSS case", where word boundaries are
|
||||
* described by hyphens ("-") and all characters are lower-case.
|
||||
* @param {String} str String to be converted.
|
||||
* @return {string} String in "CSS case".
|
||||
*/
|
||||
exports.cssCase = function(str) {
|
||||
return str.replace(/[A-Z]/g, '-$&').toLowerCase();
|
||||
};
|
||||
|
||||
/**
|
||||
* Iterate over each DOM element without creating intermediary Cheerio instances.
|
||||
*
|
||||
* This is indented for use internally to avoid otherwise unnecessary memory pressure introduced
|
||||
* by _make.
|
||||
*/
|
||||
|
||||
exports.domEach = function(cheerio, fn) {
|
||||
var i = 0, len = cheerio.length;
|
||||
while (i < len && fn.call(cheerio, i, cheerio[i]) !== false) ++i;
|
||||
return cheerio;
|
||||
};
|
||||
|
||||
/**
|
||||
* Create a deep copy of the given DOM structure by first rendering it to a
|
||||
* string and then parsing the resultant markup.
|
||||
*
|
||||
* @argument {Object} dom - The htmlparser2-compliant DOM structure
|
||||
* @argument {Object} options - The parsing/rendering options
|
||||
*/
|
||||
exports.cloneDom = function(dom, options) {
|
||||
return parse(render(dom, options), options).children;
|
||||
};
|
||||
|
||||
/*
|
||||
* A simple way to check for HTML strings or ID strings
|
||||
*/
|
||||
|
||||
var quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/;
|
||||
|
||||
/*
|
||||
* Check if string is HTML
|
||||
*/
|
||||
exports.isHtml = function(str) {
|
||||
// Faster than running regex, if str starts with `<` and ends with `>`, assume it's HTML
|
||||
if (str.charAt(0) === '<' && str.charAt(str.length - 1) === '>' && str.length >= 3) return true;
|
||||
|
||||
// Run the regex
|
||||
var match = quickExpr.exec(str);
|
||||
return !!(match && match[1]);
|
||||
};
|
||||
138
node_modules/cheerio/package.json
generated
vendored
Normal file
138
node_modules/cheerio/package.json
generated
vendored
Normal file
@@ -0,0 +1,138 @@
|
||||
{
|
||||
"_args": [
|
||||
[
|
||||
{
|
||||
"name": "cheerio",
|
||||
"raw": "cheerio@0.22.0",
|
||||
"rawSpec": "0.22.0",
|
||||
"scope": null,
|
||||
"spec": "0.22.0",
|
||||
"type": "version"
|
||||
},
|
||||
"F:\\tmp\\gitbook\\node_modules\\gitbook-plugin-prism"
|
||||
]
|
||||
],
|
||||
"_from": "cheerio@0.22.0",
|
||||
"_id": "cheerio@0.22.0",
|
||||
"_inCache": true,
|
||||
"_installable": true,
|
||||
"_location": "/cheerio",
|
||||
"_nodeVersion": "6.2.2",
|
||||
"_npmOperationalInternal": {
|
||||
"host": "packages-12-west.internal.npmjs.com",
|
||||
"tmp": "tmp/cheerio-0.22.0.tgz_1471954900169_0.12557715992443264"
|
||||
},
|
||||
"_npmUser": {
|
||||
"email": "mattmuelle@gmail.com",
|
||||
"name": "mattmueller"
|
||||
},
|
||||
"_npmVersion": "3.10.6",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"name": "cheerio",
|
||||
"raw": "cheerio@0.22.0",
|
||||
"rawSpec": "0.22.0",
|
||||
"scope": null,
|
||||
"spec": "0.22.0",
|
||||
"type": "version"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/gitbook-plugin-prism"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.22.0.tgz",
|
||||
"_shasum": "a9baa860a3f9b595a6b81b1a86873121ed3a269e",
|
||||
"_shrinkwrap": null,
|
||||
"_spec": "cheerio@0.22.0",
|
||||
"_where": "F:\\tmp\\gitbook\\node_modules\\gitbook-plugin-prism",
|
||||
"author": {
|
||||
"email": "mattmuelle@gmail.com",
|
||||
"name": "Matt Mueller",
|
||||
"url": "mat.io"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/cheeriojs/cheerio/issues"
|
||||
},
|
||||
"dependencies": {
|
||||
"css-select": "~1.2.0",
|
||||
"dom-serializer": "~0.1.0",
|
||||
"entities": "~1.1.1",
|
||||
"htmlparser2": "^3.9.1",
|
||||
"lodash.assignin": "^4.0.9",
|
||||
"lodash.bind": "^4.1.4",
|
||||
"lodash.defaults": "^4.0.1",
|
||||
"lodash.filter": "^4.4.0",
|
||||
"lodash.flatten": "^4.2.0",
|
||||
"lodash.foreach": "^4.3.0",
|
||||
"lodash.map": "^4.4.0",
|
||||
"lodash.merge": "^4.4.0",
|
||||
"lodash.pick": "^4.2.1",
|
||||
"lodash.reduce": "^4.4.0",
|
||||
"lodash.reject": "^4.4.0",
|
||||
"lodash.some": "^4.4.0"
|
||||
},
|
||||
"description": "Tiny, fast, and elegant implementation of core jQuery designed specifically for the server",
|
||||
"devDependencies": {
|
||||
"benchmark": "^2.1.0",
|
||||
"coveralls": "^2.11.9",
|
||||
"expect.js": "~0.3.1",
|
||||
"istanbul": "^0.4.3",
|
||||
"jquery": "^3.0.0",
|
||||
"jsdom": "^9.2.1",
|
||||
"jshint": "^2.9.2",
|
||||
"mocha": "^2.5.3",
|
||||
"xyz": "~0.5.0"
|
||||
},
|
||||
"directories": {},
|
||||
"dist": {
|
||||
"shasum": "a9baa860a3f9b595a6b81b1a86873121ed3a269e",
|
||||
"tarball": "https://registry.npmjs.org/cheerio/-/cheerio-0.22.0.tgz"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 0.6"
|
||||
},
|
||||
"files": [
|
||||
"index.js",
|
||||
"lib"
|
||||
],
|
||||
"gitHead": "35c4917205dca9d08139c95419e2626c0689e38a",
|
||||
"homepage": "https://github.com/cheeriojs/cheerio#readme",
|
||||
"keywords": [
|
||||
"htmlparser",
|
||||
"jquery",
|
||||
"selector",
|
||||
"scraper",
|
||||
"parser",
|
||||
"html"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "./index.js",
|
||||
"maintainers": [
|
||||
{
|
||||
"email": "mattmuelle@gmail.com",
|
||||
"name": "mattmueller"
|
||||
},
|
||||
{
|
||||
"email": "dc@davidchambers.me",
|
||||
"name": "davidchambers"
|
||||
},
|
||||
{
|
||||
"email": "mike@mikepennisi.com",
|
||||
"name": "jugglinmike"
|
||||
},
|
||||
{
|
||||
"email": "me@feedic.com",
|
||||
"name": "feedic"
|
||||
}
|
||||
],
|
||||
"name": "cheerio",
|
||||
"optionalDependencies": {},
|
||||
"readme": "ERROR: No README data found!",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/cheeriojs/cheerio.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "make test"
|
||||
},
|
||||
"version": "0.22.0"
|
||||
}
|
||||
Reference in New Issue
Block a user