{ "mode": "perldoc", "parameter": "HTML::Element", "section": "", "url": "https://www.chedong.com/phpMan.php/perldoc/HTML%3A%3AElement/json", "generated": "2026-06-11T05:35:28Z", "synopsis": "use HTML::Element;\n$a = HTML::Element->new('a', href => 'http://www.perl.com/');\n$a->pushcontent(\"The Perl Homepage\");\n$tag = $a->tag;\nprint \"$tag starts out as:\", $a->starttag, \"\\n\";\nprint \"$tag ends as:\", $a->endtag, \"\\n\";\nprint \"$tag\\'s href attribute is: \", $a->attr('href'), \"\\n\";\n$linksr = $a->extractlinks();\nprint \"Hey, I found \", scalar(@$linksr), \" links.\\n\";\nprint \"And that, as HTML, is: \", $a->asHTML, \"\\n\";\n$a = $a->delete;", "sections": { "NAME": { "content": "HTML::Element - Class for objects that represent HTML elements\n", "subsections": [] }, "VERSION": { "content": "This document describes version 5.07 of HTML::Element, released August 31, 2017 as part of\nHTML-Tree.\n", "subsections": [] }, "SYNOPSIS": { "content": "use HTML::Element;\n$a = HTML::Element->new('a', href => 'http://www.perl.com/');\n$a->pushcontent(\"The Perl Homepage\");\n\n$tag = $a->tag;\nprint \"$tag starts out as:\", $a->starttag, \"\\n\";\nprint \"$tag ends as:\", $a->endtag, \"\\n\";\nprint \"$tag\\'s href attribute is: \", $a->attr('href'), \"\\n\";\n\n$linksr = $a->extractlinks();\nprint \"Hey, I found \", scalar(@$linksr), \" links.\\n\";\n\nprint \"And that, as HTML, is: \", $a->asHTML, \"\\n\";\n$a = $a->delete;\n", "subsections": [] }, "DESCRIPTION": { "content": "(This class is part of the HTML::Tree dist.)\n\nObjects of the HTML::Element class can be used to represent elements of HTML document trees.\nThese objects have attributes, notably attributes that designates each element's parent and\ncontent. The content is an array of text segments and other HTML::Element objects. A tree with\nHTML::Element objects as nodes can represent the syntax tree for a HTML document.\n", "subsections": [] }, "HOW WE REPRESENT TREES": { "content": "Consider this HTML document:\n\n\n\nStuff\n\n\n\n

I like potatoes!

\n\n\n\nBuilding a syntax tree out of it makes a tree-structure in memory that could be diagrammed as:\n\nhtml (lang='en-US')\n/ \\\n/ \\\n/ \\\nhead body\n/\\ \\\n/ \\ \\\n/ \\ \\\ntitle meta h1\n| (name='author', |\n\"Stuff\" content='Jojo') \"I like potatoes\"\n\nThis is the traditional way to diagram a tree, with the \"root\" at the top, and it's this kind of\ndiagram that people have in mind when they say, for example, that \"the meta element is under the\nhead element instead of under the body element\". (The same is also said with \"inside\" instead of\n\"under\" -- the use of \"inside\" makes more sense when you're looking at the HTML source.)\n\nAnother way to represent the above tree is with indenting:\n\nhtml (attributes: lang='en-US')\nhead\ntitle\n\"Stuff\"\nmeta (attributes: name='author' content='Jojo')\nbody\nh1\n\"I like potatoes\"\n\nIncidentally, diagramming with indenting works much better for very large trees, and is easier\nfor a program to generate. The \"$tree->dump\" method uses indentation just that way.\n\nHowever you diagram the tree, it's stored the same in memory -- it's a network of objects, each\nof which has attributes like so:\n\nelement #1: tag: 'html'\nparent: none\ncontent: [element #2, element #5]\nlang: 'en-US'\n\nelement #2: tag: 'head'\nparent: element #1\ncontent: [element #3, element #4]\n\nelement #3: tag: 'title'\nparent: element #2\ncontent: [text segment \"Stuff\"]\n\nelement #4 tag: 'meta'\nparent: element #2\ncontent: none\nname: author\ncontent: Jojo\n\nelement #5 tag: 'body'\nparent: element #1\ncontent: [element #6]\n\nelement #6 tag: 'h1'\nparent: element #5\ncontent: [text segment \"I like potatoes\"]\n\nThe \"treeness\" of the tree-structure that these elements comprise is not an aspect of any\nparticular object, but is emergent from the relatedness attributes (parent and content) of\nthese element-objects and from how you use them to get from element to element.\n\nWhile you could access the content of a tree by writing code that says \"access the 'src'\nattribute of the root's *first* child's *seventh* child's *third* child\", you're more likely to\nhave to scan the contents of a tree, looking for whatever nodes, or kinds of nodes, you want to\ndo something with. The most straightforward way to look over a tree is to \"traverse\" it; an\nHTML::Element method (\"$h->traverse\") is provided for this purpose; and several other\nHTML::Element methods are based on it.\n\n(For everything you ever wanted to know about trees, and then some, see Niklaus Wirth's\n*Algorithms + Data Structures = Programs* or Donald Knuth's *The Art of Computer Programming,\nVolume 1*.)\n", "subsections": [ { "name": "Weak References", "content": "TL;DR summary: \"use HTML::TreeBuilder 5 -weak;\" and forget about the \"delete\" method (except for\npruning a node from a tree).\n\nBecause HTML::Element stores a reference to the parent element, Perl's reference-count garbage\ncollection doesn't work properly with HTML::Element trees. Starting with version 5.00,\nHTML::Element uses weak references (if available) to prevent that problem. Weak references were\nintroduced in Perl 5.6.0, but you also need a version of Scalar::Util that provides the \"weaken\"\nfunction.\n\nWeak references are enabled by default. If you want to be certain they're in use, you can say\n\"use HTML::Element 5 -weak;\". You must include the version number; previous versions of\nHTML::Element ignored the import list entirely.\n\nTo disable weak references, you can say \"use HTML::Element -noweak;\". This is a global setting.\nThis feature is deprecated and is provided only as a quick fix for broken code. If your code\ndoes not work properly with weak references, you should fix it immediately, as weak references\nmay become mandatory in a future version. Generally, all you need to do is keep a reference to\nthe root of the tree until you're done working with it.\n\nBecause HTML::TreeBuilder is a subclass of HTML::Element, you can also import \"-weak\" or\n\"-noweak\" from HTML::TreeBuilder: e.g. \"use HTML::TreeBuilder: 5 -weak;\".\n" } ] }, "BASIC METHODS": { "content": "new\n$h = HTML::Element->new('tag', 'attrname' => 'value', ... );\n\nThis constructor method returns a new HTML::Element object. The tag name is a required argument;\nit will be forced to lowercase. Optionally, you can specify other initial attributes at object\ncreation time.\n\nattr\n$value = $h->attr('attr');\n$oldvalue = $h->attr('attr', $newvalue);\n\nReturns (optionally sets) the value of the given attribute of $h. The attribute name (but not\nthe value, if provided) is forced to lowercase. If trying to read the value of an attribute not\npresent for this element, the return value is undef. If setting a new value, the old value of\nthat attribute is returned.\n\nIf methods are provided for accessing an attribute (like \"$h->tag\" for \"tag\",\n\"$h->contentlist\", etc. below), use those instead of calling attr \"$h->attr\", whether for\nreading or setting.\n\nNote that setting an attribute to \"undef\" (as opposed to \"\", the empty string) actually deletes\nthe attribute.\n\ntag\n$tagname = $h->tag();\n$h->tag('tagname');\n\nReturns (optionally sets) the tag name (also known as the generic identifier) for the element\n$h. In setting, the tag name is always converted to lower case.\n\nThere are four kinds of \"pseudo-elements\" that show up as HTML::Element objects:\n\nComment pseudo-elements\nThese are element objects with a \"$h->tag\" value of \"~comment\", and the content of the\ncomment is stored in the \"text\" attribute (\"$h->attr(\"text\")\"). For example, parsing this\ncode with HTML::TreeBuilder...\n\n\n\nproduces an HTML::Element object with these attributes:\n\n\"tag\",\n\"~comment\",\n\"text\",\n\" I like Pie.\\n Pie is good\\n \"\n\nDeclaration pseudo-elements\nDeclarations (rarely encountered) are represented as HTML::Element objects with a tag name\nof \"~declaration\", and content in the \"text\" attribute. For example, this:\n\n\n\nproduces an element whose attributes include:\n\n\"tag\", \"~declaration\", \"text\", \"DOCTYPE foo\"\n\nProcessing instruction pseudo-elements\nPIs (rarely encountered) are represented as HTML::Element objects with a tag name of \"~pi\",\nand content in the \"text\" attribute. For example, this:\n\n\n\nproduces an element whose attributes include:\n\n\"tag\", \"~pi\", \"text\", \"stuff foo?\"\n\n(assuming a recent version of HTML::Parser)\n\n~literal pseudo-elements\nThese objects are not currently produced by HTML::TreeBuilder, but can be used to represent\na \"super-literal\" -- i.e., a literal you want to be immune from escaping. (Yes, I just made\nthat term up.)\n\nThat is, this is useful if you want to insert code into a tree that you plan to dump out\nwith \"asHTML\", where you want, for some reason, to suppress \"asHTML\"'s normal behavior of\namp-quoting text segments.\n\nFor example, this:\n\nmy $literal = HTML::Element->new('~literal',\n'text' => 'x < 4 & y > 7'\n);\nmy $span = HTML::Element->new('span');\n$span->pushcontent($literal);\nprint $span->asHTML;\n\nprints this:\n\nx < 4 & y > 7\n\nWhereas this:\n\nmy $span = HTML::Element->new('span');\n$span->pushcontent('x < 4 & y > 7');\n# normal text segment\nprint $span->asHTML;\n\nprints this:\n\nx < 4 & y > 7\n\nUnless you're inserting lots of pre-cooked code into existing trees, and dumping them out\nagain, it's not likely that you'll find \"~literal\" pseudo-elements useful.\n\nparent\n$parent = $h->parent();\n$h->parent($newparent);\n\nReturns (optionally sets) the parent (aka \"container\") for this element. The parent should\neither be undef, or should be another element.\n\nYou should not use this to directly set the parent of an element. Instead use any of the other\nmethods under \"Structure-Modifying Methods\", below.\n\nNote that \"not($h->parent)\" is a simple test for whether $h is the root of its subtree.\n\ncontentlist\n@content = $h->contentlist();\n$numchildren = $h->contentlist();\n\nReturns a list of the child nodes of this element -- i.e., what nodes (elements or text\nsegments) are inside/under this element. (Note that this may be an empty list.)\n\nIn a scalar context, this returns the count of the items, as you may expect.\n\ncontent\n$contentarrayref = $h->content(); # may return undef\n\nThis somewhat deprecated method returns the content of this element; but unlike contentlist,\nthis returns either undef (which you should understand to mean no content), or a *reference to\nthe array* of content items, each of which is either a text segment (a string, i.e., a defined\nnon-reference scalar value), or an HTML::Element object. Note that even if an arrayref is\nreturned, it may be a reference to an empty array.\n\nWhile older code should feel free to continue to use \"$h->content\", new code should use\n\"$h->contentlist\" in almost all conceivable cases. It is my experience that in most cases this\nleads to simpler code anyway, since it means one can say:\n\n@children = $h->contentlist;\n\ninstead of the inelegant:\n\n@children = @{$h->content || []};\n\nIf you do use \"$h->content\" (or \"$h->contentarrayref\"), you should not use the reference\nreturned by it (assuming it returned a reference, and not undef) to directly set or change the\ncontent of an element or text segment! Instead use contentrefslist or any of the other methods\nunder \"Structure-Modifying Methods\", below.\n\ncontentarrayref\n$contentarrayref = $h->contentarrayref(); # never undef\n\nThis is like \"content\" (with all its caveats and deprecations) except that it is guaranteed to\nreturn an array reference. That is, if the given node has no \"content\" attribute, the \"content\"\nmethod would return that undef, but \"contentarrayref\" would set the given node's \"content\"\nvalue to \"[]\" (a reference to a new, empty array), and return that.\n\ncontentrefslist\n@contentrefs = $h->contentrefslist;\n\nThis returns a list of scalar references to each element of $h's content list. This is useful in\ncase you want to in-place edit any large text segments without having to get a copy of the\ncurrent value of that segment value, modify that copy, then use the \"splicecontent\" to replace\nthe old with the new. Instead, here you can in-place edit:\n\nforeach my $itemr ($h->contentrefslist) {\nnext if ref $$itemr;\n$$itemr =~ s/honour/honor/g;\n}\n\nYou *could* currently achieve the same affect with:\n\nforeach my $item (@{ $h->contentarrayref }) {\n# deprecated!\nnext if ref $item;\n$item =~ s/honour/honor/g;\n}\n\n...except that using the return value of \"$h->content\" or \"$h->contentarrayref\" to do that is\ndeprecated, and just might stop working in the future.\n\nimplicit\n$isimplicit = $h->implicit();\n$h->implicit($makeimplicit);\n\nReturns (optionally sets) the \"implicit\" attribute. This attribute is a flag that's used for\nindicating that the element was not originally present in the source, but was added to the parse\ntree (by HTML::TreeBuilder, for example) in order to conform to the rules of HTML structure.\n\npos\n$pos = $h->pos();\n$h->pos($element);\n\nReturns (and optionally sets) the \"pos\" (for \"current *pos*ition\") pointer of $h. This\nattribute is a pointer used during some parsing operations, whose value is whatever\nHTML::Element element at or under $h is currently \"open\", where \"$h->insertelement(NEW)\" will\nactually insert a new element.\n\n(This has nothing to do with the Perl function called \"pos\", for controlling where regular\nexpression matching starts.)\n\nIf you set \"$h->pos($element)\", be sure that $element is either $h, or an element under $h.\n\nIf you've been modifying the tree under $h and are no longer sure \"$h->pos\" is valid, you can\nenforce validity with:\n\n$h->pos(undef) unless $h->pos->isinside($h);\n\nallattr\n%attr = $h->allattr();\n\nReturns all this element's attributes and values, as key-value pairs. This will include any\n\"internal\" attributes (i.e., ones not present in the original element, and which will not be\nrepresented if/when you call \"$h->asHTML\"). Internal attributes are distinguished by the fact\nthat the first character of their key (not value! key!) is an underscore (\"\").\n\nExample output of \"$h->allattr()\" : \"'parent', \"*[objectvalue]*\" , 'tag', 'em', 'lang',\n'en-US', 'content', \"*[array-ref value]*.\n\nallattrnames\n@names = $h->allattrnames();\n$numattrs = $h->allattrnames();\n\nLike \"allattr\", but only returns the names of the attributes. In scalar context, returns the\nnumber of attributes.\n\nExample output of \"$h->allattrnames()\" : \"'parent', 'tag', 'lang', 'content', \".\n\nallexternalattr\n%attr = $h->allexternalattr();\n\nLike \"allattr\", except that internal attributes are not present.\n\nallexternalattrnames\n@names = $h->allexternalattrnames();\n$numattrs = $h->allexternalattrnames();\n\nLike \"allattrnames\", except that internal attributes' names are not present (or counted).\n\nid\n$id = $h->id();\n$h->id($string);\n\nReturns (optionally sets to $string) the \"id\" attribute. \"$h->id(undef)\" deletes the \"id\"\nattribute.\n\n\"$h->id(...)\" is basically equivalent to \"$h->attr('id', ...)\", except that when setting the\nattribute, this method returns the new value, not the old value.\n\nidf\n$id = $h->idf();\n$h->idf($string);\n\nJust like the \"id\" method, except that if you call \"$h->idf()\" and no \"id\" attribute is defined\nfor this element, then it's set to a likely-to-be-unique value, and returned. (The \"f\" is for\n\"force\".)\n", "subsections": [] }, "STRUCTURE-MODIFYING METHODS": { "content": "These methods are provided for modifying the content of trees by adding or changing nodes as\nparents or children of other nodes.\n\npushcontent\n$h->pushcontent($elementortext, ...);\n\nAdds the specified items to the *end* of the content list of the element $h. The items of\ncontent to be added should each be either a text segment (a string), an HTML::Element object, or\nan arrayref. Arrayrefs are fed thru \"$h->newfromlol(thatarrayref)\" to convert them into\nelements, before being added to the content list of $h. This means you can say things concise\nthings like:\n\n$body->pushcontent(\n['br'],\n['ul',\nmap ['li', $], qw(Peaches Apples Pears Mangos)\n]\n);\n\nSee the \"newfromlol\" method's documentation, far below, for more explanation.\n\nReturns $h (the element itself).\n\nThe pushcontent method will try to consolidate adjacent text segments while adding to the\ncontent list. That's to say, if $h's \"contentlist\" is\n\n('foo bar ', $somenode, 'baz!')\n\nand you call\n\n$h->pushcontent('quack?');\n\nthen the resulting content list will be this:\n\n('foo bar ', $somenode, 'baz!quack?')\n\nand not this:\n\n('foo bar ', $somenode, 'baz!', 'quack?')\n\nIf that latter is what you want, you'll have to override the feature of consolidating text by\nusing splicecontent, as in:\n\n$h->splicecontent(scalar($h->contentlist),0,'quack?');\n\nSimilarly, if you wanted to add 'Skronk' to the beginning of the content list, calling this:\n\n$h->unshiftcontent('Skronk');\n\nthen the resulting content list will be this:\n\n('Skronkfoo bar ', $somenode, 'baz!')\n\nand not this:\n\n('Skronk', 'foo bar ', $somenode, 'baz!')\n\nWhat you'd to do get the latter is:\n\n$h->splicecontent(0,0,'Skronk');\n\nunshiftcontent\n$h->unshiftcontent($elementortext, ...)\n\nJust like \"pushcontent\", but adds to the *beginning* of the $h element's content list.\n\nThe items of content to be added should each be either a text segment (a string), an\nHTML::Element object, or an arrayref (which is fed thru \"newfromlol\").\n\nThe unshiftcontent method will try to consolidate adjacent text segments while adding to the\ncontent list. See above for a discussion of this.\n\nReturns $h (the element itself).\n\nsplicecontent\n@removed = $h->splicecontent($offset, $length,\n$elementortext, ...);\n\nDetaches the elements from $h's list of content-nodes, starting at $offset and continuing for\n$length items, replacing them with the elements of the following list, if any. Returns the\nelements (if any) removed from the content-list. If $offset is negative, then it starts that far\nfrom the end of the array, just like Perl's normal \"splice\" function. If $length and the\nfollowing list is omitted, removes everything from $offset onward.\n\nThe items of content to be added (if any) should each be either a text segment (a string), an\narrayref (which is fed thru \"newfromlol\"), or an HTML::Element object that's not already a\nchild of $h.\n\ndetach\n$oldparent = $h->detach();\n\nThis unlinks $h from its parent, by setting its 'parent' attribute to undef, and by removing it\nfrom the content list of its parent (if it had one). The return value is the parent that was\ndetached from (or undef, if $h had no parent to start with). Note that neither $h nor its parent\nare explicitly destroyed.\n\ndetachcontent\n@oldcontent = $h->detachcontent();\n\nThis unlinks all of $h's children from $h, and returns them. Note that these are not explicitly\ndestroyed; for that, you can just use \"$h->deletecontent\".\n\nreplacewith\n$h->replacewith( $elementortext, ... )\n\nThis replaces $h in its parent's content list with the nodes specified. The element $h (which by\nthen may have no parent) is returned. This causes a fatal error if $h has no parent. The list of\nnodes to insert may contain $h, but at most once. Aside from that possible exception, the nodes\nto insert should not already be children of $h's parent.\n\nAlso, note that this method does not destroy $h if weak references are turned off -- use\n\"$h->replacewith(...)->delete\" if you need that.\n\npreinsert\n$h->preinsert($elementortext...);\n\nInserts the given nodes right BEFORE $h in $h's parent's content list. This causes a fatal error\nif $h has no parent. None of the given nodes should be $h or other children of $h. Returns $h.\n\npostinsert\n$h->postinsert($elementortext...)\n\nInserts the given nodes right AFTER $h in $h's parent's content list. This causes a fatal error\nif $h has no parent. None of the given nodes should be $h or other children of $h. Returns $h.\n\nreplacewithcontent\n$h->replacewithcontent();\n\nThis replaces $h in its parent's content list with its own content. The element $h (which by\nthen has no parent or content of its own) is returned. This causes a fatal error if $h has no\nparent. Also, note that this does not destroy $h if weak references are turned off -- use\n\"$h->replacewithcontent->delete\" if you need that.\n\ndeletecontent\n$h->deletecontent();\n$h->destroycontent(); # alias\n\nClears the content of $h, calling \"$h->delete\" for each content element. Compare with\n\"$h->detachcontent\".\n\nReturns $h.\n\n\"destroycontent\" is an alias for this method.\n\ndelete\n$h->delete();\n$h->destroy(); # alias\n\nDetaches this element from its parent (if it has one) and explicitly destroys the element and\nall its descendants. The return value is the empty list (or \"undef\" in scalar context).\n\nBefore version 5.00 of HTML::Element, you had to call \"delete\" when you were finished with the\ntree, or your program would leak memory. This is no longer necessary if weak references are\nenabled, see \"Weak References\".\n\ndestroy\nAn alias for \"delete\".\n\ndestroycontent\nAn alias for \"deletecontent\".\n\nclone\n$copy = $h->clone();\n\nReturns a copy of the element (whose children are clones (recursively) of the original's\nchildren, if any).\n\nThe returned element is parentless. Any 'pos' attributes present in the source element/tree\nwill be absent in the copy. For that and other reasons, the clone of an HTML::TreeBuilder object\nthat's in mid-parse (i.e, the head of a tree that HTML::TreeBuilder is elaborating) cannot\n(currently) be used to continue the parse.\n\nYou are free to clone HTML::TreeBuilder trees, just as long as: 1) they're done being parsed, or\n2) you don't expect to resume parsing into the clone. (You can continue parsing into the\noriginal; it is never affected.)\n\nclonelist\n@copies = HTML::Element->clonelist(...nodes...);\n\nReturns a list consisting of a copy of each node given. Text segments are simply copied;\nelements are cloned by calling \"$it->clone\" on each of them.\n\nNote that this must be called as a class method, not as an instance method. \"clonelist\" will\ncroak if called as an instance method. You can also call it like so:\n\nref($h)->clonelist(...nodes...)\n\nnormalizecontent\n$h->normalizecontent\n\nNormalizes the content of $h -- i.e., concatenates any adjacent text nodes. (Any undefined text\nsegments are turned into empty-strings.) Note that this does not recurse into $h's descendants.\n\ndeleteignorablewhitespace\n$h->deleteignorablewhitespace()\n\nThis traverses under $h and deletes any text segments that are ignorable whitespace. You should\nnot use this if $h is under a \"

\" element.\n\ninsertelement\n$h->insertelement($element, $implicit);\n\nInserts (via pushcontent) a new element under the element at \"$h->pos()\". Then updates\n\"$h->pos()\" to point to the inserted element, unless $element is a prototypically empty element\nlike \"
\", \"
\", \"\", etc. The new \"$h->pos()\" is returned. This method is useful only\nif your particular tree task involves setting \"$h->pos()\".\n",
            "subsections": []
        },
        "DUMPING METHODS": {
            "content": "dump\n$h->dump()\n$h->dump(*FH)  ; # or *FH{IO} or $fhobj\n\nPrints the element and all its children to STDOUT (or to a specified filehandle), in a format\nuseful only for debugging. The structure of the document is shown by indentation (no end tags).\n\nasHTML\n$s = $h->asHTML();\n$s = $h->asHTML($entities);\n$s = $h->asHTML($entities, $indentchar);\n$s = $h->asHTML($entities, $indentchar, \\%optionalendtags);\n\nReturns a string representing in HTML the element and its descendants. The optional argument\n$entities specifies a string of the entities to encode. For compatibility with previous\nversions, specify '<>&' here. If omitted or undef, *all* unsafe characters are encoded as HTML\nentities. See HTML::Entities for details. If passed an empty string, no entities are encoded.\n\nIf $indentchar is specified and defined, the HTML to be output is intented, using the string\nyou specify (which you probably should set to \"\\t\", or some number of spaces, if you specify\nit).\n\nIf \"\\%optionalendtags\" is specified and defined, it should be a reference to a hash that holds\na true value for every tag name whose end tag is optional. Defaults to\n\"\\%HTML::Element::optionalEndTag\", which is an alias to %HTML::Tagset::optionalEndTag, which, at\ntime of writing, contains true values for \"p, li, dt, dd\". A useful value to pass is an empty\nhashref, \"{}\", which means that no end-tags are optional for this dump. Otherwise, possibly\nconsider copying %HTML::Tagset::optionalEndTag to a hash of your own, adding or deleting values\nas you like, and passing a reference to that hash.\n\nastext\n$s = $h->astext();\n$s = $h->astext(skipdels => 1);\n\nReturns a string consisting of only the text parts of the element's descendants. Any whitespace\ninside the element is included unchanged, but whitespace not in the tree is never added. But\nremember that whitespace may be ignored or compacted by HTML::TreeBuilder during parsing\n(depending on the value of the \"ignoreignorablewhitespace\" and \"nospacecompacting\"\nattributes). Also, since whitespace is never added during parsing,\n\nHTML::TreeBuilder->newfromcontent(\"a
b
\")\n->astext;\n\nreturns \"ab\", not \"a b\" or \"a\\nb\".\n\nText under \"