WIP - add extractor, generate snippet_data
This commit is contained in:
Stefan Fejes
652
node_modules/cheerio/History.md
generated
vendored
Normal file
652
node_modules/cheerio/History.md
generated
vendored
Normal file
@ -0,0 +1,652 @@
|
||||
1.0.0-rc.3 / 2019-04-06
|
||||
==================
|
||||
|
||||
This release corrects a test expectation that was fixed by one of the project's
|
||||
dependencies.
|
||||
|
||||
1.0.0-rc.2 / 2017-07-02
|
||||
==================
|
||||
|
||||
This release changes Cheerio's default parser to [the Parse5 HTML
|
||||
parser](https://github.com/inikulin/parse5). Parse5 is an excellent project
|
||||
that rigorously conforms to the HTML standard. It does not support XML, so
|
||||
Cheerio continues to use [`htmlparser2`](https://github.com/fb55/htmlparser2/)
|
||||
when working with XML documents.
|
||||
|
||||
This switch addresses many long-standing bugs in Cheerio, but some users may
|
||||
experience slower behavior in performance-critical applications. In addition,
|
||||
`htmlparser2` is more forgiving of invalid markup which can be useful when
|
||||
input sourced from a third party and cannot be corrected. For these reasons,
|
||||
the `load` method also accepts a DOM structure as produced by the `htmlparser2`
|
||||
library. See the project's "readme" file for more details on this usage
|
||||
pattern.
|
||||
|
||||
### Migrating from version 0.x
|
||||
|
||||
`cheerio.load( html[, options ] )`` This method continues to produce
|
||||
jQuery-like functions, bound to the provided input text. In prior releases, the
|
||||
provided string was interpreted as a document fragment. This meant that in a
|
||||
statement such as:
|
||||
|
||||
var $ = cheerio.load('<p>Hello, <b>world</b>!</p>');
|
||||
|
||||
The resulting `$` function would operate on a tree whose root element was a
|
||||
paragraph tag.
|
||||
|
||||
With this release of Cheerio, strings provided to the `load` method are
|
||||
interpreted as documents. The same example will produce a `$` function that
|
||||
operates on a full HTML document, including an `<html>` document element with
|
||||
nested `<head>` and `<body>` tags. This mimics web browser behavior much more
|
||||
closely, but may require alterations to existing code. To work with fragments,
|
||||
first load an empty document, and then use the resulting `$` to parse the
|
||||
input:
|
||||
|
||||
var $ = cheerio.load('');
|
||||
var $fragment = $('<p>Hello, <b>world</b>!</p>');
|
||||
|
||||
* Update History.md (and include migration guide) (Mike Pennisi)
|
||||
* Rename `useHtmlParser2` option (Mike Pennisi)
|
||||
* Remove documentation for `xmlMode` option (Mike Pennisi)
|
||||
* Document advanced usage with htmlparser2 (Mike Pennisi)
|
||||
* Correct errors in Readme.md (Mike Pennisi)
|
||||
* Improve release process (Mike Pennisi)
|
||||
* 1.0.0-rc.1 (Mike Pennisi)
|
||||
* Update unit test (Mike Pennisi)
|
||||
* Normalize code style (Mike Pennisi)
|
||||
* Added support for nested wrapping. (Diane Looney)
|
||||
* Add nested wrapping test (Toni Helenius)
|
||||
* Added $.merge following the specification at https://api.jquery.com/jquery.merge/ Added test cases for $.merge (Diane Looney)
|
||||
* Clarify project scope in README file (Mike Pennisi)
|
||||
* .text() ignores script and style tags (#1018) (Haleem Assal)
|
||||
* Test suite housekeeping (#1016) (DianeLooney)
|
||||
* experiment with a job board (Matthew)
|
||||
* Change options format (inikulin)
|
||||
* Add test for #997 (inikulin)
|
||||
* Update .filter function docs. (Konstantin)
|
||||
* Standardise readme on ES6 variable declarations (Dekatron)
|
||||
* Use documents via $.load (inikulin)
|
||||
* Use parse5 as a default parser (closes #863) (inikulin)
|
||||
* Fix small typo in Readme (Darren Scerri)
|
||||
* Report test failures in CI (Mike Pennisi)
|
||||
* serializeArray should not ignore input elements without value attributes (Ricardo Gladwell)
|
||||
* Disallow variable shadowing (Mike Pennisi)
|
||||
* Update hasClass method (sufisaid)
|
||||
* Added MIT License fixes #902 (Prasanth Vaaheeswaran)
|
||||
* chore(package): update dependencies (greenkeeper[bot])
|
||||
* Use modular lodash package (#913) (Billy Janitsch)
|
||||
|
||||
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)
|
||||
21
node_modules/cheerio/LICENSE
generated
vendored
Normal file
21
node_modules/cheerio/LICENSE
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2016 Matt Mueller
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
1041
node_modules/cheerio/Readme.md
generated
vendored
Normal file
1041
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;
|
||||
492
node_modules/cheerio/lib/api/attributes.js
generated
vendored
Normal file
492
node_modules/cheerio/lib/api/attributes.js
generated
vendored
Normal file
@ -0,0 +1,492 @@
|
||||
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(objValue, objName) {
|
||||
setAttr(el, objName, objValue);
|
||||
});
|
||||
} else {
|
||||
setAttr(el, name, value);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return getAttr(this[0], name);
|
||||
};
|
||||
|
||||
var getProp = function (el, name) {
|
||||
if (!el || !isTag(el)) return;
|
||||
|
||||
return hasOwn.call(el, 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(j, el) {
|
||||
setProp(el, name, value.call(el, j, getProp(el, name)));
|
||||
});
|
||||
}
|
||||
|
||||
return domEach(this, function(__, el) {
|
||||
if (!isTag(el)) return;
|
||||
|
||||
if (typeof name === 'object') {
|
||||
|
||||
_.forEach(name, function(val, key) {
|
||||
setProp(el, key, 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;
|
||||
}
|
||||
};
|
||||
|
||||
// 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 (!hasOwn.call(this.attr(), '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 (hasOwn.call(this.attr(), 'multiple')) {
|
||||
returnValue = [];
|
||||
domEach(option, function(__, 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 && className.length) {
|
||||
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 value = $elem.val();
|
||||
|
||||
// If there is no value set (e.g. `undefined`, `null`), then default value to empty
|
||||
if (value == null) {
|
||||
value = '';
|
||||
}
|
||||
|
||||
// If we have an array of values (e.g. `<select multiple>`), return an array of key/value pairs
|
||||
if (Array.isArray(value)) {
|
||||
return _.map(value, 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: value.replace( rCRLF, '\r\n' )};
|
||||
}
|
||||
// Convert our result to an array
|
||||
}).get();
|
||||
};
|
||||
442
node_modules/cheerio/lib/api/manipulation.js
generated
vendored
Normal file
442
node_modules/cheerio/lib/api/manipulation.js
generated
vendored
Normal file
@ -0,0 +1,442 @@
|
||||
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, false);
|
||||
} 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,
|
||||
wrapperDom, elInsertLocation, j, index;
|
||||
|
||||
if (!parent) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (wrapperFn) {
|
||||
wrapper = wrapperFn.call(el, i);
|
||||
}
|
||||
|
||||
if (typeof wrapper === 'string' && !isHtml(wrapper)) {
|
||||
wrapper = this.parents().last().find(wrapper).clone();
|
||||
}
|
||||
|
||||
wrapperDom = this._makeDomArray(wrapper, i < lastIdx).slice(0, 1);
|
||||
elInsertLocation = wrapperDom[0];
|
||||
// Find the deepest child. Only consider the first tag child of each node
|
||||
// (ignore text); stop if no children are found.
|
||||
j = 0;
|
||||
|
||||
while (elInsertLocation && elInsertLocation.children) {
|
||||
if (j >= elInsertLocation.children.length) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (elInsertLocation.children[j].type === 'tag') {
|
||||
elInsertLocation = elInsertLocation.children[j];
|
||||
j=0;
|
||||
} else {
|
||||
j++;
|
||||
}
|
||||
}
|
||||
index = siblings.indexOf(el);
|
||||
|
||||
updateDOM([el], elInsertLocation);
|
||||
// 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, wrapperDom, 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(child) {
|
||||
child.next = child.prev = child.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(child) {
|
||||
child.next = child.prev = child.parent = null;
|
||||
});
|
||||
|
||||
var content = str.cheerio ? str.clone().get() : evaluate('' + str, opts, false);
|
||||
|
||||
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(child) {
|
||||
child.next = child.prev = child.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
|
||||
);
|
||||
};
|
||||
139
node_modules/cheerio/lib/cheerio.js
generated
vendored
Normal file
139
node_modules/cheerio/lib/cheerio.js
generated
vendored
Normal file
@ -0,0 +1,139 @@
|
||||
/*
|
||||
Module dependencies
|
||||
*/
|
||||
|
||||
var parse = require('./parse'),
|
||||
defaultOptions = require('./options').default,
|
||||
flattenOptions = require('./options').flatten,
|
||||
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(flattenOptions(options), this.options, defaultOptions);
|
||||
|
||||
// $(), $(null), $(undefined), $(false)
|
||||
if (!selector) return this;
|
||||
|
||||
if (root) {
|
||||
if (typeof root === 'string') root = parse(root, this.options, false);
|
||||
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, false).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, false);
|
||||
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]';
|
||||
|
||||
/*
|
||||
* 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';
|
||||
};
|
||||
16
node_modules/cheerio/lib/options.js
generated
vendored
Normal file
16
node_modules/cheerio/lib/options.js
generated
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
var assign = require('lodash/assign');
|
||||
|
||||
/*
|
||||
* Cheerio default options
|
||||
*/
|
||||
|
||||
exports.default = {
|
||||
withDomLvl1: true,
|
||||
normalizeWhitespace: false,
|
||||
xml: false,
|
||||
decodeEntities: true
|
||||
};
|
||||
|
||||
exports.flatten = function(options) {
|
||||
return options && options.xml ? assign({xmlMode: true}, options.xml) : options;
|
||||
};
|
||||
100
node_modules/cheerio/lib/parse.js
generated
vendored
Normal file
100
node_modules/cheerio/lib/parse.js
generated
vendored
Normal file
@ -0,0 +1,100 @@
|
||||
/*
|
||||
Module Dependencies
|
||||
*/
|
||||
var htmlparser = require('htmlparser2'),
|
||||
parse5 = require('parse5');
|
||||
|
||||
/*
|
||||
Parser
|
||||
*/
|
||||
exports = module.exports = function(content, options, isDocument) {
|
||||
var dom = exports.evaluate(content, options, isDocument),
|
||||
// Generic root element
|
||||
root = exports.evaluate('<root></root>', options, false)[0];
|
||||
|
||||
root.type = 'root';
|
||||
root.parent = null;
|
||||
|
||||
// Update the dom using the root
|
||||
exports.update(dom, root);
|
||||
|
||||
return root;
|
||||
};
|
||||
|
||||
function parseWithParse5 (content, isDocument) {
|
||||
var parse = isDocument ? parse5.parse : parse5.parseFragment,
|
||||
root = parse(content, { treeAdapter: parse5.treeAdapters.htmlparser2 });
|
||||
|
||||
return root.children;
|
||||
}
|
||||
|
||||
exports.evaluate = function(content, options, isDocument) {
|
||||
// options = options || $.fn.options;
|
||||
|
||||
var dom;
|
||||
|
||||
if (Buffer.isBuffer(content))
|
||||
content = content.toString();
|
||||
|
||||
if (typeof content === 'string') {
|
||||
var useHtmlParser2 = options.xmlMode || options._useHtmlParser2;
|
||||
|
||||
dom = useHtmlParser2 ? htmlparser.parseDOM(content, options) : parseWithParse5(content, isDocument);
|
||||
} 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);
|
||||
234
node_modules/cheerio/lib/static.js
generated
vendored
Normal file
234
node_modules/cheerio/lib/static.js
generated
vendored
Normal file
@ -0,0 +1,234 @@
|
||||
/**
|
||||
* Module dependencies
|
||||
*/
|
||||
|
||||
var serialize = require('dom-serializer'),
|
||||
defaultOptions = require('./options').default,
|
||||
flattenOptions = require('./options').flatten,
|
||||
select = require('css-select'),
|
||||
parse = require('./parse'),
|
||||
_ = {
|
||||
merge: require('lodash/merge'),
|
||||
defaults: require('lodash/defaults')
|
||||
};
|
||||
|
||||
/**
|
||||
* $.load(str)
|
||||
*/
|
||||
|
||||
exports.load = function(content, options, isDocument) {
|
||||
var Cheerio = require('./cheerio');
|
||||
|
||||
options = _.defaults(flattenOptions(options || {}), defaultOptions);
|
||||
|
||||
if (isDocument === void 0)
|
||||
isDocument = true;
|
||||
|
||||
var root = parse(content, options, isDocument);
|
||||
|
||||
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) {
|
||||
// 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(flattenOptions(options || {}), this._options, defaultOptions);
|
||||
|
||||
return render(this, dom, options);
|
||||
};
|
||||
|
||||
/**
|
||||
* $.xml([selector | dom])
|
||||
*/
|
||||
|
||||
exports.xml = function(dom) {
|
||||
var options = _.defaults({xml: 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' && elem.tagName !== 'script' && elem.tagName !== 'style') {
|
||||
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, defaultOptions, false);
|
||||
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;
|
||||
};
|
||||
|
||||
/**
|
||||
* $.merge()
|
||||
*/
|
||||
|
||||
exports.merge = function(arr1, arr2) {
|
||||
if(!(isArrayLike(arr1) && isArrayLike(arr2))){
|
||||
return;
|
||||
}
|
||||
var newLength = arr1.length + arr2.length;
|
||||
var i = 0;
|
||||
while(i < arr2.length){
|
||||
arr1[i + arr1.length] = arr2[i];
|
||||
i++;
|
||||
}
|
||||
arr1.length = newLength;
|
||||
return arr1;
|
||||
};
|
||||
|
||||
function isArrayLike(item){
|
||||
if(Array.isArray(item)){
|
||||
return true;
|
||||
}
|
||||
if(typeof item !== 'object'){
|
||||
return false;
|
||||
}
|
||||
if(!item.hasOwnProperty('length')){
|
||||
return false;
|
||||
}
|
||||
if(typeof item.length !== 'number') {
|
||||
return false;
|
||||
}
|
||||
if(item.length < 0){
|
||||
return false;
|
||||
}
|
||||
var i = 0;
|
||||
while(i < item.length){
|
||||
if(!(i in item)){
|
||||
return false;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
86
node_modules/cheerio/lib/utils.js
generated
vendored
Normal file
86
node_modules/cheerio/lib/utils.js
generated
vendored
Normal file
@ -0,0 +1,86 @@
|
||||
var parse = require('./parse'),
|
||||
render = require('dom-serializer'),
|
||||
assign = require('lodash/assign');
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
options = assign({}, options, { _useHtmlParser2: true });
|
||||
|
||||
return parse(render(dom, options), options, false).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]);
|
||||
};
|
||||
11
node_modules/cheerio/node_modules/dom-serializer/LICENSE
generated
vendored
Normal file
11
node_modules/cheerio/node_modules/dom-serializer/LICENSE
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
License
|
||||
|
||||
(The MIT License)
|
||||
|
||||
Copyright (c) 2014 The cheeriojs contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
148
node_modules/cheerio/node_modules/dom-serializer/index.js
generated
vendored
Normal file
148
node_modules/cheerio/node_modules/dom-serializer/index.js
generated
vendored
Normal file
@ -0,0 +1,148 @@
|
||||
/*
|
||||
Module dependencies
|
||||
*/
|
||||
var ElementType = require('domelementtype');
|
||||
var entities = require('entities');
|
||||
|
||||
var unencodedElements = {
|
||||
__proto__: null,
|
||||
style: true,
|
||||
script: true,
|
||||
xmp: true,
|
||||
iframe: true,
|
||||
noembed: true,
|
||||
noframes: true,
|
||||
plaintext: true,
|
||||
noscript: true
|
||||
};
|
||||
|
||||
/*
|
||||
Format attributes
|
||||
*/
|
||||
function formatAttrs(attributes, opts) {
|
||||
if (!attributes) return;
|
||||
|
||||
var output = '',
|
||||
value;
|
||||
|
||||
// Loop through the attributes
|
||||
for (var key in attributes) {
|
||||
value = attributes[key];
|
||||
if (output) {
|
||||
output += ' ';
|
||||
}
|
||||
|
||||
output += key;
|
||||
if ((value !== null && value !== '') || opts.xmlMode) {
|
||||
output += '="' + (opts.decodeEntities ? entities.encodeXML(value) : value) + '"';
|
||||
}
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
/*
|
||||
Self-enclosing tags (stolen from node-htmlparser)
|
||||
*/
|
||||
var singleTag = {
|
||||
__proto__: null,
|
||||
area: true,
|
||||
base: true,
|
||||
basefont: true,
|
||||
br: true,
|
||||
col: true,
|
||||
command: true,
|
||||
embed: true,
|
||||
frame: true,
|
||||
hr: true,
|
||||
img: true,
|
||||
input: true,
|
||||
isindex: true,
|
||||
keygen: true,
|
||||
link: true,
|
||||
meta: true,
|
||||
param: true,
|
||||
source: true,
|
||||
track: true,
|
||||
wbr: true,
|
||||
};
|
||||
|
||||
|
||||
var render = module.exports = function(dom, opts) {
|
||||
if (!Array.isArray(dom) && !dom.cheerio) dom = [dom];
|
||||
opts = opts || {};
|
||||
|
||||
var output = '';
|
||||
|
||||
for(var i = 0; i < dom.length; i++){
|
||||
var elem = dom[i];
|
||||
|
||||
if (elem.type === 'root')
|
||||
output += render(elem.children, opts);
|
||||
else if (ElementType.isTag(elem))
|
||||
output += renderTag(elem, opts);
|
||||
else if (elem.type === ElementType.Directive)
|
||||
output += renderDirective(elem);
|
||||
else if (elem.type === ElementType.Comment)
|
||||
output += renderComment(elem);
|
||||
else if (elem.type === ElementType.CDATA)
|
||||
output += renderCdata(elem);
|
||||
else
|
||||
output += renderText(elem, opts);
|
||||
}
|
||||
|
||||
return output;
|
||||
};
|
||||
|
||||
function renderTag(elem, opts) {
|
||||
// Handle SVG
|
||||
if (elem.name === "svg") opts = {decodeEntities: opts.decodeEntities, xmlMode: true};
|
||||
|
||||
var tag = '<' + elem.name,
|
||||
attribs = formatAttrs(elem.attribs, opts);
|
||||
|
||||
if (attribs) {
|
||||
tag += ' ' + attribs;
|
||||
}
|
||||
|
||||
if (
|
||||
opts.xmlMode
|
||||
&& (!elem.children || elem.children.length === 0)
|
||||
) {
|
||||
tag += '/>';
|
||||
} else {
|
||||
tag += '>';
|
||||
if (elem.children) {
|
||||
tag += render(elem.children, opts);
|
||||
}
|
||||
|
||||
if (!singleTag[elem.name] || opts.xmlMode) {
|
||||
tag += '</' + elem.name + '>';
|
||||
}
|
||||
}
|
||||
|
||||
return tag;
|
||||
}
|
||||
|
||||
function renderDirective(elem) {
|
||||
return '<' + elem.data + '>';
|
||||
}
|
||||
|
||||
function renderText(elem, opts) {
|
||||
var data = elem.data || '';
|
||||
|
||||
// if entities weren't decoded, no need to encode them back
|
||||
if (opts.decodeEntities && !(elem.parent && elem.parent.name in unencodedElements)) {
|
||||
data = entities.encodeXML(data);
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function renderCdata(elem) {
|
||||
return '<![CDATA[' + elem.children[0].data + ']]>';
|
||||
}
|
||||
|
||||
function renderComment(elem) {
|
||||
return '<!--' + elem.data + '-->';
|
||||
}
|
||||
67
node_modules/cheerio/node_modules/dom-serializer/package.json
generated
vendored
Normal file
67
node_modules/cheerio/node_modules/dom-serializer/package.json
generated
vendored
Normal file
@ -0,0 +1,67 @@
|
||||
{
|
||||
"_from": "dom-serializer@~0.1.1",
|
||||
"_id": "dom-serializer@0.1.1",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-l0IU0pPzLWSHBcieZbpOKgkIn3ts3vAh7ZuFyXNwJxJXk/c4Gwj9xaTJwIDVQCXawWD0qb3IzMGH5rglQaO0XA==",
|
||||
"_location": "/cheerio/dom-serializer",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "dom-serializer@~0.1.1",
|
||||
"name": "dom-serializer",
|
||||
"escapedName": "dom-serializer",
|
||||
"rawSpec": "~0.1.1",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "~0.1.1"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/cheerio"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.1.tgz",
|
||||
"_shasum": "1ec4059e284babed36eec2941d4a970a189ce7c0",
|
||||
"_spec": "dom-serializer@~0.1.1",
|
||||
"_where": "/Users/stefanfejes/Projects/30-seconds-of-python-code/node_modules/cheerio",
|
||||
"author": {
|
||||
"name": "Felix Boehm",
|
||||
"email": "me@feedic.com"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/cheeriojs/dom-renderer/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"dependencies": {
|
||||
"domelementtype": "^1.3.0",
|
||||
"entities": "^1.1.1"
|
||||
},
|
||||
"deprecated": false,
|
||||
"description": "render dom nodes to string",
|
||||
"devDependencies": {
|
||||
"cheerio": "*",
|
||||
"expect.js": "^0.3.1",
|
||||
"jshint": "^2.9.1-rc1",
|
||||
"lodash": "^4.17.11",
|
||||
"mocha": "^5.2.0",
|
||||
"xyz": "^3.0.0"
|
||||
},
|
||||
"files": [
|
||||
"index.js"
|
||||
],
|
||||
"homepage": "https://github.com/cheeriojs/dom-renderer#readme",
|
||||
"keywords": [
|
||||
"html",
|
||||
"xml",
|
||||
"render"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "./index.js",
|
||||
"name": "dom-serializer",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/cheeriojs/dom-renderer.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "mocha test.js"
|
||||
},
|
||||
"version": "0.1.1"
|
||||
}
|
||||
5
node_modules/cheerio/node_modules/entities/.travis.yml
generated
vendored
Normal file
5
node_modules/cheerio/node_modules/entities/.travis.yml
generated
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
sudo: true
|
||||
language: node_js
|
||||
node_js:
|
||||
- 8
|
||||
script: npm run coveralls
|
||||
11
node_modules/cheerio/node_modules/entities/LICENSE
generated
vendored
Normal file
11
node_modules/cheerio/node_modules/entities/LICENSE
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
Copyright (c) Felix Böhm
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
|
||||
|
||||
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
|
||||
|
||||
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
26
node_modules/cheerio/node_modules/entities/index.js
generated
vendored
Normal file
26
node_modules/cheerio/node_modules/entities/index.js
generated
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
var encode = require("./lib/encode.js"),
|
||||
decode = require("./lib/decode.js");
|
||||
|
||||
exports.decode = function(data, level) {
|
||||
return (!level || level <= 0 ? decode.XML : decode.HTML)(data);
|
||||
};
|
||||
|
||||
exports.decodeStrict = function(data, level) {
|
||||
return (!level || level <= 0 ? decode.XML : decode.HTMLStrict)(data);
|
||||
};
|
||||
|
||||
exports.encode = function(data, level) {
|
||||
return (!level || level <= 0 ? encode.XML : encode.HTML)(data);
|
||||
};
|
||||
|
||||
exports.encodeXML = encode.XML;
|
||||
|
||||
exports.encodeHTML4 = exports.encodeHTML5 = exports.encodeHTML = encode.HTML;
|
||||
|
||||
exports.decodeXML = exports.decodeXMLStrict = decode.XML;
|
||||
|
||||
exports.decodeHTML4 = exports.decodeHTML5 = exports.decodeHTML = decode.HTML;
|
||||
|
||||
exports.decodeHTML4Strict = exports.decodeHTML5Strict = exports.decodeHTMLStrict = decode.HTMLStrict;
|
||||
|
||||
exports.escape = encode.escape;
|
||||
70
node_modules/cheerio/node_modules/entities/lib/decode.js
generated
vendored
Normal file
70
node_modules/cheerio/node_modules/entities/lib/decode.js
generated
vendored
Normal file
@ -0,0 +1,70 @@
|
||||
var entityMap = require("../maps/entities.json"),
|
||||
legacyMap = require("../maps/legacy.json"),
|
||||
xmlMap = require("../maps/xml.json"),
|
||||
decodeCodePoint = require("./decode_codepoint.js");
|
||||
|
||||
var decodeXMLStrict = getStrictDecoder(xmlMap),
|
||||
decodeHTMLStrict = getStrictDecoder(entityMap);
|
||||
|
||||
function getStrictDecoder(map) {
|
||||
var keys = Object.keys(map).join("|"),
|
||||
replace = getReplacer(map);
|
||||
|
||||
keys += "|#[xX][\\da-fA-F]+|#\\d+";
|
||||
|
||||
var re = new RegExp("&(?:" + keys + ");", "g");
|
||||
|
||||
return function(str) {
|
||||
return String(str).replace(re, replace);
|
||||
};
|
||||
}
|
||||
|
||||
var decodeHTML = (function() {
|
||||
var legacy = Object.keys(legacyMap).sort(sorter);
|
||||
|
||||
var keys = Object.keys(entityMap).sort(sorter);
|
||||
|
||||
for (var i = 0, j = 0; i < keys.length; i++) {
|
||||
if (legacy[j] === keys[i]) {
|
||||
keys[i] += ";?";
|
||||
j++;
|
||||
} else {
|
||||
keys[i] += ";";
|
||||
}
|
||||
}
|
||||
|
||||
var re = new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g"),
|
||||
replace = getReplacer(entityMap);
|
||||
|
||||
function replacer(str) {
|
||||
if (str.substr(-1) !== ";") str += ";";
|
||||
return replace(str);
|
||||
}
|
||||
|
||||
//TODO consider creating a merged map
|
||||
return function(str) {
|
||||
return String(str).replace(re, replacer);
|
||||
};
|
||||
})();
|
||||
|
||||
function sorter(a, b) {
|
||||
return a < b ? 1 : -1;
|
||||
}
|
||||
|
||||
function getReplacer(map) {
|
||||
return function replace(str) {
|
||||
if (str.charAt(1) === "#") {
|
||||
if (str.charAt(2) === "X" || str.charAt(2) === "x") {
|
||||
return decodeCodePoint(parseInt(str.substr(3), 16));
|
||||
}
|
||||
return decodeCodePoint(parseInt(str.substr(2), 10));
|
||||
}
|
||||
return map[str.slice(1, -1)];
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
XML: decodeXMLStrict,
|
||||
HTML: decodeHTML,
|
||||
HTMLStrict: decodeHTMLStrict
|
||||
};
|
||||
25
node_modules/cheerio/node_modules/entities/lib/decode_codepoint.js
generated
vendored
Normal file
25
node_modules/cheerio/node_modules/entities/lib/decode_codepoint.js
generated
vendored
Normal file
@ -0,0 +1,25 @@
|
||||
var decodeMap = require("../maps/decode.json");
|
||||
|
||||
module.exports = decodeCodePoint;
|
||||
|
||||
// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
|
||||
function decodeCodePoint(codePoint) {
|
||||
if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
|
||||
return "\uFFFD";
|
||||
}
|
||||
|
||||
if (codePoint in decodeMap) {
|
||||
codePoint = decodeMap[codePoint];
|
||||
}
|
||||
|
||||
var output = "";
|
||||
|
||||
if (codePoint > 0xffff) {
|
||||
codePoint -= 0x10000;
|
||||
output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
|
||||
codePoint = 0xdc00 | (codePoint & 0x3ff);
|
||||
}
|
||||
|
||||
output += String.fromCharCode(codePoint);
|
||||
return output;
|
||||
}
|
||||
82
node_modules/cheerio/node_modules/entities/lib/encode.js
generated
vendored
Normal file
82
node_modules/cheerio/node_modules/entities/lib/encode.js
generated
vendored
Normal file
@ -0,0 +1,82 @@
|
||||
var inverseXML = getInverseObj(require("../maps/xml.json")),
|
||||
xmlReplacer = getInverseReplacer(inverseXML);
|
||||
|
||||
exports.XML = getInverse(inverseXML, xmlReplacer);
|
||||
|
||||
var inverseHTML = getInverseObj(require("../maps/entities.json")),
|
||||
htmlReplacer = getInverseReplacer(inverseHTML);
|
||||
|
||||
exports.HTML = getInverse(inverseHTML, htmlReplacer);
|
||||
|
||||
function getInverseObj(obj) {
|
||||
return Object.keys(obj)
|
||||
.sort()
|
||||
.reduce(function(inverse, name) {
|
||||
inverse[obj[name]] = "&" + name + ";";
|
||||
return inverse;
|
||||
}, {});
|
||||
}
|
||||
|
||||
function getInverseReplacer(inverse) {
|
||||
var single = [],
|
||||
multiple = [];
|
||||
|
||||
Object.keys(inverse).forEach(function(k) {
|
||||
if (k.length === 1) {
|
||||
single.push("\\" + k);
|
||||
} else {
|
||||
multiple.push(k);
|
||||
}
|
||||
});
|
||||
|
||||
//TODO add ranges
|
||||
multiple.unshift("[" + single.join("") + "]");
|
||||
|
||||
return new RegExp(multiple.join("|"), "g");
|
||||
}
|
||||
|
||||
var re_nonASCII = /[^\0-\x7F]/g,
|
||||
re_astralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
|
||||
|
||||
function singleCharReplacer(c) {
|
||||
return (
|
||||
"&#x" +
|
||||
c
|
||||
.charCodeAt(0)
|
||||
.toString(16)
|
||||
.toUpperCase() +
|
||||
";"
|
||||
);
|
||||
}
|
||||
|
||||
function astralReplacer(c) {
|
||||
// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
|
||||
var high = c.charCodeAt(0);
|
||||
var low = c.charCodeAt(1);
|
||||
var codePoint = (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000;
|
||||
return "&#x" + codePoint.toString(16).toUpperCase() + ";";
|
||||
}
|
||||
|
||||
function getInverse(inverse, re) {
|
||||
function func(name) {
|
||||
return inverse[name];
|
||||
}
|
||||
|
||||
return function(data) {
|
||||
return data
|
||||
.replace(re, func)
|
||||
.replace(re_astralSymbols, astralReplacer)
|
||||
.replace(re_nonASCII, singleCharReplacer);
|
||||
};
|
||||
}
|
||||
|
||||
var re_xmlChars = getInverseReplacer(inverseXML);
|
||||
|
||||
function escapeXML(data) {
|
||||
return data
|
||||
.replace(re_xmlChars, singleCharReplacer)
|
||||
.replace(re_astralSymbols, astralReplacer)
|
||||
.replace(re_nonASCII, singleCharReplacer);
|
||||
}
|
||||
|
||||
exports.escape = escapeXML;
|
||||
1
node_modules/cheerio/node_modules/entities/maps/decode.json
generated
vendored
Normal file
1
node_modules/cheerio/node_modules/entities/maps/decode.json
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"0":65533,"128":8364,"130":8218,"131":402,"132":8222,"133":8230,"134":8224,"135":8225,"136":710,"137":8240,"138":352,"139":8249,"140":338,"142":381,"145":8216,"146":8217,"147":8220,"148":8221,"149":8226,"150":8211,"151":8212,"152":732,"153":8482,"154":353,"155":8250,"156":339,"158":382,"159":376}
|
||||
1
node_modules/cheerio/node_modules/entities/maps/entities.json
generated
vendored
Normal file
1
node_modules/cheerio/node_modules/entities/maps/entities.json
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
1
node_modules/cheerio/node_modules/entities/maps/legacy.json
generated
vendored
Normal file
1
node_modules/cheerio/node_modules/entities/maps/legacy.json
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"Aacute":"\u00C1","aacute":"\u00E1","Acirc":"\u00C2","acirc":"\u00E2","acute":"\u00B4","AElig":"\u00C6","aelig":"\u00E6","Agrave":"\u00C0","agrave":"\u00E0","amp":"&","AMP":"&","Aring":"\u00C5","aring":"\u00E5","Atilde":"\u00C3","atilde":"\u00E3","Auml":"\u00C4","auml":"\u00E4","brvbar":"\u00A6","Ccedil":"\u00C7","ccedil":"\u00E7","cedil":"\u00B8","cent":"\u00A2","copy":"\u00A9","COPY":"\u00A9","curren":"\u00A4","deg":"\u00B0","divide":"\u00F7","Eacute":"\u00C9","eacute":"\u00E9","Ecirc":"\u00CA","ecirc":"\u00EA","Egrave":"\u00C8","egrave":"\u00E8","ETH":"\u00D0","eth":"\u00F0","Euml":"\u00CB","euml":"\u00EB","frac12":"\u00BD","frac14":"\u00BC","frac34":"\u00BE","gt":">","GT":">","Iacute":"\u00CD","iacute":"\u00ED","Icirc":"\u00CE","icirc":"\u00EE","iexcl":"\u00A1","Igrave":"\u00CC","igrave":"\u00EC","iquest":"\u00BF","Iuml":"\u00CF","iuml":"\u00EF","laquo":"\u00AB","lt":"<","LT":"<","macr":"\u00AF","micro":"\u00B5","middot":"\u00B7","nbsp":"\u00A0","not":"\u00AC","Ntilde":"\u00D1","ntilde":"\u00F1","Oacute":"\u00D3","oacute":"\u00F3","Ocirc":"\u00D4","ocirc":"\u00F4","Ograve":"\u00D2","ograve":"\u00F2","ordf":"\u00AA","ordm":"\u00BA","Oslash":"\u00D8","oslash":"\u00F8","Otilde":"\u00D5","otilde":"\u00F5","Ouml":"\u00D6","ouml":"\u00F6","para":"\u00B6","plusmn":"\u00B1","pound":"\u00A3","quot":"\"","QUOT":"\"","raquo":"\u00BB","reg":"\u00AE","REG":"\u00AE","sect":"\u00A7","shy":"\u00AD","sup1":"\u00B9","sup2":"\u00B2","sup3":"\u00B3","szlig":"\u00DF","THORN":"\u00DE","thorn":"\u00FE","times":"\u00D7","Uacute":"\u00DA","uacute":"\u00FA","Ucirc":"\u00DB","ucirc":"\u00FB","Ugrave":"\u00D9","ugrave":"\u00F9","uml":"\u00A8","Uuml":"\u00DC","uuml":"\u00FC","Yacute":"\u00DD","yacute":"\u00FD","yen":"\u00A5","yuml":"\u00FF"}
|
||||
1
node_modules/cheerio/node_modules/entities/maps/xml.json
generated
vendored
Normal file
1
node_modules/cheerio/node_modules/entities/maps/xml.json
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"amp":"&","apos":"'","gt":">","lt":"<","quot":"\""}
|
||||
90
node_modules/cheerio/node_modules/entities/package.json
generated
vendored
Normal file
90
node_modules/cheerio/node_modules/entities/package.json
generated
vendored
Normal file
@ -0,0 +1,90 @@
|
||||
{
|
||||
"_from": "entities@~1.1.1",
|
||||
"_id": "entities@1.1.2",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==",
|
||||
"_location": "/cheerio/entities",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "entities@~1.1.1",
|
||||
"name": "entities",
|
||||
"escapedName": "entities",
|
||||
"rawSpec": "~1.1.1",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "~1.1.1"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/cheerio",
|
||||
"/cheerio/dom-serializer"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/entities/-/entities-1.1.2.tgz",
|
||||
"_shasum": "bdfa735299664dfafd34529ed4f8522a275fea56",
|
||||
"_spec": "entities@~1.1.1",
|
||||
"_where": "/Users/stefanfejes/Projects/30-seconds-of-python-code/node_modules/cheerio",
|
||||
"author": {
|
||||
"name": "Felix Boehm",
|
||||
"email": "me@feedic.com"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/fb55/entities/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"deprecated": false,
|
||||
"description": "Encode & decode XML/HTML entities with ease",
|
||||
"devDependencies": {
|
||||
"coveralls": "*",
|
||||
"istanbul": "*",
|
||||
"jshint": "2",
|
||||
"mocha": "^5.0.1",
|
||||
"mocha-lcov-reporter": "*"
|
||||
},
|
||||
"directories": {
|
||||
"test": "test"
|
||||
},
|
||||
"homepage": "https://github.com/fb55/entities#readme",
|
||||
"jshintConfig": {
|
||||
"eqeqeq": true,
|
||||
"freeze": true,
|
||||
"latedef": "nofunc",
|
||||
"noarg": true,
|
||||
"nonbsp": true,
|
||||
"quotmark": "double",
|
||||
"undef": true,
|
||||
"unused": true,
|
||||
"trailing": true,
|
||||
"eqnull": true,
|
||||
"proto": true,
|
||||
"smarttabs": true,
|
||||
"node": true,
|
||||
"globals": {
|
||||
"describe": true,
|
||||
"it": true
|
||||
}
|
||||
},
|
||||
"keywords": [
|
||||
"html",
|
||||
"xml",
|
||||
"entity",
|
||||
"decoding",
|
||||
"encoding"
|
||||
],
|
||||
"license": "BSD-2-Clause",
|
||||
"main": "./index.js",
|
||||
"name": "entities",
|
||||
"prettier": {
|
||||
"tabWidth": 4
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/fb55/entities.git"
|
||||
},
|
||||
"scripts": {
|
||||
"coveralls": "npm run lint && npm run lcov && (cat coverage/lcov.info | coveralls || exit 0)",
|
||||
"lcov": "istanbul cover _mocha --report lcovonly -- -R spec",
|
||||
"lint": "jshint index.js lib/*.js test/*.js",
|
||||
"test": "mocha && npm run lint"
|
||||
},
|
||||
"version": "1.1.2"
|
||||
}
|
||||
27
node_modules/cheerio/node_modules/entities/readme.md
generated
vendored
Normal file
27
node_modules/cheerio/node_modules/entities/readme.md
generated
vendored
Normal file
@ -0,0 +1,27 @@
|
||||
# entities [](https://npmjs.org/package/entities) [](https://npmjs.org/package/entities) [](http://travis-ci.org/fb55/entities) [](https://coveralls.io/r/fb55/entities)
|
||||
|
||||
En- & decoder for XML/HTML entities.
|
||||
|
||||
## How to…
|
||||
|
||||
### …install `entities`
|
||||
|
||||
npm i entities
|
||||
|
||||
### …use `entities`
|
||||
|
||||
```javascript
|
||||
var entities = require("entities");
|
||||
//encoding
|
||||
entities.encodeXML("&"); // "&#38;"
|
||||
entities.encodeHTML("&"); // "&#38;"
|
||||
//decoding
|
||||
entities.decodeXML("asdf & ÿ ü '"); // "asdf & ÿ ü '"
|
||||
entities.decodeHTML("asdf & ÿ ü '"); // "asdf & ÿ ü '"
|
||||
```
|
||||
|
||||
<!-- TODO extend API -->
|
||||
|
||||
---
|
||||
|
||||
License: BSD-2-Clause
|
||||
2
node_modules/cheerio/node_modules/entities/test/mocha.opts
generated
vendored
Normal file
2
node_modules/cheerio/node_modules/entities/test/mocha.opts
generated
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
--check-leaks
|
||||
--reporter spec
|
||||
170
node_modules/cheerio/node_modules/entities/test/test.js
generated
vendored
Normal file
170
node_modules/cheerio/node_modules/entities/test/test.js
generated
vendored
Normal file
@ -0,0 +1,170 @@
|
||||
var assert = require("assert"),
|
||||
path = require("path"),
|
||||
entities = require("../");
|
||||
|
||||
describe("Encode->decode test", function() {
|
||||
var testcases = [
|
||||
{
|
||||
input: "asdf & ÿ ü '",
|
||||
xml: "asdf & ÿ ü '",
|
||||
html: "asdf & ÿ ü '"
|
||||
},
|
||||
{
|
||||
input: "&",
|
||||
xml: "&#38;",
|
||||
html: "&#38;"
|
||||
}
|
||||
];
|
||||
testcases.forEach(function(tc) {
|
||||
var encodedXML = entities.encodeXML(tc.input);
|
||||
it("should XML encode " + tc.input, function() {
|
||||
assert.equal(encodedXML, tc.xml);
|
||||
});
|
||||
it("should default to XML encode " + tc.input, function() {
|
||||
assert.equal(entities.encode(tc.input), tc.xml);
|
||||
});
|
||||
it("should XML decode " + encodedXML, function() {
|
||||
assert.equal(entities.decodeXML(encodedXML), tc.input);
|
||||
});
|
||||
it("should default to XML encode " + encodedXML, function() {
|
||||
assert.equal(entities.decode(encodedXML), tc.input);
|
||||
});
|
||||
it("should default strict to XML encode " + encodedXML, function() {
|
||||
assert.equal(entities.decodeStrict(encodedXML), tc.input);
|
||||
});
|
||||
|
||||
var encodedHTML5 = entities.encodeHTML5(tc.input);
|
||||
it("should HTML5 encode " + tc.input, function() {
|
||||
assert.equal(encodedHTML5, tc.html);
|
||||
});
|
||||
it("should HTML5 decode " + encodedHTML5, function() {
|
||||
assert.equal(entities.decodeHTML(encodedHTML5), tc.input);
|
||||
});
|
||||
});
|
||||
|
||||
it("should encode data URIs (issue 16)", function() {
|
||||
var data = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAALAAABAAEAAAIBRAA7";
|
||||
assert.equal(entities.decode(entities.encode(data)), data);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Decode test", function() {
|
||||
var testcases = [
|
||||
{ input: "&amp;", output: "&" },
|
||||
{ input: "&#38;", output: "&" },
|
||||
{ input: "&#x26;", output: "&" },
|
||||
{ input: "&#X26;", output: "&" },
|
||||
{ input: "&#38;", output: "&" },
|
||||
{ input: "&#38;", output: "&" },
|
||||
{ input: "&#38;", output: "&" },
|
||||
{ input: ":", output: ":" },
|
||||
{ input: ":", output: ":" },
|
||||
{ input: ":", output: ":" },
|
||||
{ input: ":", output: ":" }
|
||||
];
|
||||
testcases.forEach(function(tc) {
|
||||
it("should XML decode " + tc.input, function() {
|
||||
assert.equal(entities.decodeXML(tc.input), tc.output);
|
||||
});
|
||||
it("should HTML4 decode " + tc.input, function() {
|
||||
assert.equal(entities.decodeHTML(tc.input), tc.output);
|
||||
});
|
||||
it("should HTML5 decode " + tc.input, function() {
|
||||
assert.equal(entities.decodeHTML(tc.input), tc.output);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
var levels = ["xml", "entities"];
|
||||
|
||||
describe("Documents", function() {
|
||||
levels
|
||||
.map(function(n) {
|
||||
return path.join("..", "maps", n);
|
||||
})
|
||||
.map(require)
|
||||
.forEach(function(doc, i) {
|
||||
describe("Decode", function() {
|
||||
it(levels[i], function() {
|
||||
Object.keys(doc).forEach(function(e) {
|
||||
for (var l = i; l < levels.length; l++) {
|
||||
assert.equal(entities.decode("&" + e + ";", l), doc[e]);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Decode strict", function() {
|
||||
it(levels[i], function() {
|
||||
Object.keys(doc).forEach(function(e) {
|
||||
for (var l = i; l < levels.length; l++) {
|
||||
assert.equal(entities.decodeStrict("&" + e + ";", l), doc[e]);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Encode", function() {
|
||||
it(levels[i], function() {
|
||||
Object.keys(doc).forEach(function(e) {
|
||||
for (var l = i; l < levels.length; l++) {
|
||||
assert.equal(entities.decode(entities.encode(doc[e], l), l), doc[e]);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
var legacy = require("../maps/legacy.json");
|
||||
|
||||
describe("Legacy", function() {
|
||||
it("should decode", runLegacy);
|
||||
});
|
||||
|
||||
function runLegacy() {
|
||||
Object.keys(legacy).forEach(function(e) {
|
||||
assert.equal(entities.decodeHTML("&" + e), legacy[e]);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
var astral = {
|
||||
"1D306": "\uD834\uDF06",
|
||||
"1D11E": "\uD834\uDD1E"
|
||||
};
|
||||
|
||||
var astralSpecial = {
|
||||
"80": "\u20AC",
|
||||
"110000": "\uFFFD"
|
||||
};
|
||||
|
||||
describe("Astral entities", function() {
|
||||
Object.keys(astral).forEach(function(c) {
|
||||
it("should decode " + astral[c], function() {
|
||||
assert.equal(entities.decode("&#x" + c + ";"), astral[c]);
|
||||
});
|
||||
|
||||
it("should encode " + astral[c], function() {
|
||||
assert.equal(entities.encode(astral[c]), "&#x" + c + ";");
|
||||
});
|
||||
|
||||
it("should escape " + astral[c], function() {
|
||||
assert.equal(entities.escape(astral[c]), "&#x" + c + ";");
|
||||
});
|
||||
});
|
||||
|
||||
Object.keys(astralSpecial).forEach(function(c) {
|
||||
it("special should decode \\u" + c, function() {
|
||||
assert.equal(entities.decode("&#x" + c + ";"), astralSpecial[c]);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Escape", function() {
|
||||
it("should always decode ASCII chars", function() {
|
||||
for (var i = 0; i < 0x7f; i++) {
|
||||
var c = String.fromCharCode(i);
|
||||
assert.equal(entities.decodeXML(entities.escape(c)), c);
|
||||
}
|
||||
});
|
||||
});
|
||||
86
node_modules/cheerio/package.json
generated
vendored
Normal file
86
node_modules/cheerio/package.json
generated
vendored
Normal file
@ -0,0 +1,86 @@
|
||||
{
|
||||
"_from": "cheerio@^1.0.0-rc.2",
|
||||
"_id": "cheerio@1.0.0-rc.3",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-0td5ijfUPuubwLUu0OBoe98gZj8C/AA+RW3v67GPlGOrvxWjZmBXiBCRU+I8VEiNyJzjth40POfHiz2RB3gImA==",
|
||||
"_location": "/cheerio",
|
||||
"_phantomChildren": {
|
||||
"domelementtype": "1.3.1"
|
||||
},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "cheerio@^1.0.0-rc.2",
|
||||
"name": "cheerio",
|
||||
"escapedName": "cheerio",
|
||||
"rawSpec": "^1.0.0-rc.2",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "^1.0.0-rc.2"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/gatsby-plugin-offline",
|
||||
"/gatsby-remark-copy-linked-files",
|
||||
"/gatsby-remark-images"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.3.tgz",
|
||||
"_shasum": "094636d425b2e9c0f4eb91a46c05630c9a1a8bf6",
|
||||
"_spec": "cheerio@^1.0.0-rc.2",
|
||||
"_where": "/Users/stefanfejes/Projects/30-seconds-of-python-code/node_modules/gatsby-plugin-offline",
|
||||
"author": {
|
||||
"name": "Matt Mueller",
|
||||
"email": "mattmuelle@gmail.com",
|
||||
"url": "mat.io"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/cheeriojs/cheerio/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"dependencies": {
|
||||
"css-select": "~1.2.0",
|
||||
"dom-serializer": "~0.1.1",
|
||||
"entities": "~1.1.1",
|
||||
"htmlparser2": "^3.9.1",
|
||||
"lodash": "^4.15.0",
|
||||
"parse5": "^3.0.1"
|
||||
},
|
||||
"deprecated": false,
|
||||
"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": "^3.1.2",
|
||||
"xyz": "~1.1.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 0.6"
|
||||
},
|
||||
"files": [
|
||||
"index.js",
|
||||
"lib"
|
||||
],
|
||||
"homepage": "https://github.com/cheeriojs/cheerio#readme",
|
||||
"keywords": [
|
||||
"htmlparser",
|
||||
"jquery",
|
||||
"selector",
|
||||
"scraper",
|
||||
"parser",
|
||||
"html"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "./index.js",
|
||||
"name": "cheerio",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/cheeriojs/cheerio.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "make test"
|
||||
},
|
||||
"version": "1.0.0-rc.3"
|
||||
}
|
||||
Reference in New Issue
Block a user