Файловый менеджер - Редактировать - /var/www/html/Core.zip
Ðазад
PK ! � � ElementRange.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Wikimedia\Parsoid\DOM\Element; /** * A simple pair of DOM elements */ class ElementRange { /** @var Element */ public $startElem; /** @var Element */ public $endElem; } PK ! ��D�� � SelserData.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; /** * TODO: Kept around for backwards compatibilty with uses outside this repo. */ class SelserData extends SelectiveUpdateData { } PK ! ��� � ContentModelHandler.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Wikimedia\Parsoid\DOM\Document; use Wikimedia\Parsoid\Ext\ParsoidExtensionAPI; abstract class ContentModelHandler { /** * @param ParsoidExtensionAPI $extApi * @param ?SelectiveUpdateData $selectiveUpdateData * @return Document */ abstract public function toDOM( ParsoidExtensionAPI $extApi, ?SelectiveUpdateData $selectiveUpdateData = null ): Document; /** * @param ParsoidExtensionAPI $extApi * @param ?SelectiveUpdateData $selectiveUpdateData * @return string */ abstract public function fromDOM( ParsoidExtensionAPI $extApi, ?SelectiveUpdateData $selectiveUpdateData = null ): string; } PK ! ��l9 9 PageBundle.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Composer\Semver\Semver; use Wikimedia\Parsoid\DOM\Document; use Wikimedia\Parsoid\DOM\Element; use Wikimedia\Parsoid\DOM\Node; use Wikimedia\Parsoid\Utils\ContentUtils; use Wikimedia\Parsoid\Utils\DOMCompat; use Wikimedia\Parsoid\Utils\DOMDataUtils; use Wikimedia\Parsoid\Utils\DOMUtils; use Wikimedia\Parsoid\Utils\PHPUtils; /** * PORT-FIXME: This is just a placeholder for data that was previously passed * to entrypoint in JavaScript. Who will construct these objects and whether * this is the correct interface is yet to be determined. * * Note that the parsoid/mw properties of the page bundle are in "serialized * array" form; that is, they are flat arrays appropriate for json-encoding * and do not contain DataParsoid or DataMw objects. */ class PageBundle { /** @var string */ public $html; /** * A map from ID to the array serialization of DataParsoid for the Node * with that ID. * * @var null|array{counter?:int,offsetType?:string,ids:array<string,array>} */ public $parsoid; /** * A map from ID to the array serialization of DataMw for the Node * with that ID. * * @var null|array{ids:array<string,array>} */ public $mw; /** @var ?string */ public $version; /** * A map of HTTP headers: both name and value should be strings. * @var array<string,string>|null */ public $headers; /** @var string|null */ public $contentmodel; public function __construct( string $html, ?array $parsoid = null, ?array $mw = null, ?string $version = null, ?array $headers = null, ?string $contentmodel = null ) { $this->html = $html; $this->parsoid = $parsoid; $this->mw = $mw; $this->version = $version; $this->headers = $headers; $this->contentmodel = $contentmodel; } public function toDom(): Document { $doc = DOMUtils::parseHTML( $this->html ); self::apply( $doc, $this ); return $doc; } public function toHtml(): string { return ContentUtils::toXML( $this->toDom() ); } /** * Check if this pagebundle is valid. * @param string $contentVersion Document content version to validate against. * @param ?string &$errorMessage Error message will be returned here. * @return bool */ public function validate( string $contentVersion, ?string &$errorMessage = null ) { if ( !$this->parsoid || !isset( $this->parsoid['ids'] ) ) { $errorMessage = 'Invalid data-parsoid was provided.'; return false; } elseif ( Semver::satisfies( $contentVersion, '^999.0.0' ) && ( !$this->mw || !isset( $this->mw['ids'] ) ) ) { $errorMessage = 'Invalid data-mw was provided.'; return false; } return true; } /** * @return array */ public function responseData() { $responseData = [ 'contentmodel' => $this->contentmodel ?? '', 'html' => [ 'headers' => array_merge( [ 'content-type' => 'text/html; charset=utf-8; ' . 'profile="https://www.mediawiki.org/wiki/Specs/HTML/' . $this->version . '"', ], $this->headers ?? [] ), 'body' => $this->html, ], 'data-parsoid' => [ 'headers' => [ 'content-type' => 'application/json; charset=utf-8; ' . 'profile="https://www.mediawiki.org/wiki/Specs/data-parsoid/' . $this->version . '"', ], 'body' => $this->parsoid, ], ]; if ( Semver::satisfies( $this->version, '^999.0.0' ) ) { $responseData['data-mw'] = [ 'headers' => [ 'content-type' => 'application/json; charset=utf-8; ' . 'profile="https://www.mediawiki.org/wiki/Specs/data-mw/' . $this->version . '"', ], 'body' => $this->mw, ]; } return $responseData; } /** * Applies the `data-*` attributes JSON structure to the document. * Leaves `id` attributes behind -- they are used by citation code to * extract `<ref>` body from the DOM. * * @param Document $doc doc * @param PageBundle $pb page bundle */ public static function apply( Document $doc, PageBundle $pb ): void { DOMUtils::visitDOM( DOMCompat::getBody( $doc ), static function ( Node $node ) use ( $pb ): void { if ( $node instanceof Element ) { $id = DOMCompat::getAttribute( $node, 'id' ); if ( $id === null ) { return; } if ( isset( $pb->parsoid['ids'][$id] ) ) { DOMDataUtils::setJSONAttribute( $node, 'data-parsoid', $pb->parsoid['ids'][$id] ); } if ( isset( $pb->mw['ids'][$id] ) ) { // Only apply if it isn't already set. This means // earlier applications of the pagebundle have higher // precedence, inline data being the highest. if ( !$node->hasAttribute( 'data-mw' ) ) { DOMDataUtils::setJSONAttribute( $node, 'data-mw', $pb->mw['ids'][$id] ); } } } } ); } /** * Encode some of these properties for emitting in the <head> element of a doc * @return string */ public function encodeForHeadElement(): string { // Note that $this->parsoid and $this->mw are already serialized arrays // so a naive jsonEncode is sufficient. We don't need a codec. return PHPUtils::jsonEncode( [ 'parsoid' => $this->parsoid ?? [], 'mw' => $this->mw ?? [] ] ); } } PK ! ����K �K ContentMetadataCollector.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; /** * Interface for collecting the results of a parse. * * This class is used by Parsoid to record metainformation about a * particular bit of parsed content which is extracted during the * parse. This includes (for example) table of contents information, * and lists of links/categories/templates/images present in the * content. Expected cache lifetime of this parsed content is also * recorded here, as it is influenced by certain things which may * be encountered during the parse. * * In core this is implemented by ParserOutput. Core uses * ParserOutput to record the rendered HTML (and rendered table of * contents HTML), but on the Parsoid side we're going to keep * rendered HTML DOM out of this interface (we use PageBundle for * this). */ interface ContentMetadataCollector { /* * Internal implementation notes: * This class was refactored out of ParserOutput in core. * * == Deliberately omitted == * ::get*()/::has*() and other getters * This is a builder-only interface. This also avoids ordering * issues if/when Parsoid passes this class to sub-parses/extensions. * ::setSpeculativeRevIdUsed() * ::setRevisionTimestampUsed() * ::setRevisionUsedSha1Base36() * ::setSpeculativePageIdUsed() * T292865: these should be plumbed through direct from ParserOptions * or use the ::setOutputFlag() or addOutputData() mechanism. * ::setTimestamp() * This is used by ParserCache and is a little optimization used to * show the correct 'article was last edited on blablablah' box on * page views. Parsoid shouldn't need to worry about this; probably * part of T292865. * ::addCacheMessage() * This is marked @internal in core. * Not clear yet whether Parsoid needs this. * ::getText()/::setText() * T293512: rendered HTML doesn't belong in ParserOutput * ::addWrapperDivClass()/::clearWrapperDivClass() * Has to do with ::getText() implementation, see above * ::setTitleText() * Omited because it contains rendered HTML * (should become a method which takes a DOM tree instead?) * ::setTOCHTML() * Omitted because it contains rendered HTML. * T293513 will remove this method from ParserOutput * ::addHeadItem() * Not clear this is needed by Parsoid (but maybe some of the stuff * Parsoid adds to head could be refactored to use this interface). * Should be DOM not string data! * ::addOutputPageMetadata() * OutputPage isn't a Parsoid interface, so this shouldn't be needed * by Parsoid. * ::setDisplayTitle() * T293514: This desugars to calls to two other methods in * ContentOutputBuilder; callers can refactor to invoke those directly. * ::unsetPageProperty() * If parse fragment A is setting a property * and parse fragment B is unsetting the property, we've introduced * an ordering dependency. We'd like to avoid that code pattern. * ::resetParseStartTime()/::getTimeSinceStart() * Not needed by parsoid? * ::finalizeAdaptiveCacheExpiry() * Same as above, can probably be invoked by caller of parsoid, * doesn't need to be in Parsoid library code. * ::mergeInternalMetaDataFrom() * ::mergeHtmlMetaDataFrom() * ::mergeTrackingMetaDataFrom() * Rather than explicitly merging ContentMetadataCollectors, we'd * prefer to pass a single ContentOutputBuilder around to accumulate * results. We're going to wait and see to what extent methods like * this are necessary. * (ParserOutput will implement a ::mergeTo(ContentMetadataCollector) * method, as it has read access to its own contents.) * ::setNoGallery()/::setEnableOOUI()/::setNewSection()/::setHideNewSection() * ::setPreventClickjacking()/::setIndexPolicy()/ * Available via ::setOutputFlag() (see T292868) * ::setCategories() * Doesn't seem necessary, we have ::addCategory(). * (And adding the ability to overwrite categories would be bad.) * ::addTrackingCategory() * This was moved to Parser / the TrackingCategories service, and * equivalently DataAccess in Parsoid. * ::isLinkInternal() * T296036: Should be non-public or at least @internal? * ::addInterwikiLink() * invoked from ::addLink() if the link is external, we don't * need a separate entry point. * ::setSections() * T296025: replaced with ::setTOCData() * ::setLanguageLinks() * Deprecated; replaced with ::addLanguageLink() * ::addExtraCSPDefaultSrc() * ::addExtraCSPStyleSrc() * ::addExtraCSPScriptSrc() * ::updateRuntimeAdaptiveExpiry() * T296345: handled through ::appendOutputStrings() * * == Temporarily omitted == * ::addTemplate() * T296038: Requires page id and revision id. In addition, this * interacts with user hooks. The MediaWiki side should probably be * responsible for updating the Template dependencies not Parsoid. * OTOH, we need to return *something* like a Title back because * eventually Parsoid has to fetch the template to expand it. * ::setTitleText() * T293514: This contains the title in HTML and is redundant with * ::setDisplayTitle() */ /** * Merge strategy to use for ContentMetadataCollector * accumulators: "union" means that values are strings, stored as * a set, and exposed as a PHP associative array mapping from * values to `true`. * * This constant should be treated as @internal until we expose * alternative merge strategies for external use. * @internal */ public const MERGE_STRATEGY_UNION = 'union'; /** * Add a category, with the given sort key. * * @param LinkTarget $c Category name * @param string $sort Sort key (pass the empty string to use the default) */ public function addCategory( $c, $sort = '' ): void; /** * Record a local or interwiki inline link for saving in future link tables. * * @param LinkTarget $link (used to require Title until 1.38) * @param int|null $id Optional known page_id so we can skip the lookup * (generally not used by Parsoid) */ public function addLink( LinkTarget $link, $id = null ): void; /** * Register a file dependency for this output * @param LinkTarget $name Title dbKey * @param string|false|null $timestamp MW timestamp of file creation (or false if non-existing) * @param string|false|null $sha1 Base 36 SHA-1 of file (or false if non-existing) */ public function addImage( LinkTarget $name, $timestamp = null, $sha1 = null ): void; /** * Add a language link. * @param LinkTarget $lt */ public function addLanguageLink( LinkTarget $lt ): void; /** * Add a warning to the output for this page. * @param string $msg The localization message key for the warning * @param mixed ...$args Optional arguments for the message */ public function addWarningMsg( string $msg, ...$args ): void; /** * @param string $url External link URL */ public function addExternalLink( string $url ): void; /** * Provides a uniform interface to various boolean flags stored * in the content metadata. Flags internal to MediaWiki core should * have names which are constants in ParserOutputFlags. Extensions * should use ::setExtensionData() rather than creating new flags * with ::setOutputFlag() in order to prevent namespace conflicts. * * @param string $name A flag name * @param bool $val */ public function setOutputFlag( string $name, bool $val = true ): void; /** * Provides a uniform interface to various appendable lists of strings * stored in the content metadata. Strings internal to MediaWiki core should * have names which are constants in ParserOutputStrings. Extensions * should use ::setExtensionData() rather than creating new keys here * in order to prevent namespace conflicts. * * @param string $name A string name * @param string[] $value */ public function appendOutputStrings( string $name, array $value ): void; /** * Set a numeric page property whose *value* is intended to be sorted * and indexed. The sort key used for the property will be the value, * coerced to a number. It is also possible to efficiently look up all * the pages with a certain property (the "presence" of the * property is also indexed; see Special:PagesWithProp, * list=pageswithprop). * * The page property is stored in the page_props database * table. The page_props table is a key-value store indexed by the * page ID. This allows the parser to set a property on a page * whose value can then be quickly retrieved given the page ID or via a * DB join when given the page title. The page_props table is *also* * indexed on the numeric sort key passed as $numericValue to this * method. This allows for efficient "top k" queries of pages with * respect to a given property. * * In the future, we may allow the value to be specified independent * of sort key (T357783). * * The setNumericPageProperty() method is thus used to propagate * properties from the parsed page to request contexts other than * a page view of the currently parsed article. * * Some applications examples: * * * The Proofread page extension stores * `proofread_page_quality_level` as a numeric property to allow * efficient retrieval of pages of a certain quality level. * * * Keeping a count of the number of errors found in a page property * to allow listing pages in order from most errors to least. * * If you need a placeholder value, you likely should be using * ::setUnsortedPageProperty() instead. * * @note Note that the PageProp service always returns strings * for the value of the page property, while values retrieved * from this ParserOutput will be numeric. Be careful to distinguish * these two cases. * * @note Do not use setNumericPageProperty() to set a property * which is only used in a context where the ParserOutput object * itself is already available, for example a normal page * view. There is no need to save such a property in the database * since the text is already parsed; use ::setExtensionData() * instead. * * @par Example: * @code * $parser->getOutput()->setExtensionData( 'my_ext_foo', '...' ); * @endcode * * And then later, in the OutputPageParserOutput hook or similar: * * @par Example: * @code * $output->getExtensionData( 'my_ext_foo' ); * @endcode * * @param string $propName The name of the page property * @param int|float|string $numericValue the numeric value * @since 1.42 */ public function setNumericPageProperty( string $propName, $numericValue ): void; /** * Set a page property whose *value* is not intended to be sorted * and indexed. It is still possible to efficiently look up all * the pages with a certain property (the "presence" of the * property *is* indexed; see Special:PagesWithProp, * list=pageswithprop). * * The page property is stored in the page_props database * table. The page_props table is a key-value store indexed by the * page ID. This allows the parser to set a property on a page * whose value can then be quickly retrieved given the page ID or via a * DB join when given the page title. * * The setUnsortedPageProperty() method is thus used to propagate * properties from the parsed page to request contexts other than * a page view of the currently parsed article. * * Some applications examples: * * * To implement hidden categories, hiding pages from category listings * by storing a page property. * * * Overriding the displayed article title * (ParserOutput::setDisplayTitle()). * * * To implement image tagging, for example displaying an icon on an * image thumbnail to indicate that it is listed for deletion on * Wikimedia Commons. * (This is not actually implemented yet but would be pretty cool.) * * It is recommended to use the empty string if you need a * placeholder value (ie, if it is the *presence* of the property * which is important, not the *value* the property is set to). * * @note Do not use setUnsortedPageProperty() to set a property * which is only used in a context where the ParserOutput object * itself is already available, for example a normal page * view. There is no need to save such a property in the database * since the text is already parsed; use ::setExtensionData() * instead. * * @par Example: * @code * $parser->getOutput()->setExtensionData( 'my_ext_foo', '...' ); * @endcode * * And then later, in the OutputPageParserOutput hook or similar: * * @par Example: * @code * $output->getExtensionData( 'my_ext_foo' ); * @endcode * * @param string $propName The name of the page property * @param string $value Optional value; defaults to the empty string. * @since 1.42 */ public function setUnsortedPageProperty( string $propName, string $value = '' ): void; /** * Attaches arbitrary data to this content. This can be used to * store some information for later use during page output. The * data will be cached along with the parsed page, but unlike data * set using set*PageProperty(), it is not recorded in the * database. * * To use setExtensionData() to pass extension information from a * hook inside the parser to a hook in the page output, use this * in the parser hook: * * @par Example: * @code * $parser->getOutput()->setExtensionData( 'my_ext_foo', '...' ); * @endcode * * And then later, in OutputPageParserOutput or similar: * * @par Example: * @code * $output->getExtensionData( 'my_ext_foo' ); * @endcode * * @note Only scalar values, e.g. numbers, strings, arrays or * MediaWiki\Json\JsonUnserializable instances are supported as a * value. Attempt to set other class instance as a extension data * will break ParserCache for the page. * * @note As with ::setJsConfigVar(), setting a page property to multiple * conflicting values during the parse is not supported. * * @param string $key The key for accessing the data. Extensions * should take care to avoid conflicts in naming keys. It is * suggested to use the extension's name as a prefix. Keys * beginning with `mw-` are reserved for use by mediawiki core. * * @param mixed $value The value to set. * Setting a value to null is equivalent to removing the value. */ public function setExtensionData( string $key, $value ): void; /** * Appends arbitrary data to this ParserObject. This can be used * to store some information in the ParserOutput object for later * use during page output. The data will be cached along with the * ParserOutput object, but unlike data set using * set*PageProperty(), it is not recorded in the database. * * See ::setExtensionData() for more details on rationale and use. * * In order to provide for out-of-order/asynchronous/incremental * parsing, this method appends values to a set. See * ::setExtensionData() for the flag-like version of this method. * * @note Only values which can be array keys are currently supported * as values. Be aware that array keys which 'look like' numbers are * converted to ints by PHP, and so if you put in `"0"` as a value you * will get `[0=>true]` out. * * @param string $key The key for accessing the data. Extensions should take care to avoid * conflicts in naming keys. It is suggested to use the extension's name as a prefix. * * @param int|string $value The value to append to the list. * @param string $strategy Merge strategy: * only MW_MERGE_STRATEGY_UNION is currently supported and external callers * should treat this parameter as @internal at this time and omit it. */ public function appendExtensionData( string $key, $value, string $strategy = self::MERGE_STRATEGY_UNION ): void; /** * Add a variable to be set in mw.config in JavaScript. * * In order to ensure the result is independent of the parse order, the values * set here must be unique -- that is, you can pass the same $key * multiple times but ONLY if the $value is identical each time. * If you want to collect multiple pieces of data under a single key, * use ::appendJsConfigVar(). * * @param string $key Key to use under mw.config * @param mixed|null $value Value of the configuration variable. */ public function setJsConfigVar( string $key, $value ): void; /** * Append a value to a variable to be set in mw.config in JavaScript. * * In order to ensure the result is independent of the parse order, * the value of this key will be an associative array, mapping all of * the values set under that key to true. (The array is implicitly * ordered in PHP, but you should treat it as unordered.) * If you want a non-array type for the key, and can ensure that only * a single value will be set, you should use ::setJsConfigVar() instead. * * @note Only values which can be array keys are currently supported * as values. Be aware that array keys which 'look like' numbers are * converted to ints by PHP, and so if you put in `"0"` as a value you * will get `[0=>true]` out. * * @param string $key Key to use under mw.config * @param string $value Value to append to the configuration variable. * @param string $strategy Merge strategy: * only MW_MERGE_STRATEGY_UNION is currently supported and external callers * should treat this parameter as @internal at this time and omit it. */ public function appendJsConfigVar( string $key, string $value, string $strategy = self::MERGE_STRATEGY_UNION ): void; /** * @see OutputPage::addModules * @param string[] $modules * @deprecated use ::appendOutputStrings(::MODULE, ...) */ public function addModules( array $modules ): void; /** * @see OutputPage::addModuleStyles * @param string[] $modules * @deprecated use ::appendOutputStrings(::MODULE_STYLE, ...) */ public function addModuleStyles( array $modules ): void; /** * Sets parser limit report data for a key * * The key is used as the prefix for various messages used for formatting: * - $key: The label for the field in the limit report * - $key-value-text: Message used to format the value in the "NewPP limit * report" HTML comment. If missing, uses $key-format. * - $key-value-html: Message used to format the value in the preview * limit report table. If missing, uses $key-format. * - $key-value: Message used to format the value. If missing, uses "$1". * * Note that all values are interpreted as wikitext, and so should be * encoded with htmlspecialchars() as necessary, but should avoid complex * HTML for sanity of display in the "NewPP limit report" comment. * * @param string $key Message key * @param mixed $value Appropriate for Message::params() */ public function setLimitReportData( string $key, $value ): void; /** * Sets Table of Contents data for this page. * * Note that merging of TOCData is not supported; exactly one fragment * should set TOCData. * * @param TOCData $tocData */ public function setTOCData( TOCData $tocData ): void; /** * Set the content for an indicator. * * @param string $name * @param string $content * @param-taint $content exec_html */ public function setIndicator( $name, $content ): void; } PK ! �*]�5 5 MediaStructure.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Wikimedia\Parsoid\DOM\Element; use Wikimedia\Parsoid\DOM\Node; use Wikimedia\Parsoid\Utils\DiffDOMUtils; use Wikimedia\Parsoid\Utils\DOMCompat; use Wikimedia\Parsoid\Utils\WTUtils; use Wikimedia\Parsoid\Wikitext\Consts; /** * All media should have a fixed structure: * * ``` * <conatinerElt> * <linkElt><mediaElt /></linkElt> * <captionElt>...</captionElt> * </containerElt> * ``` * * Pull out this fixed structure, being as generous as possible with * possibly-broken HTML. */ class MediaStructure { /** * Node names: figure, span * * @var ?Element */ public $containerElt; /** * Node names: a, span * * @var ?Element */ public $linkElt; /** * Node names: img, audio, video, span * * @var ?Element */ public $mediaElt; /** * Node names: figcaption * * @var ?Element */ public $captionElt; /** * @param Element $mediaElt * @param ?Element $linkElt * @param ?Element $containerElt */ public function __construct( Element $mediaElt, ?Element $linkElt = null, ?Element $containerElt = null ) { $this->mediaElt = $mediaElt; $this->linkElt = $linkElt; $this->containerElt = $containerElt; if ( $containerElt && DOMCompat::nodeName( $containerElt ) === 'figure' ) { // FIXME: Support last child, which is not the linkElt, as the caption? $this->captionElt = DOMCompat::querySelector( $containerElt, 'figcaption' ); } } /** * We were not able to fetch info for the title, so the media was * considered missing and rendered as a span. * * @return bool */ public function isRedLink(): bool { return ( DOMCompat::nodeName( $this->mediaElt ) === 'span' ); } /** * @return ?string the resource name if it exists, otherwise null */ public function getResource(): ?string { return DOMCompat::getAttribute( $this->mediaElt, 'resource' ); } /** * @return ?string The alt text if it exists, otherwise null */ public function getAlt(): ?string { return DOMCompat::getAttribute( $this->mediaElt, 'alt' ); } /** * @return ?string The media href if it exists, otherwise null. */ public function getMediaUrl(): ?string { return $this->linkElt ? DOMCompat::getAttribute( $this->linkElt, 'href' ) : null; } /** * @param Node $node * @return ?MediaStructure */ public static function parse( Node $node ): ?MediaStructure { if ( !WTUtils::isGeneratedFigure( $node ) ) { return null; } '@phan-var Element $node'; // @var Element $node $linkElt = $node; do { // Try being lenient, maybe there was a content model violation when // parsing and an active formatting element was reopened in the wrapper $linkElt = DiffDOMUtils::firstNonSepChild( $linkElt ); } while ( $linkElt instanceof Element && DOMCompat::nodeName( $linkElt ) !== 'a' && isset( Consts::$HTML['FormattingTags'][DOMCompat::nodeName( $linkElt )] ) ); if ( !( $linkElt instanceof Element && in_array( DOMCompat::nodeName( $linkElt ), [ 'a', 'span' ], true ) ) ) { if ( $linkElt instanceof Element ) { // Try being lenient, maybe this is the media element and we don't // have a link elt. See the test, "Image: from basic HTML (1)" $mediaElt = $linkElt; $linkElt = null; } else { return null; } } else { $mediaElt = DiffDOMUtils::firstNonSepChild( $linkElt ); } if ( !( $mediaElt instanceof Element && in_array( DOMCompat::nodeName( $mediaElt ), [ 'audio', 'img', 'span', 'video' ], true ) ) ) { return null; } return new MediaStructure( $mediaElt, $linkElt, $node ); } } PK ! �� x� � & ContentMetadataCollectorStringSets.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; /** * Registry of flags used with ContentMetadataCollector::appendOutputStrings() * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html */ class ContentMetadataCollectorStringSets { /** * @see ParserOutputStringSets::MODULE */ public const MODULE = 'mw-Module'; /** * @see ParserOutputStringSets::MODULE_STYLE */ public const MODULE_STYLE = 'mw-ModuleStyle'; } PK ! �� U� � " ResourceLimitExceededException.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; /** * Parsoid resource limit exception. */ class ResourceLimitExceededException extends \Exception { } PK ! �+�}( }( TOCData.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Wikimedia\JsonCodec\Hint; use Wikimedia\JsonCodec\JsonCodecable; use Wikimedia\JsonCodec\JsonCodecableTrait; use Wikimedia\Parsoid\Utils\CompatJsonCodec; /** * Table of Contents data, including an array of section metadata. * * This is simply an array of SectionMetadata objects for now along * with extension data, but may include additional ToC properties in * the future. */ class TOCData implements \JsonSerializable, JsonCodecable { use JsonCodecableTrait; /** * The sections in this Table of Contents. * @var SectionMetadata[] */ private array $sections; /** * Arbitrary data attached to this Table of Contents by * extensions. This data will be stored and cached in the * ParserOutput object along with the rest of the table of * contents data, and made available to external clients via the * action API. * * See ParserOutput::setExtensionData() for more information on typical * use, and SectionMetadata::setExtensionData() for a method appropriate * for attaching information to a specific section of the ToC. */ private array $extensionData = []; /** * -------------------------------------------------- * These next 4 properties are temporary state needed * to construct section metadata objects used in TOC. * These state properties are not useful once that is * done and will not be exported or serialized. * -------------------------------------------------- */ /** @var int Temporary TOC State */ private $tocLevel = 0; /** @var int Temporary TOC State */ private $prevLevel = 0; /** @var array<int> Temporary TOC State */ private $levelCount = []; /** @var array<int> Temporary TOC State */ private $subLevelCount = []; /** * Create a new TOCData object with the given sections and no * extension data. * @param SectionMetadata ...$sections */ public function __construct( ...$sections ) { $this->sections = $sections; } /** * Return current TOC level while headings are being * processed and section metadata is being constructed. * @return int */ public function getCurrentTOCLevel(): int { return $this->tocLevel; } /** * Add a new section to this TOCData. * @param SectionMetadata $s */ public function addSection( SectionMetadata $s ) { $this->sections[] = $s; } /** * Get the list of sections in the TOCData. * @return SectionMetadata[] */ public function getSections() { return $this->sections; } /** * Attaches arbitrary data to this TOCData object. This can be * used to store some information about the table of contents in * the ParserOutput object for later use during page output. The * data will be cached along with the ParserOutput object. * * See ParserOutput::setExtensionData() in core for further information * about typical usage in hooks, and SectionMetadata::setExtensionData() * for a similar method appropriate for information about a specific * section of the ToC. * * Setting conflicting values for the same key is not allowed. * If you call ::setExtensionData() multiple times with the same key * on a TOCData, is is expected that the value will be identical * each time. If you want to collect multiple pieces of data under a * single key, use ::appendExtensionData(). * * @note Only scalar values (numbers, strings, or arrays) are * supported as a value. (A future revision will allow anything * that core's JsonCodec can handle.) Attempts to set other types * as extension data values will break ParserCache for the page. * * @todo When values more complex than scalar values get supported, * __clone needs to be updated accordingly. * * @param string $key The key for accessing the data. Extensions * should take care to avoid conflicts in naming keys. It is * suggested to use the extension's name as a prefix. Using * the prefix `mw:` is reserved for core. * * @param mixed $value The value to set. * Setting a value to null is equivalent to removing the value. */ public function setExtensionData( string $key, $value ): void { if ( array_key_exists( $key, $this->extensionData ) && $this->extensionData[$key] !== $value ) { throw new \InvalidArgumentException( "Conflicting data for $key" ); } if ( $value === null ) { unset( $this->extensionData[$key] ); } else { $this->extensionData[$key] = $value; } } /** * Appends arbitrary data to this TOCData. This can be used to * store some information about the table of contents in the * ParserOutput object for later use during page output. * * See ::setExtensionData() for more details on rationale and use. * * @param string $key The key for accessing the data. Extensions should take care to avoid * conflicts in naming keys. It is suggested to use the extension's name as a prefix. * * @param int|string $value The value to append to the list. * @return never This method is not yet implemented. */ public function appendExtensionData( string $key, $value ): void { // This implementation would mirror that of // ParserOutput::appendExtensionData, but let's defer implementing // this until we're sure we need it. In particular, we might need // to figure out how a merge on section data is expected to work // before we can determine the right semantics for this. throw new \InvalidArgumentException( "Not yet implemented" ); } /** * Gets extension data previously attached to this TOCData. * * @param string $key The key to look up * @return mixed|null The value(s) previously set for the given key using * ::setExtensionData() or ::appendExtensionData(), or null if no * value was set for this key. */ public function getExtensionData( $key ) { $value = $this->extensionData[$key] ?? null; return $value; } /** * Return as associative array, in the legacy format returned by the * action API. * * This is helpful as b/c support while we transition to objects, * but it drops some properties from this class and shouldn't be used * in new code. * @return array */ public function toLegacy(): array { return array_map( static function ( $s ) { return $s->toLegacy(); }, $this->sections ); } /** * Create a new TOCData object from the legacy associative array format. * * This is used for backward compatibility, but the associative array * format does not include any properties of the TOCData other than the * section list. * * @param array $data Associative array with ToC data in legacy format * @return TOCData */ public static function fromLegacy( array $data ): TOCData { // The legacy format has no way to represent extension data. $sections = array_map( static function ( $d ) { return SectionMetadata::fromLegacy( $d ); }, $data ); return new TOCData( ...$sections ); } /** * @param int $oldLevel level of the heading (H1/H2, etc.) * @param int $level level of the heading (H1/H2, etc.) * @param SectionMetadata $metadata This metadata will be updated * This logic is copied from Parser.php::finalizeHeadings */ public function processHeading( int $oldLevel, int $level, SectionMetadata $metadata ): void { if ( $this->tocLevel ) { $this->prevLevel = $oldLevel; } if ( $level > $this->prevLevel ) { # increase TOC level $this->tocLevel++; $this->subLevelCount[$this->tocLevel] = 0; } elseif ( $level < $this->prevLevel && $this->tocLevel > 1 ) { # Decrease TOC level, find level to jump to for ( $i = $this->tocLevel; $i > 0; $i-- ) { if ( $this->levelCount[$i] === $level ) { # Found last matching level $this->tocLevel = $i; break; } elseif ( $this->levelCount[$i] < $level ) { # Found first matching level below current level $this->tocLevel = $i + 1; break; } } if ( $i === 0 ) { $this->tocLevel = 1; } } $this->levelCount[$this->tocLevel] = $level; # count number of headlines for each level $this->subLevelCount[$this->tocLevel]++; $numbering = ''; $dot = false; for ( $i = 1; $i <= $this->tocLevel; $i++ ) { if ( !empty( $this->subLevelCount[$i] ) ) { if ( $dot ) { $numbering .= '.'; } $numbering .= $this->subLevelCount[$i]; $dot = true; } } $metadata->hLevel = $level; $metadata->tocLevel = $this->tocLevel; $metadata->number = $numbering; } /** * Serialize all data in the TOCData as JSON. * * Unlike the `:toLegacy()` method, this method will include *all* * of the properties in the TOCData so that the serialization is * reversible. * * @inheritDoc */ public function jsonSerialize(): array { # T312589 explicitly calling jsonSerialize() on the elements of # $this->sections will be unnecessary in the future. $sections = array_map( static function ( SectionMetadata $s ) { return $s->jsonSerialize(); }, $this->sections ); return [ 'sections' => $sections, 'extensionData' => $this->extensionData, ]; } // JsonCodecable interface /** @inheritDoc */ public function toJsonArray(): array { return [ 'sections' => $this->sections, 'extensionData' => $this->extensionData, ]; } /** @inheritDoc */ public static function newFromJsonArray( array $json ) { $tocData = new TOCData( ...$json['sections'] ); foreach ( $json['extensionData'] as $key => $value ) { $tocData->setExtensionData( $key, $value ); } return $tocData; } /** @inheritDoc */ public static function jsonClassHintFor( string $keyName ) { if ( $keyName === 'sections' ) { return Hint::build( SectionMetadata::class, Hint::LIST ); } return null; } // Pretty-printing /** * For use in parser tests and wherever else humans might appreciate * some formatting in the JSON encoded output. * @return string */ public function prettyPrint(): string { $out = [ "Sections:" ]; foreach ( $this->sections as $s ) { $out[] = $s->prettyPrint(); } if ( $this->extensionData ) { $out[] = "Extension Data:"; $codec = new CompatJsonCodec(); $out[] = json_encode( $codec->toJsonArray( $this->extensionData ) ); } return implode( "\n", $out ); } public function __clone() { foreach ( $this->sections as $k => $v ) { $this->sections[$k] = clone $v; } } } PK ! vԶ� � SelectiveUpdateData.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Wikimedia\Parsoid\DOM\Document; /** * Data that's necessary for selective updates (whether html->wt or wt->html). * This is always revision (current or previous)wikitext & html. */ class SelectiveUpdateData { public string $revText; public ?string $revHTML; /** * DOM document corresponding to $revHTML */ public Document $revDOM; /** * If we are doing selective updates for a template edit, * title string of the edited template. */ public ?string $templateTitle; /** * Options for selective HTML updates: template, section, generic */ public ?string $mode; /** * Data that's necessary to perform selective serialization. */ public function __construct( string $revText, ?string $revHTML = null, ?string $mode = null ) { $this->revText = $revText; $this->revHTML = $revHTML; $this->mode = $mode; } } PK ! �A�5� � LinkTargetTrait.phpnu �Iw�� <?php declare( strict_types = 1 ); /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file * @author Addshore */ namespace Wikimedia\Parsoid\Core; /** * Useful helpers for LinkTarget implementations. * * @see LinkTarget */ trait LinkTargetTrait { /** * Convenience function to check if the target is in a given namespace. * * @param int $ns * @return bool */ public function inNamespace( int $ns ): bool { '@phan-var LinkTarget $this'; // Core may someday switch to an enumerated type, but this is // safe for now. return $this->getNamespace() === $ns; } /** * Whether the link target has a fragment. * * @return bool */ public function hasFragment(): bool { '@phan-var LinkTarget $this'; return $this->getFragment() !== ''; } /** * Get the main part of the link target, in text form. * * The main part is the link target without namespace prefix or hash fragment. * The text form is used for display purposes. * * This is computed from the DB key by replacing any underscores with spaces. * * @note To get a title string that includes the namespace and/or fragment, * use a TitleFormatter. * * @return string */ public function getText(): string { '@phan-var LinkTarget $this'; return strtr( $this->getDBKey(), '_', ' ' ); } /** * Whether this LinkTarget has an interwiki component. * * @return bool */ public function isExternal(): bool { '@phan-var LinkTarget $this'; return $this->getInterwiki() !== ''; } /** * Check whether the given LinkTarget refers to the same target as this LinkTarget. * * Two link targets are considered the same if they have the same interwiki prefix, * are in the same namespace, have the same main part, and the same fragment. * * @param LinkTarget $other * @return bool */ public function isSameLinkAs( LinkTarget $other ): bool { '@phan-var LinkTarget $this'; // NOTE: keep in sync with Title::isSameLinkAs()! // NOTE: keep in sync with TitleValue::isSameLinkAs()! // NOTE: === is needed for number-like titles return ( $other->getInterwiki() === $this->getInterwiki() ) && ( $other->getDBkey() === $this->getDBkey() ) && ( $other->getNamespace() === $this->getNamespace() ) && ( $other->getFragment() === $this->getFragment() ); } /** * Return an informative human-readable representation of the link target * namespace, for use in logging and debugging. * * @return string */ public function getNamespaceName(): string { '@phan-var LinkTarget $this'; if ( $this->getNamespace() === 0 ) { return ''; // 0 is NS_MAIN } // A nicer version of this would convert the namespace to a // human-readable string, but that's outside the bounds of the // limited LinkTarget interface. As a fallback, just use a // numeric namespace. Implementations can override this. return '<' . strval( $this->getNamespace() ) . '>'; } /** * Return an informative human-readable representation of the link target, * for use in logging and debugging. * * @return string */ public function __toString(): string { '@phan-var LinkTarget $this'; $result = ''; if ( $this->isExternal() ) { $result .= $this->getInterwiki() . ':'; } if ( $this->getNamespace() !== 0 ) { // 0 is NS_MAIN '@phan-var LinkTargetTrait $this'; $result .= $this->getNamespaceName() . ':'; } $result .= $this->getText(); if ( $this->hasFragment() ) { $result .= '#' . $this->getFragment(); } return $result; } } PK ! sD� > > ClientError.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Exception; /** * Exception thrown on invalid client requests. Should result in a HTTP 400. */ class ClientError extends Exception { public function __construct( string $message = 'Bad Request' ) { parent::__construct( $message ); } } PK ! �%o " ContentMetadataCollectorCompat.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; /** * Helper trait for implementations of ContentMetadataCollector. * * This trait is ideally empty. However, all implementations of * ContentMetadataCollector should `use` it. Then, when a method is * changed in the ContentMetadataCollector implementation, compatibility * code can be temporarily added to this trait in order to facilitate * migration. * * For example, suppose that the method `getFoo()` in ContentMetadataCollector` * was renamed to `getBar()`. Before, third-party code contains: * ``` * class MyCollector implements ContentMetadataCollector { * use ContentMetadataCollectorCompat; * * public function getFoo() { ... } * } * ``` * When the method is renamed in the `ContentMetadataCollector` interface * we then add the following to `ContentMetadataCollectorCompat`: * ``` * trait ContentMetadataCollectorCompat { * public function getBar() { * return $this->getFoo(); * } * } * ``` * * This prevents `MyCollector` from failing to implement * `ContentMetadataCollector` when Parsoid is upgraded to the latest version. * Over time, `MyCollector` will rename the method in its own implementation * and that will override the default implementation inherited from the * `ContentMetadataCollectorCompat` class. Then eventually the * compatibility method can be removed from this trait and we're back * where we started. * * Similarly, if we want to collect some new type of metadata, the * collection method can be added to `ContentMetadataCollector` at the * same time a default implementation is added to * `ContentMetadataCollectorCompat`; again ensuring that we don't * unnecessarily break classes which implement * `ContentMetadataCollector`. The default implementation could do * nothing, effectively ignoring the collection request, or it could * record portions of the metadata using other collection methods. */ trait ContentMetadataCollectorCompat { /* This trait is empty, in an ideal world. */ } PK ! ��0�1 1 DomSourceRange.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Wikimedia\Assert\Assert; use Wikimedia\Parsoid\Tokens\SourceRange; use Wikimedia\Parsoid\Utils\PHPUtils; /** * Represents a DOM source range. That is, for a given DOM tree, gives * the source offset range in the original wikitext for this DOM tree, * as well as the opening and closing tag widths if appropriate. */ class DomSourceRange extends SourceRange { /** * Opening tag width. * @var ?int */ public $openWidth; /** * Closing tag width. * @var ?int */ public $closeWidth; /** * Width of trimmed whitespace between opening tag & first child. * Defaults to zero since for most nodes, there is no ws trimming. * -1 indicates that this information is invalid and should not be used. * @var int */ public $leadingWS = 0; /** * Width of trimmed whitespace between last child & closing tag. * Defaults to zero since for most nodes, there is no ws trimming. * -1 indicates that this information is invalid and should not be used. * @var int */ public $trailingWS = 0; /** * Create a new DOM source offset range (DSR). * @param ?int $start The starting index (UTF-8 byte count, inclusive) * @param ?int $end The ending index (UTF-8 byte count, exclusive) * @param ?int $openWidth The width of the open container tag * @param ?int $closeWidth The width of the close container tag * @param int $leadingWS The width of WS chars between opening tag & first child * @param int $trailingWS The width of WS chars between last child & closing tag */ public function __construct( ?int $start, ?int $end, ?int $openWidth, ?int $closeWidth, int $leadingWS = 0, int $trailingWS = 0 ) { parent::__construct( $start, $end ); $this->openWidth = $openWidth; $this->closeWidth = $closeWidth; $this->leadingWS = $leadingWS; $this->trailingWS = $trailingWS; } /** * Return the substring of the given string corresponding to the * inner portion of this range (that is, not including the opening * and closing tag widths). * @param string $str The source text string * @return string */ public function innerSubstr( string $str ): string { return PHPUtils::safeSubstr( $str, $this->innerStart(), $this->innerLength() ); } /** * Return the "inner start", that is, the start offset plus the open width. * @return int */ public function innerStart(): int { return $this->start + ( $this->openWidth ?? 0 ); } /** * Return the "inner end", that is, the end offset minus the close width. * @return int */ public function innerEnd(): int { return $this->end - ( $this->closeWidth ?? 0 ); } /** * Return the length of this source range, excluding the open and close * tag widths. * @return int */ public function innerLength(): int { return $this->innerEnd() - $this->innerStart(); } /** * Return the substring of the given string corresponding to the * open portion of this range. * @param string $str The source text string * @return string */ public function openSubstr( string $str ): string { return PHPUtils::safeSubstr( $str, $this->start, $this->openWidth ); } /** * Return the substring of the given string corresponding to the * close portion of this range. * @param string $str The source text string * @return string */ public function closeSubstr( string $str ): string { return PHPUtils::safeSubstr( $str, $this->innerEnd(), $this->closeWidth ); } /** * Return the source range corresponding to the open portion of this range. * @return SourceRange */ public function openRange(): SourceRange { return new SourceRange( $this->start, $this->innerStart() ); } /** * Return the source range corresponding to the close portion of this range. * @return SourceRange */ public function closeRange(): SourceRange { return new SourceRange( $this->innerEnd(), $this->end ); } /** * Return the source range corresponding to the inner portion of this range. * @return SourceRange */ public function innerRange(): SourceRange { return new SourceRange( $this->innerStart(), $this->innerEnd() ); } /** * Strip the tag open and close from the beginning and end of the * provided string. This is similar to `DomSourceRange::innerSubstr()` * but we assume that the string before `$this->start` and after * `$this->end` has already been removed. (That is, that the input * is `$this->substr( $originalWikitextSource )`.) * * @param string $src The source text string from `$this->start` * (inclusive) to `$this->end` (exclusive). * @return string */ public function stripTags( string $src ): string { Assert::invariant( strlen( $src ) === $this->length(), "Input string not the expected length" ); return PHPUtils::safeSubstr( $src, $this->openWidth, -$this->closeWidth ); } /** * Return a new DOM source range shifted by $amount. * @param int $amount The amount to shift by * @return DomSourceRange */ public function offset( int $amount ): DomSourceRange { return new DomSourceRange( $this->start + $amount, $this->end + $amount, $this->openWidth, $this->closeWidth, $this->leadingWS, $this->trailingWS ); } /** * @return bool True if the tag widths are valid. */ public function hasValidTagWidths(): bool { return $this->openWidth !== null && $this->closeWidth !== null && $this->openWidth >= 0 && $this->closeWidth >= 0; } /** * Determine if this DSR records that whitespace was trimmed from * this node. Note that this doesn't mean that the amount trimmed * is known; use ::hasValidLeadingWS() or ::hasValidTrimmedWS() * to determine that. * @return bool True if either leadingWS or trailingWS is non-zero. */ public function hasTrimmedWS(): bool { return $this->leadingWS !== 0 || $this->trailingWS !== 0; } /** * @note In most cases you should check to see if this node * ::hasTrimmedWS() *and* whether the amount is valid. * @return bool if the amount of leading whitespace is known. */ public function hasValidLeadingWS(): bool { return $this->leadingWS !== -1; } /** * @note In most cases you should check to see if this node * ::hasTrimmedWS() *and* whether the amount is valid. * @return bool if the amount of trailing whitespace is known. */ public function hasValidTrailingWS(): bool { return $this->trailingWS !== -1; } /** * Convert a TSR to a DSR with zero-width container open/close tags. * @param SourceRange $tsr * @return DomSourceRange */ public static function fromTsr( SourceRange $tsr ): DomSourceRange { return new DomSourceRange( $tsr->start, $tsr->end, null, null ); } /** * Create a new DomSourceRange from an array of integers/null (such as * created during JSON serialization). * @param array<int|null> $dsr * @return DomSourceRange */ public static function newFromJsonArray( array $dsr ): DomSourceRange { $n = count( $dsr ); Assert::invariant( $n === 2 || $n === 4 || $n === 6, 'Not enough elements in DSR array' ); return new DomSourceRange( $dsr[0], $dsr[1], $dsr[2] ?? null, $dsr[3] ?? null, $dsr[4] ?? 0, $dsr[5] ?? 0 ); } /** * @inheritDoc */ public function toJsonArray(): array { $a = [ $this->start, $this->end, $this->openWidth, $this->closeWidth ]; if ( $this->leadingWS !== 0 || $this->trailingWS !== 0 ) { $a[] = $this->leadingWS; $a[] = $this->trailingWS; } return $a; } } PK ! n�pR InternalException.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; /** * Parsoid internal error that we don't know how to recover from. * Likely a result of bad configuration / bad code / edge case. */ class InternalException extends \Exception { } PK ! A w�� � LinkTarget.phpnu �Iw�� <?php declare( strict_types = 1 ); /** * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * http://www.gnu.org/copyleft/gpl.html * * @file * @author Addshore */ namespace Wikimedia\Parsoid\Core; /** * Represents the target of a wiki link. * * @see https://www.mediawiki.org/wiki/Manual:Modeling_pages */ interface LinkTarget { /** * Get the namespace index. * * @return int Namespace index */ public function getNamespace(): int; /** * Convenience function to check if the target is in a given namespace. * * @param int $ns * @return bool */ public function inNamespace( int $ns ): bool; /** * Get the link fragment in text form (i.e. the bit after the hash `#`). * * @return string link fragment */ public function getFragment(): string; /** * Whether the link target has a fragment. * * @return bool */ public function hasFragment(): bool; /** * Get the main part of the link target, in canonical database form. * * The main part is the link target without namespace prefix or hash fragment. * The database form means that spaces become underscores, this is also * used for URLs. * * @return string */ public function getDBkey(): string; /** * Get the main part of the link target, in text form. * * The main part is the link target without namespace prefix or hash fragment. * The text form is used for display purposes. * * This is computed from the DB key by replacing any underscores with spaces. * * @note To get a title string that includes the namespace and/or fragment, * use a TitleFormatter. * * @return string */ public function getText(): string; /** * Create a new LinkTarget with a different fragment on the same page. * * It is expected that the same type of object will be returned, but the * only requirement is that it is a LinkTarget. * * @param string $fragment The fragment override, or "" to remove it. * @return LinkTarget */ public function createFragmentTarget( string $fragment ); /** * Whether this LinkTarget has an interwiki component. * * @return bool */ public function isExternal(): bool; /** * The interwiki component of this LinkTarget. * * @return string */ public function getInterwiki(): string; /** * Check whether the given LinkTarget refers to the same target as this LinkTarget. * * Two link targets are considered the same if they have the same interwiki prefix, * are in the same namespace, have the same main part, and the same fragment. * * @param LinkTarget $other * @return bool */ public function isSameLinkAs( LinkTarget $other ): bool; /** * Return an informative human-readable representation of the link target, * for use in logging and debugging. * * @return string */ public function __toString(): string; } PK ! %OG<� <� Sanitizer.phpnu �Iw�� <?php declare( strict_types = 1 ); /** * General token sanitizer. Strips out (or encapsulates) unsafe and disallowed * tag types and attributes. Should run last in the third, synchronous * expansion stage. * * FIXME: This code was originally ported from PHP to JS in 2012 * and periodically updated before being back to PHP. This code should be * (a) resynced with core sanitizer changes (b) updated to use HTML5 spec */ namespace Wikimedia\Parsoid\Core; use InvalidArgumentException; use Wikimedia\Assert\Assert; use Wikimedia\Parsoid\Config\SiteConfig; use Wikimedia\Parsoid\DOM\Element; use Wikimedia\Parsoid\Tokens\KV; use Wikimedia\Parsoid\Tokens\Token; use Wikimedia\Parsoid\Utils\DOMCompat; use Wikimedia\Parsoid\Utils\DOMUtils; use Wikimedia\Parsoid\Utils\PHPUtils; use Wikimedia\Parsoid\Utils\TokenUtils; use Wikimedia\RemexHtml\HTMLData; class Sanitizer { /** * RDFa and microdata properties allow URLs, URIs and/or CURIs. */ private const MICRODATA = [ 'rel' => true, 'rev' => true, 'about' => true, 'property' => true, 'resource' => true, 'datatype' => true, 'typeof' => true, // RDFa 'itemid' => true, 'itemprop' => true, 'itemref' => true, 'itemscope' => true, 'itemtype' => true, ]; private const UTF8_REPLACEMENT = "\u{FFFD}"; /** * Regular expression to match various types of character references in * Sanitizer::normalizeCharReferences and Sanitizer::decodeCharReferences */ private const CHAR_REFS_REGEX = '/&([A-Za-z0-9\x80-\xff]+;) |&\#([0-9]+); |&\#[xX]([0-9A-Fa-f]+); |&/x'; private const INSECURE_RE = '! expression | accelerator\s*: | -o-link\s*: | -o-link-source\s*: | -o-replace\s*: | url\s*\( | src\s*\( | image\s*\( | image-set\s*\( | attr\s*\([^)]+[\s,]+url !ix'; /** * Pattern matching evil uris like javascript: * WARNING: DO NOT use this in any place that actually requires denying * certain URIs for security reasons. There are NUMEROUS[1] ways to bypass * pattern-based deny lists; the only way to be secure from javascript: * uri based xss vectors is to allow only things that you know are safe * and deny everything else. * [1]: http://ha.ckers.org/xss.html */ private const EVIL_URI_PATTERN = '!(^|\s|\*/\s*)(javascript|vbscript)(\W|$)!iD'; private const XMLNS_ATTRIBUTE_PATTERN = "/^xmlns:[:A-Z_a-z-.0-9]+$/D"; /** * Tells escapeUrlForHtml() to encode the ID using the wiki's primary encoding. * * @since 1.30 */ public const ID_PRIMARY = 0; /** * Tells escapeUrlForHtml() to encode the ID using the fallback encoding, or return false * if no fallback is configured. * * @since 1.30 */ public const ID_FALLBACK = 1; // public because it is accessed in Headings handler /** Characters that will be ignored in IDNs. * https://datatracker.ietf.org/doc/html/rfc8264#section-9.13 * https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt * Strip them before further processing so deny lists and such work. * Part of Sanitizer::cleanUrl in core. */ private const IDN_RE_G = "/ \\s| # general whitespace \u{00AD}| # SOFT HYPHEN \u{034F}| # COMBINING GRAPHEME JOINER \u{061C}| # ARABIC LETTER MARK [\u{115F}-\u{1160}]| # HANGUL CHOSEONG FILLER.. # HANGUL JUNGSEONG FILLER [\u{17B4}-\u{17B5}]| # KHMER VOWEL INHERENT AQ.. # KHMER VOWEL INHERENT AA [\u{180B}-\u{180D}]| # MONGOLIAN FREE VARIATION SELECTOR ONE.. # MONGOLIAN FREE VARIATION SELECTOR THREE \u{180E}| # MONGOLIAN VOWEL SEPARATOR [\u{200B}-\u{200F}]| # ZERO WIDTH SPACE.. # RIGHT-TO-LEFT MARK [\u{202A}-\u{202E}]| # LEFT-TO-RIGHT EMBEDDING.. # RIGHT-TO-LEFT OVERRIDE [\u{2060}-\u{2064}]| # WORD JOINER.. # INVISIBLE PLUS \u{2065}| # <reserved-2065> [\u{2066}-\u{206F}]| # LEFT-TO-RIGHT ISOLATE.. # NOMINAL DIGIT SHAPES \u{3164}| # HANGUL FILLER [\u{FE00}-\u{FE0F}]| # VARIATION SELECTOR-1.. # VARIATION SELECTOR-16 \u{FEFF}| # ZERO WIDTH NO-BREAK SPACE \u{FFA0}| # HALFWIDTH HANGUL FILLER [\u{FFF0}-\u{FFF8}]| # <reserved-FFF0>.. # <reserved-FFF8> [\u{1BCA0}-\u{1BCA3}]| # SHORTHAND FORMAT LETTER OVERLAP.. # SHORTHAND FORMAT UP STEP [\u{1D173}-\u{1D17A}]| # MUSICAL SYMBOL BEGIN BEAM.. # MUSICAL SYMBOL END PHRASE \u{E0000}| # <reserved-E0000> \u{E0001}| # LANGUAGE TAG [\u{E0002}-\u{E001F}]| # <reserved-E0002>.. # <reserved-E001F> [\u{E0020}-\u{E007F}]| # TAG SPACE.. # CANCEL TAG [\u{E0080}-\u{E00FF}]| # <reserved-E0080>.. # <reserved-E00FF> [\u{E0100}-\u{E01EF}]| # VARIATION SELECTOR-17.. # VARIATION SELECTOR-256 [\u{E01F0}-\u{E0FFF}]| # <reserved-E01F0>.. # <reserved-E0FFF> /xuD"; private const GET_ATTRIBS_RE = '/^[:_\p{L}\p{N}][:_\.\-\p{L}\p{N}]*$/uD'; /** * Character entity aliases accepted by MediaWiki in wikitext. * These are not part of the HTML standard. */ private const MW_ENTITY_ALIASES = [ 'רלמ;' => 'rlm;', 'رلم;' => 'rlm;', ]; /** * Fetch the list of acceptable attributes for a given element name. * * @param string $element * @return array<string,int> */ public static function attributesAllowedInternal( string $element ): array { // PORT-FIXME: this method is private in core, but used by Gallery $lists = self::setupAttributesAllowedInternal(); $list = $lists[$element] ?? []; return array_flip( $list ); } /** * Foreach array key (an allowed HTML element), return an array * of allowed attributes * @return array<string,string[]> */ private static function setupAttributesAllowedInternal(): array { static $allowed; if ( $allowed !== null ) { return $allowed; } $common = [ # HTML 'id', 'class', 'style', 'lang', 'dir', 'title', 'tabindex', # WAI-ARIA 'aria-describedby', 'aria-flowto', 'aria-hidden', 'aria-label', 'aria-labelledby', 'aria-level', 'aria-owns', 'role', # RDFa # These attributes are specified in section 9 of # https://www.w3.org/TR/2008/REC-rdfa-syntax-20081014 'about', 'property', 'resource', 'datatype', 'typeof', # Microdata. These are specified by # https://html.spec.whatwg.org/multipage/microdata.html#the-microdata-model 'itemid', 'itemprop', 'itemref', 'itemscope', 'itemtype', ]; $block = array_merge( $common, [ 'align' ] ); $tablealign = [ 'align', 'valign' ]; $tablecell = [ 'abbr', 'axis', 'headers', 'scope', 'rowspan', 'colspan', 'nowrap', # deprecated 'width', # deprecated 'height', # deprecated 'bgcolor', # deprecated ]; # Numbers refer to sections in HTML 4.01 standard describing the element. # See: https://www.w3.org/TR/html4/ $allowed = [ # 7.5.4 'div' => $block, 'center' => $common, # deprecated 'span' => $common, # 7.5.5 'h1' => $block, 'h2' => $block, 'h3' => $block, 'h4' => $block, 'h5' => $block, 'h6' => $block, # 7.5.6 # address # 8.2.4 'bdo' => $common, # 9.2.1 'em' => $common, 'strong' => $common, 'cite' => $common, 'dfn' => $common, 'code' => $common, 'samp' => $common, 'kbd' => $common, 'var' => $common, 'abbr' => $common, # acronym # 9.2.2 'blockquote' => array_merge( $common, [ 'cite' ] ), 'q' => array_merge( $common, [ 'cite' ] ), # 9.2.3 'sub' => $common, 'sup' => $common, # 9.3.1 'p' => $block, # 9.3.2 'br' => array_merge( $common, [ 'clear' ] ), # https://www.w3.org/TR/html5/text-level-semantics.html#the-wbr-element 'wbr' => $common, # 9.3.4 'pre' => array_merge( $common, [ 'width' ] ), # 9.4 'ins' => array_merge( $common, [ 'cite', 'datetime' ] ), 'del' => array_merge( $common, [ 'cite', 'datetime' ] ), # 10.2 'ul' => array_merge( $common, [ 'type' ] ), 'ol' => array_merge( $common, [ 'type', 'start', 'reversed' ] ), 'li' => array_merge( $common, [ 'type', 'value' ] ), # 10.3 'dl' => $common, 'dd' => $common, 'dt' => $common, # 11.2.1 'table' => array_merge( $common, [ 'summary', 'width', 'border', 'frame', 'rules', 'cellspacing', 'cellpadding', 'align', 'bgcolor', ] ), # 11.2.2 'caption' => $block, # 11.2.3 'thead' => $common, 'tfoot' => $common, 'tbody' => $common, # 11.2.4 'colgroup' => array_merge( $common, [ 'span' ] ), 'col' => array_merge( $common, [ 'span' ] ), # 11.2.5 'tr' => array_merge( $common, [ 'bgcolor' ], $tablealign ), # 11.2.6 'td' => array_merge( $common, $tablecell, $tablealign ), 'th' => array_merge( $common, $tablecell, $tablealign ), # 12.2 # NOTE: <a> is not allowed directly, but this list of allowed # attributes is used from the Parser object 'a' => array_merge( $common, [ 'href', 'rel', 'rev' ] ), # rel/rev esp. for RDFa # 13.2 # Not usually allowed, but may be used for extension-style hooks # such as <math> when it is rasterized, or if $wgAllowImageTag is # true 'img' => array_merge( $common, [ 'alt', 'src', 'width', 'height', 'srcset' ] ), # Attributes for A/V tags added in T163583 / T133673 'audio' => array_merge( $common, [ 'controls', 'preload', 'width', 'height' ] ), 'video' => array_merge( $common, [ 'poster', 'controls', 'preload', 'width', 'height' ] ), 'source' => array_merge( $common, [ 'type', 'src' ] ), 'track' => array_merge( $common, [ 'type', 'src', 'srclang', 'kind', 'label' ] ), # 15.2.1 'tt' => $common, 'b' => $common, 'i' => $common, 'big' => $common, 'small' => $common, 'strike' => $common, 's' => $common, 'u' => $common, # 15.2.2 'font' => array_merge( $common, [ 'size', 'color', 'face' ] ), # basefont # 15.3 'hr' => array_merge( $common, [ 'width' ] ), # HTML Ruby annotation text module, simple ruby only. # https://www.w3.org/TR/html5/text-level-semantics.html#the-ruby-element 'ruby' => $common, # rbc 'rb' => $common, 'rp' => $common, 'rt' => $common, # array_merge( $common, array( 'rbspan' ) ), 'rtc' => $common, # MathML root element, where used for extensions # 'title' may not be 100% valid here; it's XHTML # https://www.w3.org/TR/REC-MathML/ 'math' => [ 'class', 'style', 'id', 'title' ], // HTML 5 section 4.5 'figure' => $common, 'figcaption' => $common, # HTML 5 section 4.6 'bdi' => $common, # HTML5 elements, defined by: # https://html.spec.whatwg.org/multipage/semantics.html#the-data-element 'data' => array_merge( $common, [ 'value' ] ), 'time' => array_merge( $common, [ 'datetime' ] ), 'mark' => $common, // meta and link are only permitted by removeHTMLtags when Microdata // is enabled so we don't bother adding a conditional to hide these // Also meta and link are only valid in WikiText as Microdata elements // (ie: validateTag rejects tags missing the attributes needed for Microdata) // So we don't bother including $common attributes that have no purpose. 'meta' => [ 'itemprop', 'content' ], 'link' => [ 'itemprop', 'href', 'title' ], // HTML 5 section 4.3.5 'aside' => $common, ]; return $allowed; } /** * Ensure that any entities and character references are legal * for XML and XHTML specifically. Any stray bits will be * &-escaped to result in a valid text fragment. * * a. named char refs can only be < > & ", others are * numericized (this way we're well-formed even without a DTD) * b. any numeric char refs must be legal chars, not invalid or forbidden * c. use lower cased "&#x", not "&#X" * d. fix or reject non-valid attributes * * @param string $text * @return string * @internal */ public static function normalizeCharReferences( string $text ): string { return preg_replace_callback( self::CHAR_REFS_REGEX, [ self::class, 'normalizeCharReferencesCallback' ], $text, -1, $count, PREG_UNMATCHED_AS_NULL ); } /** * @param array $matches * @return string */ private static function normalizeCharReferencesCallback( array $matches ): string { $ret = null; if ( isset( $matches[1] ) ) { $ret = self::normalizeEntity( $matches[1] ); } elseif ( isset( $matches[2] ) ) { $ret = self::decCharReference( $matches[2] ); } elseif ( isset( $matches[3] ) ) { $ret = self::hexCharReference( $matches[3] ); } if ( $ret === null ) { return htmlspecialchars( $matches[0] ); } else { return $ret; } } /** * If the named entity is defined in HTML5 * return the equivalent numeric entity reference (except for the core < * > & "). If the entity is a MediaWiki-specific alias, returns * the HTML equivalent. Otherwise, returns HTML-escaped text of * pseudo-entity source (eg &foo;) * * @param string $name Semicolon-terminated name * @return string */ private static function normalizeEntity( string $name ): string { if ( isset( self::MW_ENTITY_ALIASES[$name] ) ) { // Non-standard MediaWiki-specific entities return '&' . self::MW_ENTITY_ALIASES[$name]; } elseif ( in_array( $name, [ 'lt;', 'gt;', 'amp;', 'quot;' ], true ) ) { // Keep these in word form return "&$name"; } elseif ( isset( HTMLData::$namedEntityTranslations[$name] ) ) { // Beware: some entities expand to more than 1 codepoint return preg_replace_callback( '/./Ssu', function ( $m ) { return '&#' . self::utf8ToCodepoint( $m[0] ) . ';'; }, HTMLData::$namedEntityTranslations[$name] ); } else { return "&$name"; } } /** * @param string $codepoint * @return null|string */ private static function decCharReference( string $codepoint ): ?string { # intval() will (safely) saturate at the maximum signed integer # value if $codepoint is too many digits $point = intval( $codepoint ); if ( self::validateCodepoint( $point ) ) { return "&#$point;"; } else { return null; } } /** * @param string $codepoint * @return null|string */ private static function hexCharReference( string $codepoint ): ?string { $point = hexdec( $codepoint ); // hexdec() might return a float if the string is too long if ( is_int( $point ) && self::validateCodepoint( $point ) ) { return sprintf( '&#x%x;', $point ); } else { return null; } } /** * Returns true if a given Unicode codepoint is a valid character in * both HTML5 and XML. * @param int $codepoint * @return bool */ private static function validateCodepoint( int $codepoint ): bool { # U+000C is valid in HTML5 but not allowed in XML. # U+000D is valid in XML but not allowed in HTML5. # U+007F - U+009F are disallowed in HTML5 (control characters). return $codepoint == 0x09 || $codepoint == 0x0a || ( $codepoint >= 0x20 && $codepoint <= 0x7e ) || ( $codepoint >= 0xa0 && $codepoint <= 0xd7ff ) || ( $codepoint >= 0xe000 && $codepoint <= 0xfffd ) || ( $codepoint >= 0x10000 && $codepoint <= 0x10ffff ); } /** * Returns a string from the provided code point. * * @param int $cp * @return string */ private static function codepointToUtf8( int $cp ): string { $chr = mb_chr( $cp, 'UTF-8' ); Assert::invariant( $chr !== false, "Getting char failed!" ); return $chr; } /** * Returns the code point at the first position of the string. * * @param string $str * @return int */ private static function utf8ToCodepoint( string $str ): int { $ord = mb_ord( $str ); Assert::invariant( $ord !== false, "Getting code point failed!" ); return $ord; } /** * @param string $host * @return string */ private static function stripIDNs( string $host ): string { // This code is part of Sanitizer::cleanUrl in core return preg_replace( self::IDN_RE_G, '', $host ); } /** * @param SiteConfig $siteConfig * @param string $href * @param string $mode * @return string|null */ public static function cleanUrl( SiteConfig $siteConfig, string $href, string $mode ): ?string { if ( $mode !== 'wikilink' ) { $href = preg_replace_callback( '/([\][<>"\x00-\x20\x7F\|])/', static function ( $matches ) { return urlencode( $matches[0] ); }, $href ); } $matched = preg_match( '#^((?:[a-zA-Z][^:/]*:)?(?://)?)([^/]+)(/?.*)#', $href, $bits ); if ( $matched === 1 ) { $proto = $bits[1]; if ( $proto && !$siteConfig->hasValidProtocol( $proto ) ) { // invalid proto, disallow URL return null; } $host = self::stripIDNs( $bits[2] ); preg_match( '/^%5B([0-9A-Fa-f:.]+)%5D((:\d+)?)$/D', $host, $match ); if ( $match ) { // IPv6 host names $host = '[' . $match[1] . ']' . $match[2]; } $path = $bits[3]; } else { $proto = ''; $host = ''; $path = $href; } return $proto . $host . $path; } /** * If the named entity is defined in HTML5 * return the UTF-8 encoding of that character. Otherwise, returns * pseudo-entity source (eg "&foo;") * * @param string $name Semicolon-terminated entity name * @return string */ private static function decodeEntity( string $name ): string { // These are MediaWiki-specific entities, not in the HTML standard if ( isset( self::MW_ENTITY_ALIASES[$name] ) ) { $name = self::MW_ENTITY_ALIASES[$name]; } $trans = HTMLData::$namedEntityTranslations[$name] ?? null; return $trans ?? "&$name"; } /** * Return UTF-8 string for a codepoint if that is a valid * character reference, otherwise U+FFFD REPLACEMENT CHARACTER. * @param int $codepoint * @return string */ private static function decodeChar( int $codepoint ): string { if ( self::validateCodepoint( $codepoint ) ) { return self::codepointToUtf8( $codepoint ); } else { return self::UTF8_REPLACEMENT; } } /** * Decode any character references, numeric or named entities, * in the text and return a UTF-8 string. * @param string $text * @return string */ public static function decodeCharReferences( string $text ): string { return preg_replace_callback( self::CHAR_REFS_REGEX, function ( $matches ) { if ( isset( $matches[1] ) ) { return self::decodeEntity( $matches[1] ); } elseif ( isset( $matches[2] ) ) { return self::decodeChar( intval( $matches[2] ) ); } elseif ( isset( $matches[3] ) ) { $point = hexdec( $matches[3] ); // hexdec() might return a float if the string is too long if ( !is_int( $point ) ) { // Invalid character reference. return self::UTF8_REPLACEMENT; } return self::decodeChar( $point ); } # Last case should be an ampersand by itself return $matches[0]; }, $text, -1, $count, PREG_UNMATCHED_AS_NULL ); } /** * Normalize CSS into a format we can easily search for hostile input * - decode character references * - decode escape sequences * - convert characters that IE6 interprets into ascii * - remove comments, unless the entire value is one single comment * @param string $value the css string * @return string normalized css */ public static function normalizeCss( string $value ): string { // Decode character references like { $value = self::decodeCharReferences( $value ); // Decode escape sequences and line continuation // See the grammar in the CSS 2 spec, appendix D. // This has to be done AFTER decoding character references. // This means it isn't possible for this function to return // unsanitized escape sequences. It is possible to manufacture // input that contains character references that decode to // escape sequences that decode to character references, but // it's OK for the return value to contain character references // because the caller is supposed to escape those anyway. static $decodeRegex; if ( !$decodeRegex ) { $space = '[\\x20\\t\\r\\n\\f]'; $nl = '(?:\\n|\\r\\n|\\r|\\f)'; $backslash = '\\\\'; $decodeRegex = "/ $backslash (?: ($nl) | # 1. Line continuation ([0-9A-Fa-f]{1,6})$space? | # 2. character number (.) | # 3. backslash cancelling special meaning () | # 4. backslash at end of string )/xu"; } $value = preg_replace_callback( $decodeRegex, [ self::class, 'cssDecodeCallback' ], $value ); // Let the value through if it's nothing but a single comment, to // allow other functions which may reject it to pass some error // message through. if ( !preg_match( '! ^ \s* /\* [^*\\/]* \*/ \s* $ !xD', $value ) ) { // Remove any comments; IE gets token splitting wrong // This must be done AFTER decoding character references and // escape sequences, because those steps can introduce comments // This step cannot introduce character references or escape // sequences, because it replaces comments with spaces rather // than removing them completely. $value = self::delimiterReplace( '/*', '*/', ' ', $value ); // Remove anything after a comment-start token, to guard against // incorrect client implementations. $commentPos = strpos( $value, '/*' ); if ( $commentPos !== false ) { $value = substr( $value, 0, $commentPos ); } } return $value; } // PORT_FIXME - The delimiterReplace code below is from StringUtils in core /** * Perform an operation equivalent to `preg_replace_callback()` * * Matches this code: * * preg_replace_callback( "!$startDelim(.*)$endDelim!s$flags", $callback, $subject ); * * If the start delimiter ends with an initial substring of the end delimiter, * e.g. in the case of C-style comments, the behavior differs from the model * regex. In this implementation, the end must share no characters with the * start, so e.g. `/*\/` is not considered to be both the start and end of a * comment. `/*\/xy/*\/` is considered to be a single comment with contents `/xy/`. * * The implementation of delimiterReplaceCallback() is slower than hungryDelimiterReplace() * but uses far less memory. The delimiters are literal strings, not regular expressions. * * @param string $startDelim Start delimiter * @param string $endDelim End delimiter * @param callable $callback Function to call on each match * @param string $subject * @param string $flags Regular expression flags * @throws InvalidArgumentException * @return string */ private static function delimiterReplaceCallback( string $startDelim, string $endDelim, callable $callback, string $subject, string $flags = '' ): string { $inputPos = 0; $outputPos = 0; $contentPos = 0; $output = ''; $foundStart = false; $encStart = preg_quote( $startDelim, '!' ); $encEnd = preg_quote( $endDelim, '!' ); $strcmp = strpos( $flags, 'i' ) === false ? 'strcmp' : 'strcasecmp'; $endLength = strlen( $endDelim ); $m = []; while ( $inputPos < strlen( $subject ) && preg_match( "!($encStart)|($encEnd)!S$flags", $subject, $m, PREG_OFFSET_CAPTURE, $inputPos ) ) { $tokenOffset = $m[0][1]; if ( $m[1][0] !== '' ) { if ( $foundStart && $strcmp( $endDelim, substr( $subject, $tokenOffset, $endLength ) ) === 0 ) { # An end match is present at the same location $tokenType = 'end'; $tokenLength = $endLength; } else { $tokenType = 'start'; $tokenLength = strlen( $m[0][0] ); } } elseif ( $m[2][0] !== '' ) { $tokenType = 'end'; $tokenLength = strlen( $m[0][0] ); } else { throw new InvalidArgumentException( 'Invalid delimiter given to ' . __METHOD__ ); } if ( $tokenType === 'start' ) { # Only move the start position if we haven't already found a start # This means that START START END matches outer pair if ( !$foundStart ) { # Found start $inputPos = $tokenOffset + $tokenLength; # Write out the non-matching section $output .= substr( $subject, $outputPos, $tokenOffset - $outputPos ); $outputPos = $tokenOffset; $contentPos = $inputPos; $foundStart = true; } else { # Move the input position past the *first character* of START, # to protect against missing END when it overlaps with START $inputPos = $tokenOffset + 1; } } elseif ( $tokenType === 'end' ) { if ( $foundStart ) { # Found match $output .= $callback( [ substr( $subject, $outputPos, $tokenOffset + $tokenLength - $outputPos ), substr( $subject, $contentPos, $tokenOffset - $contentPos ) ] ); $foundStart = false; } else { # Non-matching end, write it out $output .= substr( $subject, $inputPos, $tokenOffset + $tokenLength - $outputPos ); } $inputPos = $outputPos = $tokenOffset + $tokenLength; } else { throw new InvalidArgumentException( 'Invalid delimiter given to ' . __METHOD__ ); } } if ( $outputPos < strlen( $subject ) ) { $output .= substr( $subject, $outputPos ); } return $output; } /** * Perform an operation equivalent to `preg_replace()` with flags. * * Matches this code: * * preg_replace( "!$startDelim(.*)$endDelim!$flags", $replace, $subject ); * * @param string $startDelim Start delimiter regular expression * @param string $endDelim End delimiter regular expression * @param string $replace Replacement string. May contain $1, which will be * replaced by the text between the delimiters * @param string $subject String to search * @param string $flags Regular expression flags * @return string The string with the matches replaced */ private static function delimiterReplace( string $startDelim, string $endDelim, string $replace, string $subject, string $flags = '' ): string { return self::delimiterReplaceCallback( $startDelim, $endDelim, static function ( array $matches ) use ( $replace ) { return strtr( $replace, [ '$0' => $matches[0], '$1' => $matches[1] ] ); }, $subject, $flags ); } /** * SSS FIXME: There is a test in mediawiki.environment.js that doles out * and tests about ids. There are probably some tests in Util.php as well. * We should move all these kind of tests somewhere else. * @param string $k * @param string $v * @param KV[] $attrs * @return bool */ private static function isParsoidAttr( string $k, string $v, array $attrs ): bool { // NOTES: // 1. Currently the tokenizer unconditionally escapes typeof and about // attributes from wikitxt to data-x-typeof and data-x-about. So, // this check will only pass through Parsoid inserted attrs. // 2. But, if we fix the over-aggressive escaping in the tokenizer to // not escape non-Parsoid typeof and about, then this will return // true for something like typeof='mw:Foo evilScriptHere'. But, that // is safe since this check is only used to see if we should // unconditionally discard the entire attribute or process it further. // That further processing will catch and discard any dangerous // strings in the rest of the attribute return ( in_array( $k, [ 'typeof', 'property', 'rel' ], true ) && preg_match( '/(?:^|\s)mw:.+?(?=$|\s)/D', $v ) ) || ( $k === 'about' && preg_match( '/^#mwt\d+$/D', $v ) ) || ( $k === 'content' && preg_match( '/(?:^|\s)mw:.+?(?=$|\s)/D', KV::lookup( $attrs, 'property' ) ?? '' ) ); } /** * Given an attribute name, checks whether it is a reserved data attribute * (such as data-mw-foo) which is unavailable to user-generated HTML so MediaWiki * core and extension code can safely use it to communicate with frontend code. * @param string $attr Attribute name. * @return bool */ public static function isReservedDataAttribute( string $attr ): bool { // data-ooui is reserved for ooui. // data-mw and data-parsoid are reserved for parsoid. // data-mw-<name here> is reserved for extensions (or core) if // they need to communicate some data to the client and want to be // sure that it isn't coming from an untrusted user. // We ignore the possibility of namespaces since user-generated HTML // can't use them anymore. if ( preg_match( '/^data-(mw|parsoid)/', $attr ) ) { return false; // PARSOID SPECIFIC } return (bool)preg_match( '/^data-(ooui|mw|parsoid)/i', $attr ); } /** * @param SiteConfig $siteConfig * @param ?string $tagName * @param ?Token $token * @param array $attrs * @return array */ public static function sanitizeTagAttrs( SiteConfig $siteConfig, ?string $tagName, ?Token $token, array $attrs ): array { $tag = $tagName ?: $token->getName(); $list = self::attributesAllowedInternal( $tag ); $newAttrs = []; $n = count( $attrs ); for ( $i = 0; $i < $n; $i++ ) { $a = $attrs[$i]; $a->v ??= ''; // Convert attributes to string, if necessary. $a->k = TokenUtils::tokensToString( $a->k ); if ( is_array( $a->v ) ) { // Use the expanded attr instead of trying to unpackDOMFragments // since the fragment will have been released when expanding to DOM $expandedVal = $token ? $token->fetchExpandedAttrValue( $a->k ) : null; if ( $expandedVal === null ) { $a->v = TokenUtils::tokensToString( $a->v ); } else { // See the comment in TokenUtils::tokensToString about // unpackDOMFragments for why we're just using the textContent $dom = DOMUtils::parseHTML( $expandedVal ); $a->v = DOMCompat::getBody( $dom )->textContent; } } $origK = $a->ksrc ?? $a->k; // $a->k can be uppercase $k = mb_strtolower( $a->k ); $v = $a->v; $origV = $a->vsrc ?? $v; $psdAttr = self::isParsoidAttr( $k, $v, $attrs ); // Bypass RDFa/allowed attribute checks for Parsoid-inserted attrs // Safe to do since the tokenizer renames about/typeof attrs. // unconditionally. FIXME: The escaping solution in the tokenizer // may be aggressive. There is no need to escape typeof strings // that or about ids that don't resemble Parsoid tokens/about ids. if ( !$psdAttr ) { if ( !preg_match( self::GET_ATTRIBS_RE, $k ) ) { $newAttrs[$k] = [ null, $origV, $origK ]; continue; } # Allow XML namespace declaration to allow RDFa if ( preg_match( self::XMLNS_ATTRIBUTE_PATTERN, $k ) ) { if ( !preg_match( self::EVIL_URI_PATTERN, $v ) ) { $newAttrs[$k] = [ $v, $origV, $origK ]; } else { $newAttrs[$k] = [ null, $origV, $origK ]; } continue; } # Allow any attribute beginning with "data-" # However: # * Disallow data attributes used by MediaWiki code # * Ensure that the attribute is not namespaced by banning # colons. if ( ( !preg_match( '/^data-[^:]*$/iD', $k ) && !isset( $list[$k] ) ) || self::isReservedDataAttribute( $k ) ) { $newAttrs[$k] = [ null, $origV, $origK ]; continue; } } # Strip javascript "expression" from stylesheets. # http://msdn.microsoft.com/workshop/author/dhtml/overview/recalc.asp if ( $k === 'style' ) { $v = self::checkCss( $v ); } # Escape HTML id attributes if ( $k === 'id' ) { $v = self::escapeIdForAttribute( $v, self::ID_PRIMARY ); } # Escape HTML id reference lists if ( $k === 'aria-describedby' || $k === 'aria-flowto' || $k === 'aria-labelledby' || $k === 'aria-owns' ) { $v = self::escapeIdReferenceList( $v ); } // RDFa and microdata properties allow URLs, URIs and/or CURIs. // Check them for validity. if ( $k === 'rel' || $k === 'rev' # RDFa || $k === 'about' || $k === 'property' || $k === 'resource' || $k === 'datatype' || $k === 'typeof' # HTML5 microdata || $k === 'itemid' || $k === 'itemprop' || $k === 'itemref' || $k === 'itemscope' || $k === 'itemtype' ) { // Paranoia. Allow "simple" values but suppress javascript if ( preg_match( self::EVIL_URI_PATTERN, $v ) ) { // Retain the Parsoid typeofs for Parsoid attrs $newV = $psdAttr ? trim( preg_replace( '/(?:^|\s)(?!mw:\w)\S*/', '', $origV ) ) : null; $newAttrs[$k] = [ $newV, $origV, $origK ]; continue; } } # NOTE: even though elements using href/src are not allowed directly, supply # validation code that can be used by tag hook handlers, etc if ( $token && ( $k === 'href' || $k === 'src' || $k === 'poster' ) ) { // T163583 // `origV` will always be `v`, because `a.vsrc` isn't set, since // this attribute didn't come from source. However, in the // LinkHandler, we may have already shadowed this value so use // that instead. $rel = $token->getAttributeShadowInfo( 'rel' ); $mode = ( $k === 'href' && isset( $rel['value'] ) && preg_match( '#^mw:WikiLink(/Interwiki)?$#', $rel['value'] ) ) ? 'wikilink' : 'external'; $origHref = $token->getAttributeShadowInfo( $k )['value']; $newHref = self::cleanUrl( $siteConfig, $v, $mode ); if ( $newHref !== $v ) { $newAttrs[$k] = [ $newHref, $origHref, $origK ]; continue; } } if ( $k === 'tabindex' && $v !== '0' ) { // Only allow tabindex of 0, which is useful for accessibility. continue; } // SSS FIXME: This logic is not RT-friendly. // If this attribute was previously set, override it. // Output should only have one attribute of each name. $newAttrs[$k] = [ $v, $origV, $origK ]; } # itemtype, itemid, itemref don't make sense without itemscope if ( !array_key_exists( 'itemscope', $newAttrs ) ) { // SSS FIXME: This logic is not RT-friendly. unset( $newAttrs['itemtype'] ); unset( $newAttrs['itemid'] ); unset( $newAttrs['itemref'] ); } # TODO: Strip itemprop if we aren't descendants of an itemscope or pointed to by an itemref. return $newAttrs; } /** * Sanitize and apply attributes to a wrapper element. * * Used primarily when we're applying tokenized attributes directly to * dom elements, which wouldn't have had a chance to be sanitized before * tree building. * @param SiteConfig $siteConfig * @param Element $wrapper wrapper * @param array $attrs attributes */ public static function applySanitizedArgs( SiteConfig $siteConfig, Element $wrapper, array $attrs ): void { $nodeName = DOMCompat::nodeName( $wrapper ); $sanitizedAttrs = self::sanitizeTagAttrs( $siteConfig, $nodeName, null, $attrs ); foreach ( $sanitizedAttrs as $k => $v ) { if ( isset( $v[0] ) ) { $wrapper->setAttribute( $k, $v[0] ); } } } /** * @param string $text * @return string */ public static function checkCss( string $text ): string { $text = self::normalizeCss( $text ); // \000-\010\013\016-\037\177 are the octal escape sequences if ( preg_match( '/[\000-\010\013\016-\037\177]/', $text ) || strpos( $text, self::UTF8_REPLACEMENT ) !== false ) { return '/* invalid control char */'; } elseif ( preg_match( self::INSECURE_RE, $text ) ) { return '/* insecure input */'; } else { return $text; } } /** * @param array $matches * @return string */ public static function cssDecodeCallback( array $matches ): string { if ( $matches[1] !== '' ) { // Line continuation return ''; } elseif ( $matches[2] !== '' ) { # hexdec could return a float if the match is too long, but the # regexp in question limits the string length to 6. $char = self::codepointToUtf8( hexdec( $matches[2] ) ); } elseif ( $matches[3] !== '' ) { $char = $matches[3]; } else { $char = '\\'; } if ( $char == "\n" || $char == '"' || $char == "'" || $char == '\\' ) { // These characters need to be escaped in strings // Clean up the escape sequence to avoid parsing errors by clients return '\\' . dechex( ord( $char ) ) . ' '; } else { // Decode unnecessary escape return $char; } } /** * Sanitize a title to be used in a URI? * @param string $title * @param bool $isInterwiki * @return string */ public static function sanitizeTitleURI( string $title, bool $isInterwiki = false ): string { $idx = strpos( $title, '#' ); $anchor = null; if ( $idx !== false ) { // split at first '#' $anchor = substr( $title, $idx + 1 ); $title = substr( $title, 0, $idx ); } $title = preg_replace_callback( '/[%? \[\]#|<>]/', static function ( $matches ) { return PHPUtils::encodeURIComponent( $matches[0] ); }, $title ); if ( $anchor !== null ) { $title .= '#' . ( $isInterwiki ? self::escapeIdForExternalInterwiki( $anchor ) : self::escapeIdForLink( $anchor ) ); } return $title; } public const FIXTAGS = [ # French spaces, last one Guillemet-left # only if it isn't followed by a word character. '/ (?=[?:;!%»›](?!\w))/u' => "%s", # French spaces, Guillemet-right '/([«‹]) /u' => "\\1%s", ]; /** * Armor French spaces with a replacement character * * @since 1.32 * @param string $text Text to armor * @param string $space Space character for the French spaces, defaults to ' ' * @return string Armored text */ public static function armorFrenchSpaces( string $text, string $space = ' ' ): string { // Replace $ with \$ and \ with \\ $space = preg_replace( '#(?<!\\\\)(\\$|\\\\)#', '\\\\$1', $space ); return preg_replace( array_keys( self::FIXTAGS ), array_map( static function ( string $replacement ) use ( $space ) { // @phan-suppress-next-line PhanPluginPrintfVariableFormatString return sprintf( $replacement, $space ); }, array_values( self::FIXTAGS ) ), $text ); } /** * Given a section name or other user-generated or otherwise unsafe string, escapes it to be * a valid HTML id attribute. * * WARNING: unlike escapeId(), the output of this function is not guaranteed to be HTML safe, * be sure to use proper escaping. * * In Parsoid, proper escaping is usually handled for us by the HTML * serialization algorithm, but be careful of corner cases (such as * emitting attributes in wikitext). * * @param string $id String to escape * @param int $mode One of ID_* constants, specifying whether the primary or fallback encoding * should be used. * @return string Escaped ID * * @since 1.30 */ public static function escapeIdForAttribute( string $id, int $mode = self::ID_PRIMARY ): string { // For consistency with PHP's API, we accept "primary" or "fallback" as // the mode in 'options'. This (slightly) abstracts the actual details // of the id encoding from the Parsoid code which handles ids; we could // swap primary and fallback here, or even transition to a new HTML6 // encoding (!), without touching all the call sites. $internalMode = $mode === self::ID_FALLBACK ? 'legacy' : 'html5'; return self::escapeIdInternal( $id, $internalMode ); } /** * Given a section name or other user-generated or otherwise unsafe string, escapes it to be * a valid URL fragment. * * WARNING: unlike escapeId(), the output of this function is not guaranteed to be HTML safe, * be sure to use proper escaping. * * @param string $id String to escape * @return string Escaped ID * * @since 1.30 */ public static function escapeIdForLink( string $id ): string { return self::escapeIdInternalUrl( $id, 'html5' ); } /** * Given a section name or other user-generated or otherwise unsafe string, escapes it to be * a valid URL fragment for external interwikis. * * @param string $id String to escape * @return string Escaped ID * * @since 1.30 */ private static function escapeIdForExternalInterwiki( string $id ): string { // Assume $wgExternalInterwikiFragmentMode = 'legacy' return self::escapeIdInternalUrl( $id, 'legacy' ); } /** * Do percent encoding of percent signs for href (but not id) attributes * * @see https://phabricator.wikimedia.org/T238385 * @param string $id String to escape * @param string $mode One of modes from $wgFragmentMode * @return string */ private static function escapeIdInternalUrl( string $id, string $mode ): string { $id = self::escapeIdInternal( $id, $mode ); if ( $mode === 'html5' ) { $id = preg_replace( '/%([a-fA-F0-9]{2})/', '%25$1', $id ); } return $id; } /** * Helper for escapeIdFor*() functions. Performs most of the actual escaping. * * @param string $id String to escape * @param string $mode One of modes from $wgFragmentMode ('html5' or 'legacy') * @return string */ private static function escapeIdInternal( string $id, string $mode ): string { switch ( $mode ) { case 'html5': // html5 spec says ids must not have any of the following: // U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, or U+0020 SPACE // In practice, in wikitext, only tab, LF, CR (and SPACE) are // possible using either Lua or html entities. $id = str_replace( [ "\t", "\n", "\f", "\r", " " ], '_', $id ); break; case 'legacy': // This corresponds to 'noninitial' mode of the old escapeId static $replace = [ '%3A' => ':', '%' => '.' ]; $id = urlencode( str_replace( ' ', '_', $id ) ); $id = strtr( $id, $replace ); break; default: throw new InvalidArgumentException( "Invalid mode '$mode' passed to '" . __METHOD__ ); } return $id; } /** * Given a string containing a space delimited list of ids, escape each id * to match ids escaped by the escapeIdForAttribute() function. * * @since 1.27 * * @param string $referenceString Space delimited list of ids * @return string */ public static function escapeIdReferenceList( string $referenceString ): string { # Explode the space delimited list string into an array of tokens $references = preg_split( '/\s+/', "{$referenceString}", -1, PREG_SPLIT_NO_EMPTY ); # Escape each token as an id foreach ( $references as &$ref ) { $ref = self::escapeIdForAttribute( $ref ); } # Merge the array back to a space delimited list string # If the array is empty, the result will be an empty string ('') $referenceString = implode( ' ', $references ); return $referenceString; } /** * Normalizes whitespace in a section name, such as might be returned * by Parser::stripSectionName(), for use in the ids that are used for * section links. * * @param string $section * @return string */ public static function normalizeSectionNameWhiteSpace( string $section ): string { return trim( preg_replace( '/[ _]+/', ' ', $section ) ); } } PK ! 0y>": ": SectionMetadata.phpnu �Iw�� <?php declare( strict_types = 1 ); namespace Wikimedia\Parsoid\Core; use Wikimedia\JsonCodec\JsonCodecable; use Wikimedia\JsonCodec\JsonCodecableTrait; use Wikimedia\Parsoid\Utils\CompatJsonCodec; /** * Section metadata for generating TOC. * * This is not the complete data for the article section, just the * information needed to generate the table of contents. * * For now, this schema matches whatever is generated by Parser.php. * Parsoid will attempt to match this output for now. * * Parser.php::finalizeHeadings() is the authoritative source for how * some of these properties are computed right now, especially for the * $line, $anchor, and $linkAnchor properties below. * * Linker.php::tocLine() and ::makeHeadline() demonstrate how these * properties are used to create headings and table of contents lines. */ class SectionMetadata implements \JsonSerializable, JsonCodecable { use JsonCodecableTrait; /** * The heading tag level: a 1 here means an <H1> tag was used, a * 2 means an <H2> tag was used, etc. */ public int $hLevel; /** * This is a one-indexed TOC level and the nesting level. * So, if a page has a H2-H4-H6, then, those levels 2,4,6 * correspond to TOC-levels 1,2,3. */ public int $tocLevel; /** * HTML heading of the section. Only a narrow set of HTML tags are allowed here. * * This starts with the parsed headline seen in wikitext and * - replaces links with link text * - processes extension strip markers * - removes style, script tags * - strips all HTML tags except the following tags (from Parser.php) * . <sup> and <sub> (T10393) * . <i> (T28375) * . <b> (r105284) * . <bdi> (T74884) * . <span dir="rtl"> and <span dir="ltr"> (T37167) * . <s> and <strike> (T35715) * . <q> (T251672) * We strip any parameter from accepted tags, except dir="rtl|ltr" from <span>, * to allow setting directionality in toc items. * * @note This should be converted into the proper html variant. */ public string $line; /** * TOC number string (3.1.3, 4.5.2, etc.) * * @note This should be localized into the parser target language. */ public string $number; /** * Section id (integer, assigned in depth first traversal order) * Template generated sections get a "T-" prefix. */ public string $index; /** * The title of the page that generated this heading. * For template-generated sections, this will be the template title. * This string is in "prefixed DB key" format. */ public ?string $fromTitle; /** * Codepoint offset where the section shows up in wikitext; this is null * if this section comes from a template, if it comes from a literal * HTML <h_> tag, or otherwise doesn't correspond to a "preprocessor * section". * @note This is measured in codepoints, not bytes; you should use * appropriate multi-byte aware string functions, *not* substr(). * Similarly, in JavaScript, be careful not to confuse JavaScript * UCS-2 "characters" with codepoints. */ public ?int $codepointOffset; /** * Anchor attribute. * * This property is the "true" value of the ID attribute, and should be * used when looking up a heading or setting an attribute, for example * using Document.getElementById() or Element.setAttribute('id',...). * * This value is *not* HTML-entity escaped; if you are writing HTML * as a literal string, you should still entity-escape ampersands and * single/double quotes as appropriate. * * This value is *not* URL-escaped either; instead use the `linkAnchor` * property if you are constructing a URL to target this section. * * The anchor attribute is based on the $line property, but does extra * processing to turn it into a valid attribute: * - strip all HTML tags, * - normalizes section name * - normalizes section name whitespace * - decodes char references * - makes it a valid HTML id attribute value * (HTML5 / HTML4 based on $wgFragmentMode property) * - dedupes (case-insensitively) identical anchors by adding "_$n" suffixes */ public string $anchor; /** * Anchor URL fragment. * * This is very similar to the $anchor property, but is appropriately * URL-escaped to make it appropriate to use in constructing a URL * fragment link. You should almost always prepend a `#` symbol * to `linkAnchor` if you are using it correctly. You are still * responsible for HTML-escaping the resulting URL if you are emitting * this as an HTML attribute. */ public string $linkAnchor; /** * Arbitrary data attached to this section by extensions. This * data will be stored and cached in the ParserOutput object along * with the rest of the section data, and made available to external * clients via the action API. * * This method is provided to overcome the unsafe practice of attaching * extra information to a section by directly assigning member variables. * * See ParserOutput::setExtensionData() for more information on typical * use. */ private array $extensionData; /** * @param int $tocLevel One-indexed TOC level and the nesting level * @param int $hLevel The heading tag level * @param string $line Stripped headline text * @param string $number TOC number string (3.1.3, 4.5.2, etc) * @param string $index Section id * @param ?string $fromTitle The title of the page or template that * generated this heading, or null. * @param ?int $codepointOffset Codepoint offset (# of characters) where the * section shows up in wikitext, or null if this doesn't correspond to * a "preprocesor section". (Be careful if using JavaScript, as * JavaScript "characters" are UCS-2 encoded and don't correspond * directly to code points.) * @param string $anchor "True" value of the ID attribute * @param string $linkAnchor URL-escaped value of the anchor, for use in * constructing a URL fragment link * @param ?array $extensionData Extension data passed in as an associative array */ public function __construct( // This is a great candidate for named arguments in PHP 8.0+ int $tocLevel = 0, int $hLevel = -1, string $line = '', string $number = '', string $index = '', ?string $fromTitle = null, ?int $codepointOffset = null, string $anchor = '', string $linkAnchor = '', ?array $extensionData = null ) { $this->tocLevel = $tocLevel; $this->line = $line; $this->hLevel = $hLevel; $this->number = $number; $this->index = $index; $this->fromTitle = $fromTitle; $this->codepointOffset = $codepointOffset; $this->anchor = $anchor; $this->linkAnchor = $linkAnchor; $this->extensionData = $extensionData ?? []; } /** * Attaches arbitrary data to this SectionMetadata object. This * can be used to store some information about this section in the * ParserOutput object for later use during page output. The data * will be cached along with the ParserOutput object. * * This method is provided to overcome the unsafe practice of * attaching extra information to a section by directly assigning * member variables. * * See ParserOutput::setExtensionData() in core for further information * about typical usage in hooks. * * Setting conflicting values for the same key is not allowed. * If you call ::setExtensionData() multiple times with the same key * on a SectionMetadata, is is expected that the value will be identical * each time. If you want to collect multiple pieces of data under a * single key, use ::appendExtensionData(). * * @note Only scalar values (numbers, strings, or arrays) are * supported as a value. (A future revision will allow anything * that core's JsonCodec can handle.) Attempts to set other types * as extension data values will break ParserCache for the page. * * @todo When more complex values than scalar values are supported, * TOCData::__clone should be updated to take that into account. * * @param string $key The key for accessing the data. Extensions * should take care to avoid conflicts in naming keys. It is * suggested to use the extension's name as a prefix. Using * the prefix `mw:` is reserved for core. * * @param mixed $value The value to set. * Setting a value to null is equivalent to removing the value. */ public function setExtensionData( string $key, $value ): void { if ( array_key_exists( $key, $this->extensionData ) && $this->extensionData[$key] !== $value ) { throw new \InvalidArgumentException( "Conflicting data for $key" ); } if ( $value === null ) { unset( $this->extensionData[$key] ); } else { $this->extensionData[$key] = $value; } } /** * Appends arbitrary data to this SectionMetadata. This can be used * to store some information about the section in the ParserOutput object for later * use during page output. * * See ::setExtensionData() for more details on rationale and use. * * @param string $key The key for accessing the data. Extensions should take care to avoid * conflicts in naming keys. It is suggested to use the extension's name as a prefix. * * @param int|string $value The value to append to the list. * @return never This method is not yet implemented. */ public function appendExtensionData( string $key, $value ): void { // This implementation would mirror that of // ParserOutput::appendExtensionData, but let's defer implementing // this until we're sure we need it. In particular, we might need // to figure out how a merge on section data is expected to work // before we can determine the right semantics for this. throw new \InvalidArgumentException( "Not yet implemented" ); } /** * Gets extension data previously attached to this SectionMetadata. * * @param string $key The key to look up * @return mixed|null The value(s) previously set for the given key using * ::setExtensionData() or ::appendExtensionData(), or null if no * value was set for this key. */ public function getExtensionData( $key ) { $value = $this->extensionData[$key] ?? null; return $value; } /** * Alias for :toLegacy(), for b/c compatibility only. * @deprecated * @return array */ public function toArray(): array { return $this->toLegacy(); } /** * Alias for :fromLegacy(), for b/c compatibility only. * @deprecated * @param array $data * @return SectionMetadata */ public static function fromArray( array $data ): SectionMetadata { return self::fromLegacy( $data ); } /** * Create a new SectionMetadata object from an array in the legacy * format returned by the action API. * * This is useful for backward-compatibility, but is expected to * be replaced by conversion to/from JSON in the future. * * @param array $data Associative array with section metadata * @return SectionMetadata */ public static function fromLegacy( array $data ): SectionMetadata { return new SectionMetadata( $data['toclevel'] ?? 0, (int)( $data['level'] ?? -1 ), $data['line'] ?? '', $data['number'] ?? '', $data['index'] ?? '', ( $data['fromtitle'] ?? false ) ?: null, $data['byteoffset'] ?? null, // T319141: actually "codepoint offset" $data['anchor'] ?? '', $data['linkAnchor'] ?? $data['anchor'] ?? '', $data['extensionData'] ?? null ); } /** * Return as associative array, in the format returned by the * action API (including the order of fields and the value types). * * This is helpful as b/c support while we transition to objects. * @return array */ public function toLegacy(): array { $ret = [ 'toclevel' => $this->tocLevel, // cast $level to string in order to keep b/c for the parse api 'level' => (string)$this->hLevel, 'line' => $this->line, 'number' => $this->number, 'index' => $this->index, 'fromtitle' => $this->fromTitle ?? false, // T319141: legacy 'byteoffset' is actually "codepoint offset" 'byteoffset' => $this->codepointOffset, 'anchor' => $this->anchor, 'linkAnchor' => $this->linkAnchor, ]; // Micro-opt: Output 'extensionData' conditionally to avoid bloat if ( $this->extensionData ) { $ret['extensionData'] = $this->extensionData; } return $ret; } /** * @inheritDoc */ public function jsonSerialize(): array { return $this->toLegacy(); } // JsonCodecable interface /** @inheritDoc */ public function toJsonArray(): array { $ret = []; if ( $this->tocLevel !== 0 ) { $ret['tocLevel'] = $this->tocLevel; } if ( $this->hLevel !== -1 ) { $ret['hLevel'] = $this->hLevel; } if ( $this->line !== '' ) { $ret['line'] = $this->line; } if ( $this->number !== '' ) { $ret['number'] = $this->number; } if ( $this->index !== '' ) { $ret['index'] = $this->index; } if ( $this->fromTitle !== null ) { $ret['fromTitle'] = $this->fromTitle; } if ( $this->codepointOffset !== null ) { $ret['codepointOffset'] = $this->codepointOffset; } if ( $this->anchor !== '' ) { $ret['anchor'] = $this->anchor; } if ( $this->linkAnchor !== $this->anchor ) { $ret['linkAnchor'] = $this->linkAnchor; } if ( $this->extensionData ) { $ret['extensionData'] = $this->extensionData; } return $ret; } /** @inheritDoc */ public static function newFromJsonArray( array $json ) { return new SectionMetadata( $json['tocLevel'] ?? 0, $json['hLevel'] ?? -1, $json['line'] ?? '', $json['number'] ?? '', $json['index'] ?? '', $json['fromTitle'] ?? null, $json['codepointOffset'] ?? null, $json['anchor'] ?? '', $json['linkAnchor'] ?? $json['anchor'] ?? '', $json['extensionData'] ?? null ); } // Pretty-printing /** * For use in parser tests and wherever else humans might appreciate * some formatting in the JSON encoded output. For now, nothing special. * @param int $indent Additional indentation to apply (defaults to zero) * @return string */ public function prettyPrint( int $indent = 0 ): string { # Basic info $buf = str_repeat( ' ', $indent + $this->tocLevel ) . "h{$this->hLevel}"; $buf .= " index:{$this->index} toclevel:$this->tocLevel number:{$this->number}"; # Optional information $title = $this->fromTitle ?? "NULL"; $offset = $this->codepointOffset ?? "NULL"; $buf .= " title:{$title} off:{$offset}"; # Anchors & link text if ( $this->anchor === $this->linkAnchor ) { $buf .= " anchor/linkAnchor:{$this->anchor}"; } else { $buf .= " anchor:{$this->anchor} linkAnchor:{$this->linkAnchor}"; } $line = $this->line; if ( str_contains( $line, "\n" ) ) { // Handle cases where $line has "funny" characters $line = json_encode( $line ); } $buf .= " line:{$line}"; # Extension data if ( $this->extensionData ) { $codec = new CompatJsonCodec(); $buf .= " ext:" . json_encode( $codec->toJsonArray( $this->extensionData ) ); } return $buf; } } PK ! � � ElementRange.phpnu �Iw�� PK ! ��D�� � < SelserData.phpnu �Iw�� PK ! ��� � G ContentModelHandler.phpnu �Iw�� PK ! ��l9 9 E PageBundle.phpnu �Iw�� PK ! ����K �K � ContentMetadataCollector.phpnu �Iw�� PK ! �*]�5 5 �e MediaStructure.phpnu �Iw�� PK ! �� x� � & Yt ContentMetadataCollectorStringSets.phpnu �Iw�� PK ! �� U� � " /y ResourceLimitExceededException.phpnu �Iw�� PK ! �+�}( }( 1z TOCData.phpnu �Iw�� PK ! vԶ� � � SelectiveUpdateData.phpnu �Iw�� PK ! �A�5� � ʦ LinkTargetTrait.phpnu �Iw�� PK ! sD� > > �� ClientError.phpnu �Iw�� PK ! �%o " � ContentMetadataCollectorCompat.phpnu �Iw�� PK ! ��0�1 1 i� DomSourceRange.phpnu �Iw�� PK ! n�pR �� InternalException.phpnu �Iw�� PK ! A w�� � !� LinkTarget.phpnu �Iw�� PK ! %OG<� <� � Sanitizer.phpnu �Iw�� PK ! 0y>": ": �� SectionMetadata.phpnu �Iw�� PK � ��
| ver. 1.1 | |
.
| PHP 8.4.18 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0.03 |
proxy
|
phpinfo
|
ÐаÑтройка