first commit

wp-content/plugins/woocommerce/lib/LICENSE

@@ -0,0 +1,39 @@
+The folder contains auto generated content.
+
+This program incorporates work covered by the following copyright and
+permission notices:
+
+  Mobiledetect/MobileDetect
+
+  mobiledetect/mobiledetectlib is Copyright (c) 2021 Şerban Ghiţă, Nick Ilyin and contributors.
+  https://github.com/serbanghita/Mobile-Detect
+
+  mobiledetect/mobiledetectlib is released under the MIT License
+  https://github.com/serbanghita/Mobile-Detect/blob/ffafcc0d659e7794f5b4ba611087de1af684f3c2/LICENSE
+
+
+  Pelago/Emogrifier
+
+  pelago/emogrifier is Copyright (c) 2008-2018 Pelago
+  https://github.com/MyIntervals/emogrifier
+
+  pelago/emogrifier is released under the MIT License
+  https://github.com/MyIntervals/emogrifier/blob/2cb1701ab3f23e979a7201d20615b33e31c365d3/LICENSE
+
+
+  Sabberworm/PHP CSS Parser
+
+  sabberworm/php-css-parser is Copyright (c) 2011 Raphael Schweikert, https://www.sabberworm.com/
+
+  sabberworm/php-css-parser is released under the MIT License
+  https://github.com/MyIntervals/PHP-CSS-Parser/blob/92432abc08758613a166fc5af5fa89c15aca4af3/LICENSE
+
+
+  Psr/Container interface
+
+  psr/container is Copyright (c) 2013-2016 container-interop
+  Copyright (c) 2016 PHP Framework Interoperability Group
+  https://github.com/php-fig/container
+
+  psr/container is released under the MIT License
+  https://github.com/php-fig/container/blob/707984727bd5b2b670e59559d3ed2500240cf875/LICENSE

wp-content/plugins/woocommerce/lib/classes/symfony/polyfill-php80/Resources/stubs/Attribute.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#[WC_Vendor_Attribute(Attribute::TARGET_CLASS)]
+final class WC_Vendor_Attribute
+{
+    public const TARGET_CLASS = 1;
+    public const TARGET_FUNCTION = 2;
+    public const TARGET_METHOD = 4;
+    public const TARGET_PROPERTY = 8;
+    public const TARGET_CLASS_CONSTANT = 16;
+    public const TARGET_PARAMETER = 32;
+    public const TARGET_ALL = 63;
+    public const IS_REPEATABLE = 64;
+
+    /** @var int */
+    public $flags;
+
+    public function __construct(int $flags = self::TARGET_ALL)
+    {
+        $this->flags = $flags;
+    }
+}

wp-content/plugins/woocommerce/lib/classes/symfony/polyfill-php80/Resources/stubs/PhpToken.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if (\PHP_VERSION_ID < 80000 && extension_loaded('tokenizer')) {
+    class WC_Vendor_PhpToken extends Symfony\Polyfill\Php80\WC_Vendor_PhpToken
+    {
+    }
+}

wp-content/plugins/woocommerce/lib/classes/symfony/polyfill-php80/Resources/stubs/Stringable.php

@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if (\PHP_VERSION_ID < 80000) {
+    interface WC_Vendor_Stringable
+    {
+        /**
+         * @return string
+         */
+        public function __toString();
+    }
+}

wp-content/plugins/woocommerce/lib/classes/symfony/polyfill-php80/Resources/stubs/UnhandledMatchError.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if (\PHP_VERSION_ID < 80000) {
+    class WC_Vendor_UnhandledMatchError extends Error
+    {
+    }
+}

wp-content/plugins/woocommerce/lib/classes/symfony/polyfill-php80/Resources/stubs/ValueError.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if (\PHP_VERSION_ID < 80000) {
+    class WC_Vendor_ValueError extends Error
+    {
+    }
+}

wp-content/plugins/woocommerce/lib/composer.json

@@ -0,0 +1,57 @@
+{
+	"name": "woocommerce/woocommerce-lib",
+	"description": "A package for hiding re-namespaced dependencies and executing them",
+	"prefer-stable": true,
+	"minimum-stability": "dev",
+	"require": {
+		"php": ">=7.4"
+	},
+	"require-dev": {
+		"mobiledetect/mobiledetectlib": "^3.74",
+		"psr/container": "^1.1",
+		"pelago/emogrifier": "7.3.0",
+		"league/iso3166": "^4.3.3"
+	},
+	"config": {
+		"platform": {
+			"php": "7.4"
+		}
+	},
+	"scripts": {
+		"post-install-cmd": [
+			"\"../vendor/bin/mozart\" compose"
+		],
+		"post-update-cmd": [
+			"\"../vendor/bin/mozart\" compose"
+		]
+	},
+	"extra": {
+		"mozart": {
+			"dep_namespace": "Automattic\\WooCommerce\\Vendor\\",
+			"dep_directory": "/packages/",
+			"packages": [
+				"psr/container",
+				"mobiledetect/mobiledetectlib",
+				"pelago/emogrifier",
+				"league/iso3166"
+			],
+			"excluded_packages": [
+			],
+			"override_autoload": {
+				"mobiledetect/mobiledetectlib": {
+					"psr-4": {
+						"Detection\\": "src/"
+					}
+				},
+				"thecodingmachine/safe": {
+					"psr-4": {
+						"Safe\\": ""
+					}
+				}
+			},
+			"classmap_directory": "/classes/",
+			"classmap_prefix": "WC_Vendor_",
+			"delete_vendor_directories": true
+		} 
+	}
+}

wp-content/plugins/woocommerce/lib/packages/League/ISO3166/Exception/DomainException.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * (c) Rob Bast <rob.bast@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\League\ISO3166\Exception;
+
+final class DomainException extends \DomainException implements ISO3166Exception
+{
+}

wp-content/plugins/woocommerce/lib/packages/League/ISO3166/Exception/ISO3166Exception.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * (c) Rob Bast <rob.bast@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\League\ISO3166\Exception;
+
+interface ISO3166Exception extends \Throwable
+{
+}

wp-content/plugins/woocommerce/lib/packages/League/ISO3166/Exception/OutOfBoundsException.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * (c) Rob Bast <rob.bast@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\League\ISO3166\Exception;
+
+final class OutOfBoundsException extends \OutOfBoundsException implements ISO3166Exception
+{
+}

wp-content/plugins/woocommerce/lib/packages/League/ISO3166/Guards.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * (c) Rob Bast <rob.bast@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\League\ISO3166;
+
+use Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException;
+
+final class Guards
+{
+    /**
+     * Assert that input is not an empty string.
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if input is an empty string
+     */
+    public static function guardAgainstInvalidName(string $name): void
+    {
+        if ('' === trim($name)) {
+            throw new DomainException('Expected string, got empty string');
+        }
+    }
+
+    /**
+     * Assert that input looks like an alpha2 key.
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if input does not look like an alpha2 key
+     */
+    public static function guardAgainstInvalidAlpha2(string $alpha2): void
+    {
+        if (1 !== preg_match('/^[a-zA-Z]{2}$/', $alpha2)) {
+            throw new DomainException(sprintf('Not a valid alpha2 key: %s', $alpha2));
+        }
+    }
+
+    /**
+     * Assert that input looks like an alpha3 key.
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if input does not look like an alpha3 key
+     */
+    public static function guardAgainstInvalidAlpha3(string $alpha3): void
+    {
+        if (1 !== preg_match('/^[a-zA-Z]{3}$/', $alpha3)) {
+            throw new DomainException(sprintf('Not a valid alpha3 key: %s', $alpha3));
+        }
+    }
+
+    /**
+     * Assert that input looks like a numeric key.
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if input does not look like a numeric key
+     */
+    public static function guardAgainstInvalidNumeric(string $numeric): void
+    {
+        if (1 !== preg_match('/^\d{3}$/', $numeric)) {
+            throw new DomainException(sprintf('Not a valid numeric key: %s', $numeric));
+        }
+    }
+}

wp-content/plugins/woocommerce/lib/packages/League/ISO3166/ISO3166DataProvider.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * (c) Rob Bast <rob.bast@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\League\ISO3166;
+
+interface ISO3166DataProvider
+{
+    /**
+     * Lookup ISO3166-1 data by name identifier.
+     *
+     * @api
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\OutOfBoundsException if input does not exist in dataset
+     *
+     * @return array<string, mixed>
+     */
+    public function name(string $name): array;
+
+    /**
+     * Lookup ISO3166-1 data by alpha2 identifier.
+     *
+     * @api
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if input does not look like an alpha2 key
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\OutOfBoundsException if input does not exist in dataset
+     *
+     * @return array<string, mixed>
+     */
+    public function alpha2(string $alpha2): array;
+
+    /**
+     * Lookup ISO3166-1 data by alpha3 identifier.
+     *
+     * @api
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if input does not look like an alpha3 key
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\OutOfBoundsException if input does not exist in dataset
+     *
+     * @return array<string, mixed>
+     */
+    public function alpha3(string $alpha3): array;
+
+    /**
+     * Lookup ISO3166-1 data by numeric identifier (numerical string, that is).
+     *
+     * @api
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if input does not look like a numeric key
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\OutOfBoundsException if input does not exist in dataset
+     *
+     * @return array<string, mixed>
+     */
+    public function numeric(string $numeric): array;
+}

wp-content/plugins/woocommerce/lib/packages/League/ISO3166/ISO3166DataValidator.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * (c) Rob Bast <rob.bast@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\League\ISO3166;
+
+use Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException;
+
+final class ISO3166DataValidator
+{
+    /**
+     * @param array<array<string, mixed>> $data
+     *
+     * @return array<array<string, mixed>>
+     */
+    public function validate(array $data): array
+    {
+        foreach ($data as $entry) {
+            $this->assertEntryHasRequiredKeys($entry);
+        }
+
+        return $data;
+    }
+
+    /**
+     * @param array<string, mixed> $entry
+     *
+     * @throws \Automattic\WooCommerce\Vendor\League\ISO3166\Exception\DomainException if given data entry does not have all the required keys
+     */
+    private function assertEntryHasRequiredKeys(array $entry): void
+    {
+        if (!isset($entry[ISO3166::KEY_NAME])) {
+            throw new DomainException('Each data entry must have a name key.');
+        }
+
+        Guards::guardAgainstInvalidName($entry[ISO3166::KEY_NAME]);
+
+        if (!isset($entry[ISO3166::KEY_ALPHA2])) {
+            throw new DomainException('Each data entry must have a alpha2 key.');
+        }
+
+        Guards::guardAgainstInvalidAlpha2($entry[ISO3166::KEY_ALPHA2]);
+
+        if (!isset($entry[ISO3166::KEY_ALPHA3])) {
+            throw new DomainException('Each data entry must have a alpha3 key.');
+        }
+
+        Guards::guardAgainstInvalidAlpha3($entry[ISO3166::KEY_ALPHA3]);
+
+        if (!isset($entry[ISO3166::KEY_NUMERIC])) {
+            throw new DomainException('Each data entry must have a numeric key.');
+        }
+
+        Guards::guardAgainstInvalidNumeric($entry[ISO3166::KEY_NUMERIC]);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/League/ISO3166/ISO3166WithAliases.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * (c) Rob Bast <rob.bast@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\League\ISO3166;
+
+class ISO3166WithAliases implements ISO3166DataProvider
+{
+    private ISO3166DataProvider $source;
+
+    /** @type array<string, string> */
+    public const aliases = [
+        'Bolivia' => 'Bolivia (Plurinational State of)',
+        'Bolivia, Plurinational State of' => 'Bolivia (Plurinational State of)',
+        'Congo-Kinshasa' => 'Congo (Democratic Republic of the)',
+        'Congo, Democratic Republic of the' => 'Congo (Democratic Republic of the)',
+        'Czech Republic' => 'Czechia',
+        'Iran' => 'Iran (Islamic Republic of)',
+        'North Korea' => 'Korea (Democratic People\'s Republic of)',
+        'South Korea' => 'Korea (Republic of)',
+        'Laos' => 'Lao People\'s Democratic Republic',
+        'Micronesia' => 'Micronesia (Federated States of)',
+        'Moldova' => 'Moldova (Republic of)',
+        'Palestine' => 'Palestine, State of',
+        'Russia' => 'Russian Federation',
+        'Saint Martin' => 'Saint Martin (French part)',
+        'Sint Maarten' => 'Sint Maarten (Dutch part)',
+        'Taiwan' => 'Taiwan (Province of China)',
+        'Tanzania' => 'Tanzania, United Republic of',
+        'United Kingdom' => 'United Kingdom of Great Britain and Northern Ireland',
+        'United States' => 'United States of America',
+        'USA' => 'United States of America',
+        'Venezuela' => 'Venezuela (Bolivarian Republic of)',
+        'Vietnam' => 'Viet Nam',
+    ];
+
+    public function __construct(ISO3166DataProvider $iso3166)
+    {
+        $this->source = $iso3166;
+    }
+
+    public function name(string $name): array
+    {
+        foreach (self::aliases as $alias => $original) {
+            if (0 === strcasecmp($alias, $name)) {
+                $name = $original;
+                break;
+            }
+        }
+
+        return $this->source->name($name);
+    }
+
+    public function alpha2(string $alpha2): array
+    {
+        return $this->source->alpha2($alpha2);
+    }
+
+    public function alpha3(string $alpha3): array
+    {
+        return $this->source->alpha3($alpha3);
+    }
+
+    public function numeric(string $numeric): array
+    {
+        return $this->source->numeric($numeric);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/Caching/SimpleStringCache.php

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Caching;
+
+/**
+ * This cache caches string values with string keys. It is not PSR-6-compliant.
+ *
+ * Usage:
+ *
+ * ```php
+ * $cache = new SimpleStringCache();
+ * $cache->set($key, $value);
+ * …
+ * if ($cache->has($key) {
+ *     $cachedValue = $cache->get($value);
+ * }
+ * ```
+ *
+ * @internal
+ */
+final class SimpleStringCache
+{
+    /**
+     * @var array<string, string>
+     */
+    private $values = [];
+
+    /**
+     * Checks whether there is an entry stored for the given key.
+     *
+     * @param string $key the key to check; must not be empty
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function has(string $key): bool
+    {
+        $this->assertNotEmptyKey($key);
+
+        return isset($this->values[$key]);
+    }
+
+    /**
+     * Returns the entry stored for the given key, and throws an exception if the value does not exist
+     * (which helps keep the return type simple).
+     *
+     * @param string $key the key to of the item to retrieve; must not be empty
+     *
+     * @return string the retrieved value; may be empty
+     *
+     * @throws \BadMethodCallException
+     */
+    public function get(string $key): string
+    {
+        if (!$this->has($key)) {
+            throw new \BadMethodCallException('You can only call `get` with a key for an existing value.', 1625996246);
+        }
+
+        return $this->values[$key];
+    }
+
+    /**
+     * Sets or overwrites an entry.
+     *
+     * @param string $key the key to of the item to set; must not be empty
+     * @param string $value the value to set; can be empty
+     *
+     * @throws \BadMethodCallException
+     */
+    public function set(string $key, string $value): void
+    {
+        $this->assertNotEmptyKey($key);
+
+        $this->values[$key] = $value;
+    }
+
+    /**
+     * @throws \InvalidArgumentException
+     */
+    private function assertNotEmptyKey(string $key): void
+    {
+        if ($key === '') {
+            throw new \InvalidArgumentException('Please provide a non-empty key.', 1625995840);
+        }
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/Css/CssDocument.php

@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Css;
+
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\Preg;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList\AtRuleBlockList as CssAtRuleBlockList;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList\Document as SabberwormCssDocument;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parser as CssParser;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\AtRule as CssAtRule;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Charset as CssCharset;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Import as CssImport;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Renderable as CssRenderable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\DeclarationBlock as CssDeclarationBlock;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\RuleSet as CssRuleSet;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Settings as ParserSettings;
+
+/**
+ * Parses and stores a CSS document from a string of CSS, and provides methods to obtain the CSS in parts or as data
+ * structures.
+ *
+ * @internal
+ */
+final class CssDocument
+{
+    /**
+     * @var SabberwormCssDocument
+     */
+    private $sabberwormCssDocument;
+
+    /**
+     * `@import` rules must precede all other types of rules, except `@charset` rules.  This property is used while
+     * rendering at-rules to enforce that.
+     *
+     * @var bool
+     */
+    private $isImportRuleAllowed = true;
+
+    /**
+     * @param string $css
+     * @param bool $debug
+     *        If this is `true`, an exception will be thrown if invalid CSS is encountered.
+     *        Otherwise the parser will try to do the best it can.
+     */
+    public function __construct(string $css, bool $debug)
+    {
+        // CSS Parser currently throws exception with nested at-rules (like `@media`) in strict parsing mode
+        $parserSettings = ParserSettings::create()->withLenientParsing(!$debug || $this->hasNestedAtRule($css));
+
+        // CSS Parser currently throws exception with non-empty whitespace-only CSS in strict parsing mode, so `trim()`
+        // @see https://github.com/sabberworm/PHP-CSS-Parser/issues/349
+        $this->sabberwormCssDocument = (new CssParser(\trim($css), $parserSettings))->parse();
+    }
+
+    /**
+     * Tests if a string of CSS appears to contain an at-rule with nested rules
+     * (`@media`, `@supports`, `@keyframes`, `@document`,
+     * the latter two additionally with vendor prefixes that may commonly be used).
+     *
+     * @see https://github.com/sabberworm/PHP-CSS-Parser/issues/127
+     */
+    private function hasNestedAtRule(string $css): bool
+    {
+        return (new Preg())
+            ->match('/@(?:media|supports|(?:-webkit-|-moz-|-ms-|-o-)?+(keyframes|document))\\b/', $css) !== 0;
+    }
+
+    /**
+     * Collates the media query, selectors and declarations for individual rules from the parsed CSS, in order.
+     *
+     * @param array<array-key, string> $allowedMediaTypes
+     *
+     * @return list<StyleRule>
+     */
+    public function getStyleRulesData(array $allowedMediaTypes): array
+    {
+        $ruleMatches = [];
+        /** @var CssRenderable $rule */
+        foreach ($this->sabberwormCssDocument->getContents() as $rule) {
+            if ($rule instanceof CssAtRuleBlockList) {
+                $containingAtRule = $this->getFilteredAtIdentifierAndRule($rule, $allowedMediaTypes);
+                if (\is_string($containingAtRule)) {
+                    /** @var CssRenderable $nestedRule */
+                    foreach ($rule->getContents() as $nestedRule) {
+                        if ($nestedRule instanceof CssDeclarationBlock) {
+                            $ruleMatches[] = new StyleRule($nestedRule, $containingAtRule);
+                        }
+                    }
+                }
+            } elseif ($rule instanceof CssDeclarationBlock) {
+                $ruleMatches[] = new StyleRule($rule);
+            }
+        }
+
+        return $ruleMatches;
+    }
+
+    /**
+     * Renders at-rules from the parsed CSS that are valid and not conditional group rules (i.e. not rules such as
+     * `@media` which contain style rules whose data is returned by {@see getStyleRulesData}).  Also does not render
+     * `@charset` rules; these are discarded (only UTF-8 is supported).
+     *
+     * @return string
+     */
+    public function renderNonConditionalAtRules(): string
+    {
+        $this->isImportRuleAllowed = true;
+        $cssContents = $this->sabberwormCssDocument->getContents();
+        $atRules = \array_filter($cssContents, [$this, 'isValidAtRuleToRender']);
+
+        if ($atRules === []) {
+            return '';
+        }
+
+        $atRulesDocument = new SabberwormCssDocument();
+        $atRulesDocument->setContents($atRules);
+
+        return $atRulesDocument->render();
+    }
+
+    /**
+     * @param CssAtRuleBlockList $rule
+     * @param array<array-key, string> $allowedMediaTypes
+     *
+     * @return ?string
+     *         If the nested at-rule is supported, it's opening declaration (e.g. "@media (max-width: 768px)") is
+     *         returned; otherwise the return value is null.
+     */
+    private function getFilteredAtIdentifierAndRule(CssAtRuleBlockList $rule, array $allowedMediaTypes): ?string
+    {
+        $result = null;
+
+        if ($rule->atRuleName() === 'media') {
+            $mediaQueryList = $rule->atRuleArgs();
+            [$mediaType] = \explode('(', $mediaQueryList, 2);
+            if (\trim($mediaType) !== '') {
+                $escapedAllowedMediaTypes = \array_map(
+                    static function (string $allowedMediaType): string {
+                        return \preg_quote($allowedMediaType, '/');
+                    },
+                    $allowedMediaTypes
+                );
+                $mediaTypesMatcher = \implode('|', $escapedAllowedMediaTypes);
+                $isAllowed
+                    = (new Preg())->match('/^\\s*+(?:only\\s++)?+(?:' . $mediaTypesMatcher . ')/i', $mediaType) !== 0;
+            } else {
+                $isAllowed = true;
+            }
+
+            if ($isAllowed) {
+                $result = '@media ' . $mediaQueryList;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Tests if a CSS rule is an at-rule that should be passed though and copied to a `<style>` element unmodified:
+     * - `@charset` rules are discarded - only UTF-8 is supported - `false` is returned;
+     * - `@import` rules are passed through only if they satisfy the specification ("user agents must ignore any
+     *   '@import' rule that occurs inside a block or after any non-ignored statement other than an '@charset' or an
+     *   '@import' rule");
+     * - `@media` rules are processed separately to see if their nested rules apply - `false` is returned;
+     * - `@font-face` rules are checked for validity - they must contain both a `src` and `font-family` property;
+     * - other at-rules are assumed to be valid and treated as a black box - `true` is returned.
+     *
+     * @param CssRenderable $rule
+     *
+     * @return bool
+     */
+    private function isValidAtRuleToRender(CssRenderable $rule): bool
+    {
+        if ($rule instanceof CssCharset) {
+            return false;
+        }
+
+        if ($rule instanceof CssImport) {
+            return $this->isImportRuleAllowed;
+        }
+
+        $this->isImportRuleAllowed = false;
+
+        if (!$rule instanceof CssAtRule) {
+            return false;
+        }
+
+        switch ($rule->atRuleName()) {
+            case 'media':
+                $result = false;
+                break;
+            case 'font-face':
+                $result = $rule instanceof CssRuleSet
+                    && $rule->getRules('font-family') !== []
+                    && $rule->getRules('src') !== [];
+                break;
+            default:
+                $result = true;
+        }
+
+        return $result;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/Css/StyleRule.php

@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Css;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Selector;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\DeclarationBlock;
+
+/**
+ * This class represents a CSS style rule, including selectors, a declaration block, and an optional containing at-rule.
+ *
+ * @internal
+ */
+final class StyleRule
+{
+    /**
+     * @var DeclarationBlock
+     */
+    private $declarationBlock;
+
+    /**
+     * @var string
+     */
+    private $containingAtRule;
+
+    /**
+     * @param DeclarationBlock $declarationBlock
+     * @param string $containingAtRule e.g. `@media screen and (max-width: 480px)`
+     */
+    public function __construct(DeclarationBlock $declarationBlock, string $containingAtRule = '')
+    {
+        $this->declarationBlock = $declarationBlock;
+        $this->containingAtRule = \trim($containingAtRule);
+    }
+
+    /**
+     * @return array<int, string> the selectors, e.g. `["h1", "p"]`
+     */
+    public function getSelectors(): array
+    {
+        /** @var array<int, Selector> $selectors */
+        $selectors = $this->declarationBlock->getSelectors();
+        return \array_map(
+            static function (Selector $selector): string {
+                return (string) $selector;
+            },
+            $selectors
+        );
+    }
+
+    /**
+     * @return string the CSS declarations, separated and followed by a semicolon, e.g., `color: red; height: 4px;`
+     */
+    public function getDeclarationAsText(): string
+    {
+        return \implode(' ', $this->declarationBlock->getRules());
+    }
+
+    /**
+     * Checks whether the declaration block has at least one declaration.
+     */
+    public function hasAtLeastOneDeclaration(): bool
+    {
+        return $this->declarationBlock->getRules() !== [];
+    }
+
+    /**
+     * @returns string e.g. `@media screen and (max-width: 480px)`, or an empty string
+     */
+    public function getContainingAtRule(): string
+    {
+        return $this->containingAtRule;
+    }
+
+    /**
+     * Checks whether the containing at-rule is non-empty and has any non-whitespace characters.
+     */
+    public function hasContainingAtRule(): bool
+    {
+        return $this->getContainingAtRule() !== '';
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/HtmlProcessor/AbstractHtmlProcessor.php

@@ -0,0 +1,478 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\HtmlProcessor;
+
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\Preg;
+
+/**
+ * Base class for HTML processor that e.g., can remove, add or modify nodes or attributes.
+ *
+ * The "vanilla" subclass is the HtmlNormalizer.
+ */
+abstract class AbstractHtmlProcessor
+{
+    /**
+     * @var string
+     */
+    protected const DEFAULT_DOCUMENT_TYPE = '<!DOCTYPE html>';
+
+    /**
+     * @var string
+     */
+    protected const CONTENT_TYPE_META_TAG = '<meta http-equiv="Content-Type" content="text/html; charset=utf-8">';
+
+    /**
+     * @var string Regular expression part to match tag names that PHP's DOMDocument implementation is not aware are
+     *      self-closing. These are mostly HTML5 elements, but for completeness <command> (obsolete) and <keygen>
+     *      (deprecated) are also included.
+     *
+     * @see https://bugs.php.net/bug.php?id=73175
+     */
+    protected const PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER = '(?:command|embed|keygen|source|track|wbr)';
+
+    /**
+     * Regular expression part to match tag names that may appear before the start of the `<body>` element.  A start tag
+     * for any other element would implicitly start the `<body>` element due to tag omission rules.
+     *
+     * @var string
+     */
+    protected const TAGNAME_ALLOWED_BEFORE_BODY_MATCHER
+        = '(?:html|head|base|command|link|meta|noscript|script|style|template|title)';
+
+    /**
+     * regular expression pattern to match an HTML comment, including delimiters and modifiers
+     *
+     * @var string
+     */
+    protected const HTML_COMMENT_PATTERN = '/<!--[^-]*+(?:-(?!->)[^-]*+)*+(?:-->|$)/';
+
+    /**
+     * regular expression pattern to match an HTML `<template>` element, including delimiters and modifiers
+     *
+     * @var string
+     */
+    protected const HTML_TEMPLATE_ELEMENT_PATTERN
+        = '%<template[\\s>][^<]*+(?:<(?!/template>)[^<]*+)*+(?:</template>|$)%i';
+
+    /**
+     * @var ?\DOMDocument
+     */
+    protected $domDocument = null;
+
+    /**
+     * @var ?\DOMXPath
+     */
+    private $xPath = null;
+
+    /**
+     * The constructor.
+     *
+     * Please use `::fromHtml` or `::fromDomDocument` instead.
+     */
+    private function __construct() {}
+
+    /**
+     * Builds a new instance from the given HTML.
+     *
+     * @param string $unprocessedHtml raw HTML, must be UTF-encoded, must not be empty
+     *
+     * @return static
+     *
+     * @throws \InvalidArgumentException if $unprocessedHtml is anything other than a non-empty string
+     */
+    public static function fromHtml(string $unprocessedHtml): self
+    {
+        if ($unprocessedHtml === '') {
+            throw new \InvalidArgumentException('The provided HTML must not be empty.', 1515763647);
+        }
+
+        $instance = new static();
+        $instance->setHtml($unprocessedHtml);
+
+        return $instance;
+    }
+
+    /**
+     * Builds a new instance from the given DOM document.
+     *
+     * @param \DOMDocument $document a DOM document returned by getDomDocument() of another instance
+     *
+     * @return static
+     */
+    public static function fromDomDocument(\DOMDocument $document): self
+    {
+        $instance = new static();
+        $instance->setDomDocument($document);
+
+        return $instance;
+    }
+
+    /**
+     * Sets the HTML to process.
+     *
+     * @param string $html the HTML to process, must be UTF-8-encoded
+     */
+    private function setHtml(string $html): void
+    {
+        $this->createUnifiedDomDocument($html);
+    }
+
+    /**
+     * Provides access to the internal DOMDocument representation of the HTML in its current state.
+     *
+     * @return \DOMDocument
+     *
+     * @throws \UnexpectedValueException
+     */
+    public function getDomDocument(): \DOMDocument
+    {
+        if (!$this->domDocument instanceof \DOMDocument) {
+            $message = self::class . '::setDomDocument() has not yet been called on ' . static::class;
+            throw new \UnexpectedValueException($message, 1570472239);
+        }
+
+        return $this->domDocument;
+    }
+
+    /**
+     * @param \DOMDocument $domDocument
+     */
+    private function setDomDocument(\DOMDocument $domDocument): void
+    {
+        $this->domDocument = $domDocument;
+        $this->xPath = new \DOMXPath($this->domDocument);
+    }
+
+    /**
+     * @return \DOMXPath
+     *
+     * @throws \UnexpectedValueException
+     */
+    protected function getXPath(): \DOMXPath
+    {
+        if (!$this->xPath instanceof \DOMXPath) {
+            $message = self::class . '::setDomDocument() has not yet been called on ' . static::class;
+            throw new \UnexpectedValueException($message, 1617819086);
+        }
+
+        return $this->xPath;
+    }
+
+    /**
+     * Renders the normalized and processed HTML.
+     *
+     * @return string
+     */
+    public function render(): string
+    {
+        $htmlWithPossibleErroneousClosingTags = $this->getDomDocument()->saveHTML();
+
+        return $this->removeSelfClosingTagsClosingTags($htmlWithPossibleErroneousClosingTags);
+    }
+
+    /**
+     * Renders the content of the BODY element of the normalized and processed HTML.
+     *
+     * @return string
+     */
+    public function renderBodyContent(): string
+    {
+        $htmlWithPossibleErroneousClosingTags = $this->getDomDocument()->saveHTML($this->getBodyElement());
+        $bodyNodeHtml = $this->removeSelfClosingTagsClosingTags($htmlWithPossibleErroneousClosingTags);
+
+        return (new Preg())->replace('%</?+body(?:\\s[^>]*+)?+>%', '', $bodyNodeHtml);
+    }
+
+    /**
+     * Eliminates any invalid closing tags for void elements from the given HTML.
+     *
+     * @param string $html
+     *
+     * @return string
+     */
+    private function removeSelfClosingTagsClosingTags(string $html): string
+    {
+        return (new Preg())->replace('%</' . self::PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER . '>%', '', $html);
+    }
+
+    /**
+     * Returns the HTML element.
+     *
+     * This method assumes that there always is an HTML element, throwing an exception otherwise.
+     *
+     * @throws \UnexpectedValueException
+     */
+    protected function getHtmlElement(): \DOMElement
+    {
+        $htmlElement = $this->getDomDocument()->getElementsByTagName('html')->item(0);
+        if (!$htmlElement instanceof \DOMElement) {
+            throw new \UnexpectedValueException('There is no HTML element although there should be one.', 1569930853);
+        }
+
+        return $htmlElement;
+    }
+
+    /**
+     * Returns the BODY element.
+     *
+     * This method assumes that there always is a BODY element.
+     *
+     * @return \DOMElement
+     *
+     * @throws \RuntimeException
+     */
+    private function getBodyElement(): \DOMElement
+    {
+        $node = $this->getDomDocument()->getElementsByTagName('body')->item(0);
+        if (!$node instanceof \DOMElement) {
+            throw new \RuntimeException('There is no body element.', 1617922607);
+        }
+
+        return $node;
+    }
+
+    /**
+     * Creates a DOM document from the given HTML and stores it in $this->domDocument.
+     *
+     * The DOM document will always have a BODY element and a document type.
+     *
+     * @param string $html
+     */
+    private function createUnifiedDomDocument(string $html): void
+    {
+        $this->createRawDomDocument($html);
+        $this->ensureExistenceOfBodyElement();
+    }
+
+    /**
+     * Creates a DOMDocument instance from the given HTML and stores it in $this->domDocument.
+     *
+     * @param string $html
+     */
+    private function createRawDomDocument(string $html): void
+    {
+        $domDocument = new \DOMDocument();
+        $domDocument->strictErrorChecking = false;
+        $domDocument->formatOutput = false;
+        $libXmlState = \libxml_use_internal_errors(true);
+        $domDocument->loadHTML($this->prepareHtmlForDomConversion($html));
+        \libxml_clear_errors();
+        \libxml_use_internal_errors($libXmlState);
+
+        $this->setDomDocument($domDocument);
+    }
+
+    /**
+     * Returns the HTML with added document type, Content-Type meta tag, and self-closing slashes, if needed,
+     * ensuring that the HTML will be good for creating a DOM document from it.
+     *
+     * @param string $html
+     *
+     * @return string the unified HTML
+     */
+    private function prepareHtmlForDomConversion(string $html): string
+    {
+        $htmlWithSelfClosingSlashes = $this->ensurePhpUnrecognizedSelfClosingTagsAreXml($html);
+        $htmlWithDocumentType = $this->ensureDocumentType($htmlWithSelfClosingSlashes);
+
+        return $this->addContentTypeMetaTag($htmlWithDocumentType);
+    }
+
+    /**
+     * Makes sure that the passed HTML has a document type, with lowercase "html".
+     *
+     * @param string $html
+     *
+     * @return string HTML with document type
+     */
+    private function ensureDocumentType(string $html): string
+    {
+        $hasDocumentType = \stripos($html, '<!DOCTYPE') !== false;
+        if ($hasDocumentType) {
+            return $this->normalizeDocumentType($html);
+        }
+
+        return self::DEFAULT_DOCUMENT_TYPE . $html;
+    }
+
+    /**
+     * Makes sure the document type in the passed HTML has lowercase "html".
+     *
+     * @param string $html
+     *
+     * @return string HTML with normalized document type
+     */
+    private function normalizeDocumentType(string $html): string
+    {
+        // Limit to replacing the first occurrence: as an optimization; and in case an example exists as unescaped text.
+        return (new Preg())->replace(
+            '/<!DOCTYPE\\s++html(?=[\\s>])/i',
+            '<!DOCTYPE html',
+            $html,
+            1
+        );
+    }
+
+    /**
+     * Adds a Content-Type meta tag for the charset.
+     *
+     * This method also ensures that there is a HEAD element.
+     *
+     * @param string $html
+     *
+     * @return string the HTML with the meta tag added
+     */
+    private function addContentTypeMetaTag(string $html): string
+    {
+        if ($this->hasContentTypeMetaTagInHead($html)) {
+            return $html;
+        }
+
+        // We are trying to insert the meta tag to the right spot in the DOM.
+        // If we just prepended it to the HTML, we would lose attributes set to the HTML tag.
+        $hasHeadTag = (new Preg())->match('/<head[\\s>]/i', $html) !== 0;
+        $hasHtmlTag = \stripos($html, '<html') !== false;
+
+        if ($hasHeadTag) {
+            $reworkedHtml = (new Preg())->replace(
+                '/<head(?=[\\s>])([^>]*+)>/i',
+                '<head$1>' . self::CONTENT_TYPE_META_TAG,
+                $html
+            );
+        } elseif ($hasHtmlTag) {
+            $reworkedHtml = (new Preg())->replace(
+                '/<html(.*?)>/is',
+                '<html$1><head>' . self::CONTENT_TYPE_META_TAG . '</head>',
+                $html
+            );
+        } else {
+            $reworkedHtml = self::CONTENT_TYPE_META_TAG . $html;
+        }
+
+        return $reworkedHtml;
+    }
+
+    /**
+     * Tests whether the given HTML has a valid `Content-Type` metadata element within the `<head>` element.  Due to tag
+     * omission rules, HTML parsers are expected to end the `<head>` element and start the `<body>` element upon
+     * encountering a start tag for any element which is permitted only within the `<body>`.
+     *
+     * @param string $html
+     *
+     * @return bool
+     */
+    private function hasContentTypeMetaTagInHead(string $html): bool
+    {
+        (new Preg())->match(
+            '%^.*?(?=<meta(?=\\s)[^>]*\\shttp-equiv=(["\']?+)Content-Type\\g{-1}[\\s/>])%is',
+            $html,
+            $matches
+        );
+        if (isset($matches[0])) {
+            $htmlBefore = $matches[0];
+            try {
+                $hasContentTypeMetaTagInHead = !$this->hasEndOfHeadElement($htmlBefore);
+            } catch (\RuntimeException $exception) {
+                // If something unexpected occurs, assume the `Content-Type` that was found is valid.
+                \trigger_error($exception->getMessage());
+                $hasContentTypeMetaTagInHead = true;
+            }
+        } else {
+            $hasContentTypeMetaTagInHead = false;
+        }
+
+        return $hasContentTypeMetaTagInHead;
+    }
+
+    /**
+     * Tests whether the `<head>` element ends within the given HTML.  Due to tag omission rules, HTML parsers are
+     * expected to end the `<head>` element and start the `<body>` element upon encountering a start tag for any element
+     * which is permitted only within the `<body>`.
+     *
+     * @param string $html
+     *
+     * @return bool
+     *
+     * @throws \RuntimeException
+     */
+    private function hasEndOfHeadElement(string $html): bool
+    {
+        if (
+            (new Preg())->match('%<(?!' . self::TAGNAME_ALLOWED_BEFORE_BODY_MATCHER . '[\\s/>])\\w|</head>%i', $html)
+            !== 0
+        ) {
+            // An exception to the implicit end of the `<head>` is any content within a `<template>` element, as well in
+            // comments.  As an optimization, this is only checked for if a potential `<head>` end tag is found.
+            $htmlWithoutCommentsOrTemplates = $this->removeHtmlTemplateElements($this->removeHtmlComments($html));
+            $hasEndOfHeadElement = $htmlWithoutCommentsOrTemplates === $html
+                || $this->hasEndOfHeadElement($htmlWithoutCommentsOrTemplates);
+        } else {
+            $hasEndOfHeadElement = false;
+        }
+
+        return $hasEndOfHeadElement;
+    }
+
+    /**
+     * Removes comments from the given HTML, including any which are unterminated, for which the remainder of the string
+     * is removed.
+     *
+     * @param string $html
+     *
+     * @return string
+     *
+     * @throws \RuntimeException
+     */
+    private function removeHtmlComments(string $html): string
+    {
+        return (new Preg())->throwExceptions(true)->replace(self::HTML_COMMENT_PATTERN, '', $html);
+    }
+
+    /**
+     * Removes `<template>` elements from the given HTML, including any without an end tag, for which the remainder of
+     * the string is removed.
+     *
+     * @param string $html
+     *
+     * @return string
+     *
+     * @throws \RuntimeException
+     */
+    private function removeHtmlTemplateElements(string $html): string
+    {
+        return (new Preg())->throwExceptions(true)->replace(self::HTML_TEMPLATE_ELEMENT_PATTERN, '', $html);
+    }
+
+    /**
+     * Makes sure that any self-closing tags not recognized as such by PHP's DOMDocument implementation have a
+     * self-closing slash.
+     *
+     * @param string $html
+     *
+     * @return string HTML with problematic tags converted.
+     */
+    private function ensurePhpUnrecognizedSelfClosingTagsAreXml(string $html): string
+    {
+        return (new Preg())->replace(
+            '%<' . self::PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER . '\\b[^>]*+(?<!/)(?=>)%',
+            '$0/',
+            $html
+        );
+    }
+
+    /**
+     * Checks that $this->domDocument has a BODY element and adds it if it is missing.
+     *
+     * @throws \UnexpectedValueException
+     */
+    private function ensureExistenceOfBodyElement(): void
+    {
+        if ($this->getDomDocument()->getElementsByTagName('body')->item(0) instanceof \DOMElement) {
+            return;
+        }
+
+        $this->getHtmlElement()->appendChild($this->getDomDocument()->createElement('body'));
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/HtmlProcessor/CssToAttributeConverter.php

@@ -0,0 +1,261 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\HtmlProcessor;
+
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\DeclarationBlockParser;
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\Preg;
+
+/**
+ * This HtmlProcessor can convert style HTML attributes to the corresponding other visual HTML attributes,
+ * e.g. it converts style="width: 100px" to width="100".
+ *
+ * It will only add attributes, but leaves the style attribute untouched.
+ *
+ * To trigger the conversion, call the convertCssToVisualAttributes method.
+ */
+final class CssToAttributeConverter extends AbstractHtmlProcessor
+{
+    /**
+     * This multi-level array contains simple mappings of CSS properties to
+     * HTML attributes. If a mapping only applies to certain HTML nodes or
+     * only for certain values, the mapping is an object with an allowlist
+     * of nodes and values.
+     *
+     * @var array<string, array{attribute: string, nodes?: array<int, string>, values?: array<int, string>}>
+     */
+    private $cssToHtmlMap = [
+        'background-color' => [
+            'attribute' => 'bgcolor',
+        ],
+        'text-align' => [
+            'attribute' => 'align',
+            'nodes' => ['p', 'div', 'td', 'th'],
+            'values' => ['left', 'right', 'center', 'justify'],
+        ],
+        'float' => [
+            'attribute' => 'align',
+            'nodes' => ['table', 'img'],
+            'values' => ['left', 'right'],
+        ],
+        'border-spacing' => [
+            'attribute' => 'cellspacing',
+            'nodes' => ['table'],
+        ],
+    ];
+
+    /**
+     * Maps the CSS from the style nodes to visual HTML attributes.
+     *
+     * @return $this
+     */
+    public function convertCssToVisualAttributes(): self
+    {
+        $declarationBlockParser = new DeclarationBlockParser();
+        /** @var \DOMElement $node */
+        foreach ($this->getAllNodesWithStyleAttribute() as $node) {
+            $inlineStyleDeclarations = $declarationBlockParser->parse($node->getAttribute('style'));
+            $this->mapCssToHtmlAttributes($inlineStyleDeclarations, $node);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns a list with all DOM nodes that have a style attribute.
+     *
+     * @return \DOMNodeList
+     */
+    private function getAllNodesWithStyleAttribute(): \DOMNodeList
+    {
+        return $this->getXPath()->query('//*[@style]');
+    }
+
+    /**
+     * Applies $styles to $node.
+     *
+     * This method maps CSS styles to HTML attributes and adds those to the
+     * node.
+     *
+     * @param array<string, string> $styles the new CSS styles taken from the global styles to be applied to this node
+     * @param \DOMElement $node node to apply styles to
+     */
+    private function mapCssToHtmlAttributes(array $styles, \DOMElement $node): void
+    {
+        foreach ($styles as $property => $value) {
+            // Strip !important indicator
+            $value = \trim(\str_replace('!important', '', $value));
+            $this->mapCssToHtmlAttribute($property, $value, $node);
+        }
+    }
+
+    /**
+     * Tries to apply the CSS style to $node as an attribute.
+     *
+     * This method maps a CSS rule to HTML attributes and adds those to the node.
+     *
+     * @param string $property the name of the CSS property to map
+     * @param string $value the value of the style rule to map
+     * @param \DOMElement $node node to apply styles to
+     */
+    private function mapCssToHtmlAttribute(string $property, string $value, \DOMElement $node): void
+    {
+        if (!$this->mapSimpleCssProperty($property, $value, $node)) {
+            $this->mapComplexCssProperty($property, $value, $node);
+        }
+    }
+
+    /**
+     * Looks up the CSS property in the mapping table and maps it if it matches the conditions.
+     *
+     * @param string $property the name of the CSS property to map
+     * @param string $value the value of the style rule to map
+     * @param \DOMElement $node node to apply styles to
+     *
+     * @return bool true if the property can be mapped using the simple mapping table
+     */
+    private function mapSimpleCssProperty(string $property, string $value, \DOMElement $node): bool
+    {
+        if (!isset($this->cssToHtmlMap[$property])) {
+            return false;
+        }
+
+        $mapping = $this->cssToHtmlMap[$property];
+        $nodesMatch = !isset($mapping['nodes']) || \in_array($node->nodeName, $mapping['nodes'], true);
+        $valuesMatch = !isset($mapping['values']) || \in_array($value, $mapping['values'], true);
+        $canBeMapped = $nodesMatch && $valuesMatch;
+        if ($canBeMapped) {
+            $node->setAttribute($mapping['attribute'], $value);
+        }
+
+        return $canBeMapped;
+    }
+
+    /**
+     * Maps CSS properties that need special transformation to an HTML attribute.
+     *
+     * @param string $property the name of the CSS property to map
+     * @param string $value the value of the style rule to map
+     * @param \DOMElement $node node to apply styles to
+     */
+    private function mapComplexCssProperty(string $property, string $value, \DOMElement $node): void
+    {
+        switch ($property) {
+            case 'background':
+                $this->mapBackgroundProperty($node, $value);
+                break;
+            case 'width':
+                // intentional fall-through
+            case 'height':
+                $this->mapWidthOrHeightProperty($node, $value, $property);
+                break;
+            case 'margin':
+                $this->mapMarginProperty($node, $value);
+                break;
+            case 'border':
+                $this->mapBorderProperty($node, $value);
+                break;
+            default:
+        }
+    }
+
+    /**
+     * @param \DOMElement $node node to apply styles to
+     * @param string $value the value of the style rule to map
+     */
+    private function mapBackgroundProperty(\DOMElement $node, string $value): void
+    {
+        // parse out the color, if any
+        /** @var array<int, string> $styles */
+        $styles = \explode(' ', $value, 2);
+        $first = $styles[0];
+        if (\is_numeric($first[0]) || \strncmp($first, 'url', 3) === 0) {
+            return;
+        }
+
+        // as this is not a position or image, assume it's a color
+        $node->setAttribute('bgcolor', $first);
+    }
+
+    /**
+     * @param \DOMElement $node node to apply styles to
+     * @param string $value the value of the style rule to map
+     * @param string $property the name of the CSS property to map
+     */
+    private function mapWidthOrHeightProperty(\DOMElement $node, string $value, string $property): void
+    {
+        $preg = new Preg();
+
+        // only parse values in px and %, but not values like "auto"
+        if ($preg->match('/^(\\d+)(\\.(\\d+))?(px|%)$/', $value) === 0) {
+            return;
+        }
+
+        $number = $preg->replace('/[^0-9.%]/', '', $value);
+        $node->setAttribute($property, $number);
+    }
+
+    /**
+     * @param \DOMElement $node node to apply styles to
+     * @param string $value the value of the style rule to map
+     */
+    private function mapMarginProperty(\DOMElement $node, string $value): void
+    {
+        if (!$this->isTableOrImageNode($node)) {
+            return;
+        }
+
+        $margins = $this->parseCssShorthandValue($value);
+        if ($margins['left'] === 'auto' && $margins['right'] === 'auto') {
+            $node->setAttribute('align', 'center');
+        }
+    }
+
+    /**
+     * @param \DOMElement $node node to apply styles to
+     * @param string $value the value of the style rule to map
+     */
+    private function mapBorderProperty(\DOMElement $node, string $value): void
+    {
+        if (!$this->isTableOrImageNode($node)) {
+            return;
+        }
+
+        if ($value === 'none' || $value === '0') {
+            $node->setAttribute('border', '0');
+        }
+    }
+
+    /**
+     * @param \DOMElement $node
+     *
+     * @return bool
+     */
+    private function isTableOrImageNode(\DOMElement $node): bool
+    {
+        return $node->nodeName === 'table' || $node->nodeName === 'img';
+    }
+
+    /**
+     * Parses a shorthand CSS value and splits it into individual values.  For example: `padding: 0 auto;` - `0 auto` is
+     * split into top: 0, left: auto, bottom: 0, right: auto.
+     *
+     * @param string $value a CSS property value with 1, 2, 3 or 4 sizes
+     *
+     * @return array<string, string>
+     *         an array of values for top, right, bottom and left (using these as associative array keys)
+     */
+    private function parseCssShorthandValue(string $value): array
+    {
+        $values = (new Preg())->split('/\\s+/', $value);
+
+        $css = [];
+        $css['top'] = $values[0];
+        $css['right'] = (\count($values) > 1) ? $values[1] : $css['top'];
+        $css['bottom'] = (\count($values) > 2) ? $values[2] : $css['top'];
+        $css['left'] = (\count($values) > 3) ? $values[3] : $css['right'];
+
+        return $css;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/HtmlProcessor/CssVariableEvaluator.php

@@ -0,0 +1,200 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\HtmlProcessor;
+
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\DeclarationBlockParser;
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\Preg;
+
+/**
+ * This class can evaluate CSS custom properties that are defined and used in inline style attributes.
+ */
+final class CssVariableEvaluator extends AbstractHtmlProcessor
+{
+    /**
+     * temporary collection used by {@see replaceVariablesInDeclarations} and callee methods
+     *
+     * @var array<non-empty-string, string>
+     */
+    private $currentVariableDefinitions = [];
+
+    /**
+     * Replaces all CSS custom property references in inline style attributes with their corresponding values where
+     * defined in inline style attributes (either from the element itself or the nearest ancestor).
+     *
+     * @return $this
+     *
+     * @throws \UnexpectedValueException
+     */
+    public function evaluateVariables(): self
+    {
+        return $this->evaluateVariablesInElementAndDescendants($this->getHtmlElement(), []);
+    }
+
+    /**
+     * @param array<non-empty-string, string> $declarations
+     *
+     * @return array<non-empty-string, string>
+     */
+    private function getVariableDefinitionsFromDeclarations(array $declarations): array
+    {
+        return \array_filter(
+            $declarations,
+            static function (string $key): bool {
+                return \substr($key, 0, 2) === '--';
+            },
+            ARRAY_FILTER_USE_KEY
+        );
+    }
+
+    /**
+     * Callback function for {@see replaceVariablesInPropertyValue} performing regular expression replacement.
+     *
+     * @param array<int, string> $matches
+     */
+    private function getPropertyValueReplacement(array $matches): string
+    {
+        $variableName = $matches[1];
+
+        if (isset($this->currentVariableDefinitions[$variableName])) {
+            $variableValue = $this->currentVariableDefinitions[$variableName];
+        } else {
+            $fallbackValueSeparator = $matches[2] ?? '';
+            if ($fallbackValueSeparator !== '') {
+                $fallbackValue = $matches[3];
+                // The fallback value may use other CSS variables, so recurse
+                $variableValue = $this->replaceVariablesInPropertyValue($fallbackValue);
+            } else {
+                $variableValue = $matches[0];
+            }
+        }
+
+        return $variableValue;
+    }
+
+    /**
+     * Regular expression based on {@see https://stackoverflow.com/a/54143883/2511031 a StackOverflow answer}.
+     */
+    private function replaceVariablesInPropertyValue(string $propertyValue): string
+    {
+        return (new Preg())->replaceCallback(
+            '/
+                var\\(
+                    \\s*+
+                    # capture variable name including `--` prefix
+                    (
+                        --[^\\s\\),]++
+                    )
+                    \\s*+
+                    # capture optional fallback value
+                    (?:
+                        # capture separator to confirm there is a fallback value
+                        (,)\\s*
+                        # begin capture with named group that can be used recursively
+                        (?<recursable>
+                            # begin named group to match sequence without parentheses, except in strings
+                            (?<noparentheses>
+                                # repeated zero or more times:
+                                (?:
+                                    # sequence without parentheses or quotes
+                                    [^\\(\\)\'"]++
+                                    |
+                                    # string in double quotes
+                                    "(?>[^"\\\\]++|\\\\.)*"
+                                    |
+                                    # string in single quotes
+                                    \'(?>[^\'\\\\]++|\\\\.)*\'
+                                )*+
+                            )
+                            # repeated zero or more times:
+                            (?:
+                                # sequence in parentheses
+                                \\(
+                                    # using the named recursable pattern
+                                    (?&recursable)
+                                \\)
+                                # sequence without parentheses, except in strings
+                                (?&noparentheses)
+                            )*+
+                        )
+                    )?+
+                \\)
+            /x',
+            \Closure::fromCallable([$this, 'getPropertyValueReplacement']),
+            $propertyValue
+        );
+    }
+
+    /**
+     * @param array<non-empty-string, string> $declarations
+     *
+     * @return ?array<non-empty-string, string> `null` is returned if no substitutions were made.
+     */
+    private function replaceVariablesInDeclarations(array $declarations): ?array
+    {
+        $substitutionsMade = false;
+        $result = \array_map(
+            function (string $propertyValue) use (&$substitutionsMade): string {
+                $newPropertyValue = $this->replaceVariablesInPropertyValue($propertyValue);
+                if ($newPropertyValue !== $propertyValue) {
+                    $substitutionsMade = true;
+                }
+                return $newPropertyValue;
+            },
+            $declarations
+        );
+
+        return $substitutionsMade ? $result : null;
+    }
+
+    /**
+     * @param array<non-empty-string, string> $declarations
+     */
+    private function getDeclarationsAsString(array $declarations): string
+    {
+        $declarationStrings = \array_map(
+            static function (string $key, string $value): string {
+                return $key . ': ' . $value;
+            },
+            \array_keys($declarations),
+            \array_values($declarations)
+        );
+
+        return \implode('; ', $declarationStrings) . ';';
+    }
+
+    /**
+     * @param array<non-empty-string, string> $ancestorVariableDefinitions
+     *
+     * @return $this
+     */
+    private function evaluateVariablesInElementAndDescendants(
+        \DOMElement $element,
+        array $ancestorVariableDefinitions
+    ): self {
+        $style = $element->getAttribute('style');
+
+        // Avoid parsing declarations if none use or define a variable
+        if ((new Preg())->match('/(?<![\\w\\-])--[\\w\\-]/', $style) !== 0) {
+            $declarations = (new DeclarationBlockParser())->parse($style);
+            $variableDefinitions = $this->currentVariableDefinitions
+                = $this->getVariableDefinitionsFromDeclarations($declarations) + $ancestorVariableDefinitions;
+
+            $newDeclarations = $this->replaceVariablesInDeclarations($declarations);
+            if ($newDeclarations !== null) {
+                $element->setAttribute('style', $this->getDeclarationsAsString($newDeclarations));
+            }
+        } else {
+            $variableDefinitions = $ancestorVariableDefinitions;
+        }
+
+        foreach ($element->childNodes as $child) {
+            if ($child instanceof \DOMElement) {
+                $this->evaluateVariablesInElementAndDescendants($child, $variableDefinitions);
+            }
+        }
+
+        return $this;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/HtmlProcessor/HtmlNormalizer.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\HtmlProcessor;
+
+/**
+ * Normalizes HTML:
+ * - add a document type (HTML5) if missing
+ * - disentangle incorrectly nested tags
+ * - add HEAD and BODY elements (if they are missing)
+ * - reformat the HTML
+ */
+final class HtmlNormalizer extends AbstractHtmlProcessor {}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/HtmlProcessor/HtmlPruner.php

@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\HtmlProcessor;
+
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\CssInliner;
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\ArrayIntersector;
+use Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities\Preg;
+
+/**
+ * This class can remove things from HTML.
+ */
+final class HtmlPruner extends AbstractHtmlProcessor
+{
+    /**
+     * We need to look for display:none, but we need to do a case-insensitive search. Since DOMDocument only
+     * supports XPath 1.0, lower-case() isn't available to us. We've thus far only set attributes to lowercase,
+     * not attribute values. Consequently, we need to translate() the letters that would be in 'NONE' ("NOE")
+     * to lowercase.
+     *
+     * @var string
+     */
+    private const DISPLAY_NONE_MATCHER
+        = '//*[@style and contains(translate(translate(@style," ",""),"NOE","noe"),"display:none")'
+        . ' and not(@class and contains(concat(" ", normalize-space(@class), " "), " -emogrifier-keep "))]';
+
+    /**
+     * Removes elements that have a "display: none;" style.
+     *
+     * @return $this
+     */
+    public function removeElementsWithDisplayNone(): self
+    {
+        $elementsWithStyleDisplayNone = $this->getXPath()->query(self::DISPLAY_NONE_MATCHER);
+        if ($elementsWithStyleDisplayNone->length === 0) {
+            return $this;
+        }
+
+        foreach ($elementsWithStyleDisplayNone as $element) {
+            $parentNode = $element->parentNode;
+            if ($parentNode !== null) {
+                $parentNode->removeChild($element);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Removes classes that are no longer required (e.g. because there are no longer any CSS rules that reference them)
+     * from `class` attributes.
+     *
+     * Note that this does not inspect the CSS, but expects to be provided with a list of classes that are still in use.
+     *
+     * This method also has the (presumably beneficial) side-effect of minifying (removing superfluous whitespace from)
+     * `class` attributes.
+     *
+     * @param array<array-key, string> $classesToKeep names of classes that should not be removed
+     *
+     * @return $this
+     */
+    public function removeRedundantClasses(array $classesToKeep = []): self
+    {
+        $elementsWithClassAttribute = $this->getXPath()->query('//*[@class]');
+
+        if ($classesToKeep !== []) {
+            $this->removeClassesFromElements($elementsWithClassAttribute, $classesToKeep);
+        } else {
+            // Avoid unnecessary processing if there are no classes to keep.
+            $this->removeClassAttributeFromElements($elementsWithClassAttribute);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Removes classes from the `class` attribute of each element in `$elements`, except any in `$classesToKeep`,
+     * removing the `class` attribute itself if the resultant list is empty.
+     *
+     * @param \DOMNodeList $elements
+     * @param array<array-key, string> $classesToKeep
+     */
+    private function removeClassesFromElements(\DOMNodeList $elements, array $classesToKeep): void
+    {
+        $classesToKeepIntersector = new ArrayIntersector($classesToKeep);
+
+        $preg = new Preg();
+        /** @var \DOMElement $element */
+        foreach ($elements as $element) {
+            $elementClasses = $preg->split('/\\s++/', \trim($element->getAttribute('class')));
+            $elementClassesToKeep = $classesToKeepIntersector->intersectWith($elementClasses);
+            if ($elementClassesToKeep !== []) {
+                $element->setAttribute('class', \implode(' ', $elementClassesToKeep));
+            } else {
+                $element->removeAttribute('class');
+            }
+        }
+    }
+
+    /**
+     * Removes the `class` attribute from each element in `$elements`.
+     *
+     * @param \DOMNodeList $elements
+     */
+    private function removeClassAttributeFromElements(\DOMNodeList $elements): void
+    {
+        /** @var \DOMElement $element */
+        foreach ($elements as $element) {
+            $element->removeAttribute('class');
+        }
+    }
+
+    /**
+     * After CSS has been inlined, there will likely be some classes in `class` attributes that are no longer referenced
+     * by any remaining (uninlinable) CSS.  This method removes such classes.
+     *
+     * Note that it does not inspect the remaining CSS, but uses information readily available from the `CssInliner`
+     * instance about the CSS rules that could not be inlined.
+     *
+     * @param CssInliner $cssInliner object instance that performed the CSS inlining
+     *
+     * @return $this
+     *
+     * @throws \BadMethodCallException if `inlineCss` has not first been called on `$cssInliner`
+     */
+    public function removeRedundantClassesAfterCssInlined(CssInliner $cssInliner): self
+    {
+        $preg = new Preg();
+
+        $classesToKeepAsKeys = [];
+        foreach ($cssInliner->getMatchingUninlinableSelectors() as $selector) {
+            $preg->matchAll('/\\.(-?+[_a-zA-Z][\\w\\-]*+)/', $selector, $matches);
+            $classesToKeepAsKeys += \array_fill_keys($matches[1], true);
+        }
+
+        $this->removeRedundantClasses(\array_keys($classesToKeepAsKeys));
+
+        return $this;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/Utilities/ArrayIntersector.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities;
+
+/**
+ * When computing many array intersections using the same array, it is more efficient to use `array_flip()` first and
+ * then `array_intersect_key()`, than `array_intersect()`.  See the discussion at
+ * {@link https://stackoverflow.com/questions/6329211/php-array-intersect-efficiency Stack Overflow} for more
+ * information.
+ *
+ * Of course, this is only possible if the arrays contain integer or string values, and either don't contain duplicates,
+ * or that fact that duplicates will be removed does not matter.
+ *
+ * This class takes care of the detail.
+ *
+ * @internal
+ */
+final class ArrayIntersector
+{
+    /**
+     * the array with which the object was constructed, with all its keys exchanged with their associated values
+     *
+     * @var array<array-key, array-key>
+     */
+    private $invertedArray;
+
+    /**
+     * Constructs the object with the array that will be reused for many intersection computations.
+     *
+     * @param array<array-key, array-key> $array
+     */
+    public function __construct(array $array)
+    {
+        $this->invertedArray = \array_flip($array);
+    }
+
+    /**
+     * Computes the intersection of `$array` and the array with which this object was constructed.
+     *
+     * @param array<array-key, array-key> $array
+     *
+     * @return array<array-key, array-key>
+     *         Returns an array containing all of the values in `$array` whose values exist in the array
+     *         with which this object was constructed.  Note that keys are preserved, order is maintained, but
+     *         duplicates are removed.
+     */
+    public function intersectWith(array $array): array
+    {
+        $invertedArray = \array_flip($array);
+
+        $invertedIntersection = \array_intersect_key($invertedArray, $this->invertedArray);
+
+        return \array_flip($invertedIntersection);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/Utilities/CssConcatenator.php

@@ -0,0 +1,181 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities;
+
+/**
+ * Facilitates building a CSS string by appending rule blocks one at a time, checking whether the media query,
+ * selectors, or declarations block are the same as those from the preceding block and combining blocks in such cases.
+ *
+ * Example:
+ *  $concatenator = new CssConcatenator();
+ *  $concatenator->append(['body'], 'color: blue;');
+ *  $concatenator->append(['body'], 'font-size: 16px;');
+ *  $concatenator->append(['p'], 'margin: 1em 0;');
+ *  $concatenator->append(['ul', 'ol'], 'margin: 1em 0;');
+ *  $concatenator->append(['body'], 'font-size: 14px;', '@media screen and (max-width: 400px)');
+ *  $concatenator->append(['ul', 'ol'], 'margin: 0.75em 0;', '@media screen and (max-width: 400px)');
+ *  $css = $concatenator->getCss();
+ *
+ * `$css` (if unminified) would contain the following CSS:
+ * ` body {
+ * `   color: blue;
+ * `   font-size: 16px;
+ * ` }
+ * ` p, ul, ol {
+ * `   margin: 1em 0;
+ * ` }
+ * ` @media screen and (max-width: 400px) {
+ * `   body {
+ * `     font-size: 14px;
+ * `   }
+ * `   ul, ol {
+ * `     margin: 0.75em 0;
+ * `   }
+ * ` }
+ *
+ * @internal
+ */
+final class CssConcatenator
+{
+    /**
+     * Array of media rules in order.  Each element is an object with the following properties:
+     * - string `media` - The media query string, e.g. "@media screen and (max-width:639px)", or an empty string for
+     *   rules not within a media query block;
+     * - object[] `ruleBlocks` - Array of rule blocks in order, where each element is an object with the following
+     *   properties:
+     *   - mixed[] `selectorsAsKeys` - Array whose keys are selectors for the rule block (values are of no
+     *     significance);
+     *   - string `declarationsBlock` - The property declarations, e.g. "margin-top: 0.5em; padding: 0".
+     *
+     * @var array<int, object{
+     *   media: string,
+     *   ruleBlocks: array<int, object{
+     *     selectorsAsKeys: array<string, array-key>,
+     *     declarationsBlock: string
+     *   }>
+     * }>
+     */
+    private $mediaRules = [];
+
+    /**
+     * Appends a declaration block to the CSS.
+     *
+     * @param array<array-key, string> $selectors
+     *        array of selectors for the rule, e.g. ["ul", "ol", "p:first-child"]
+     * @param string $declarationsBlock
+     *        the property declarations, e.g. "margin-top: 0.5em; padding: 0"
+     * @param string $media
+     *        the media query for the rule, e.g. "@media screen and (max-width:639px)", or an empty string if none
+     */
+    public function append(array $selectors, string $declarationsBlock, string $media = ''): void
+    {
+        $selectorsAsKeys = \array_flip($selectors);
+
+        $mediaRule = $this->getOrCreateMediaRuleToAppendTo($media);
+        $ruleBlocks = $mediaRule->ruleBlocks;
+        $lastRuleBlock = \end($ruleBlocks);
+
+        $hasSameDeclarationsAsLastRule = \is_object($lastRuleBlock)
+            && $declarationsBlock === $lastRuleBlock->declarationsBlock;
+        if ($hasSameDeclarationsAsLastRule) {
+            $lastRuleBlock->selectorsAsKeys += $selectorsAsKeys;
+        } else {
+            $lastRuleBlockSelectors = \is_object($lastRuleBlock) ? $lastRuleBlock->selectorsAsKeys : [];
+            $hasSameSelectorsAsLastRule = \is_object($lastRuleBlock)
+                && self::hasEquivalentSelectors($selectorsAsKeys, $lastRuleBlockSelectors);
+            if ($hasSameSelectorsAsLastRule) {
+                $lastDeclarationsBlockWithoutSemicolon = \rtrim(\rtrim($lastRuleBlock->declarationsBlock), ';');
+                $lastRuleBlock->declarationsBlock = $lastDeclarationsBlockWithoutSemicolon . ';' . $declarationsBlock;
+            } else {
+                $mediaRule->ruleBlocks[] = (object) \compact('selectorsAsKeys', 'declarationsBlock');
+            }
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getCss(): string
+    {
+        return \implode('', \array_map([self::class, 'getMediaRuleCss'], $this->mediaRules));
+    }
+
+    /**
+     * @param string $media The media query for rules to be appended, e.g. "@media screen and (max-width:639px)",
+     *        or an empty string if none.
+     *
+     * @return object{
+     *           media: string,
+     *           ruleBlocks: array<int, object{
+     *             selectorsAsKeys: array<string, array-key>,
+     *             declarationsBlock: string
+     *           }>
+     *         }
+     */
+    private function getOrCreateMediaRuleToAppendTo(string $media): object
+    {
+        $lastMediaRule = \end($this->mediaRules);
+        if (\is_object($lastMediaRule) && $media === $lastMediaRule->media) {
+            return $lastMediaRule;
+        }
+
+        $newMediaRule = (object) [
+            'media' => $media,
+            'ruleBlocks' => [],
+        ];
+        $this->mediaRules[] = $newMediaRule;
+        return $newMediaRule;
+    }
+
+    /**
+     * Tests if two sets of selectors are equivalent (i.e. the same selectors, possibly in a different order).
+     *
+     * @param array<string, array-key> $selectorsAsKeys1
+     *        array in which the selectors are the keys, and the values are of no significance
+     * @param array<string, array-key> $selectorsAsKeys2 another such array
+     *
+     * @return bool
+     */
+    private static function hasEquivalentSelectors(array $selectorsAsKeys1, array $selectorsAsKeys2): bool
+    {
+        return \count($selectorsAsKeys1) === \count($selectorsAsKeys2)
+            && \count($selectorsAsKeys1) === \count($selectorsAsKeys1 + $selectorsAsKeys2);
+    }
+
+    /**
+     * @param object{
+     *          media: string,
+     *          ruleBlocks: array<int, object{
+     *            selectorsAsKeys: array<string, array-key>,
+     *            declarationsBlock: string
+     *          }>
+     *        } $mediaRule
+     *
+     * @return string CSS for the media rule.
+     */
+    private static function getMediaRuleCss(object $mediaRule): string
+    {
+        $ruleBlocks = $mediaRule->ruleBlocks;
+        $css = \implode('', \array_map([self::class, 'getRuleBlockCss'], $ruleBlocks));
+        $media = $mediaRule->media;
+        if ($media !== '') {
+            $css = $media . '{' . $css . '}';
+        }
+        return $css;
+    }
+
+    /**
+     * @param object{selectorsAsKeys: array<string, array-key>, declarationsBlock: string} $ruleBlock
+     *
+     * @return string CSS for the rule block.
+     */
+    private static function getRuleBlockCss(object $ruleBlock): string
+    {
+        $selectorsAsKeys = $ruleBlock->selectorsAsKeys;
+        $selectors = \array_keys($selectorsAsKeys);
+        $declarationsBlock = $ruleBlock->declarationsBlock;
+        return \implode(',', $selectors) . '{' . $declarationsBlock . '}';
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/Utilities/DeclarationBlockParser.php

@@ -0,0 +1,96 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities;
+
+/**
+ * Provides a common method for parsing CSS declaration blocks.
+ * These might be from actual CSS, or from the `style` attribute of an HTML DOM element.
+ *
+ * Caches results globally.
+ *
+ * @internal
+ */
+final class DeclarationBlockParser
+{
+    /**
+     * @var array<string, array<non-empty-string, string>>
+     */
+    private static $cache = [];
+
+    /**
+     * CSS custom properties (variables) have case-sensitive names, so their case must be preserved.
+     * Standard CSS properties have case-insensitive names, which are converted to lowercase.
+     *
+     * @param non-empty-string $name
+     *
+     * @return non-empty-string
+     */
+    public function normalizePropertyName(string $name): string
+    {
+        if (\substr($name, 0, 2) === '--') {
+            return $name;
+        } else {
+            return \strtolower($name);
+        }
+    }
+
+    /**
+     * Parses a CSS declaration block into property name/value pairs.
+     *
+     * Example:
+     *
+     * The declaration block
+     *
+     *   "color: #000; font-weight: bold;"
+     *
+     * will be parsed into the following array:
+     *
+     *   "color" => "#000"
+     *   "font-weight" => "bold"
+     *
+     * @param string $declarationBlock the CSS declarations block without the curly braces, may be empty
+     *
+     * @return array<non-empty-string, string>
+     *         the CSS declarations with the property names as array keys and the property values as array values
+     *
+     * @throws \UnexpectedValueException if an empty property name is encountered (which cannot happen)
+     */
+    public function parse(string $declarationBlock): array
+    {
+        if (isset(self::$cache[$declarationBlock])) {
+            return self::$cache[$declarationBlock];
+        }
+
+        $preg = new Preg();
+
+        $declarations = $preg->split('/;(?!base64|charset)/', $declarationBlock);
+
+        $properties = [];
+        foreach ($declarations as $declaration) {
+            $matches = [];
+            if (
+                $preg->match(
+                    '/^([A-Za-z\\-]+)\\s*:\\s*(.+)$/s',
+                    \trim($declaration),
+                    $matches
+                )
+                === 0
+            ) {
+                continue;
+            }
+
+            $propertyName = $matches[1];
+            if ($propertyName === '') {
+                // This cannot happen since the regular epression matches one or more characters.
+                throw new \UnexpectedValueException('An empty property name was encountered.', 1727046409);
+            }
+            $propertyValue = $matches[2];
+            $properties[$this->normalizePropertyName($propertyName)] = $propertyValue;
+        }
+        self::$cache[$declarationBlock] = $properties;
+
+        return $properties;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Pelago/Emogrifier/Utilities/Preg.php

@@ -0,0 +1,202 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Pelago\Emogrifier\Utilities;
+
+/**
+ * PHP's `preg_*` functions can return `false` on failure.
+ * Failure is rare but may occur with a complex pattern applied to a long subject.
+ * Catastrophic backtracking may occur ({@see https://www.regular-expressions.info/catastrophic.html}).
+ * Failure may also occur due to programmer error, if an invalid pattern is provided.
+ *
+ * Catering for failure in each case clutters up the code with error handling.
+ * This class provides wrappers for some `preg_*` functions, with errors handled either
+ * - by throwing an exception, or
+ * - by triggering a user error and providing fallback logic (e.g. returning the subject string unmodified).
+ *
+ * @internal
+ */
+final class Preg
+{
+    /**
+     * whether to throw exceptions on errors (or call `trigger_error` and implement fallback)
+     *
+     * @var bool
+     */
+    private $throwExceptions = false;
+
+    /**
+     * Sets whether exceptions should be thrown if an error occurs.
+     */
+    public function throwExceptions(bool $throw): self
+    {
+        $this->throwExceptions = $throw;
+
+        return $this;
+    }
+
+    /**
+     * Wraps `preg_replace`, though does not support `$subject` being an array.
+     * If an error occurs, and exceptions are not being thrown, the original `$subject` is returned.
+     *
+     * @param non-empty-string|non-empty-array<non-empty-string> $pattern
+     * @param string|non-empty-array<string> $replacement
+     *
+     * @throws \RuntimeException
+     */
+    public function replace($pattern, $replacement, string $subject, int $limit = -1, ?int &$count = null): string
+    {
+        $result = \preg_replace($pattern, $replacement, $subject, $limit, $count);
+
+        if ($result === null) {
+            $this->logOrThrowPregLastError();
+            $result = $subject;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Wraps `preg_replace_callback`, though does not support `$subject` being an array.
+     * If an error occurs, and exceptions are not being thrown, the original `$subject` is returned.
+     *
+     * Note that (unlike when calling `preg_replace_callback`), `$callback` cannot be a non-public method
+     * represented by an array comprising an object or class name and the method name.
+     * To circumvent that, use `\Closure::fromCallable([$objectOrClassName, 'method'])`.
+     *
+     * @param non-empty-string|non-empty-array<non-empty-string> $pattern
+     *
+     * @throws \RuntimeException
+     */
+    public function replaceCallback(
+        $pattern,
+        callable $callback,
+        string $subject,
+        int $limit = -1,
+        ?int &$count = null
+    ): string {
+        $result = \preg_replace_callback($pattern, $callback, $subject, $limit, $count);
+
+        if ($result === null) {
+            $this->logOrThrowPregLastError();
+            $result = $subject;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Wraps `preg_split`.
+     * If an error occurs, and exceptions are not being thrown,
+     * a single-element array containing the original `$subject` is returned.
+     * This method does not support the `PREG_SPLIT_OFFSET_CAPTURE` flag and will throw an exception if it is specified.
+     *
+     * @param non-empty-string $pattern
+     *
+     * @return array<int, string>
+     *
+     * @throws \RuntimeException
+     */
+    public function split(string $pattern, string $subject, int $limit = -1, int $flags = 0): array
+    {
+        if (($flags & PREG_SPLIT_OFFSET_CAPTURE) !== 0) {
+            throw new \RuntimeException('PREG_SPLIT_OFFSET_CAPTURE is not supported by Preg::split', 1726506348);
+        }
+
+        $result = \preg_split($pattern, $subject, $limit, $flags);
+
+        if ($result === false) {
+            $this->logOrThrowPregLastError();
+            $result = [$subject];
+        }
+
+        return $result;
+    }
+
+    /**
+     * Wraps `preg_match`.
+     * If an error occurs, and exceptions are not being thrown,
+     * zero (`0`) is returned, and if the `$matches` parameter is provided, it is set to an empty array.
+     * This method does not currently support the `$flags` or `$offset` parameters.
+     *
+     * @param non-empty-string $pattern
+     * @param array<int, string> $matches
+     *
+     * @return 0|1
+     *
+     * @throws \RuntimeException
+     */
+    public function match(string $pattern, string $subject, ?array &$matches = null): int
+    {
+        $result = \preg_match($pattern, $subject, $matches);
+
+        if ($result === false) {
+            $this->logOrThrowPregLastError();
+            $result = 0;
+            $matches = [];
+        }
+
+        return $result;
+    }
+
+    /**
+     * Wraps `preg_match_all`.
+     *
+     * If an error occurs, and exceptions are not being thrown, zero (`0`) is returned.
+     *
+     * In the error case, if the `$matches` parameter is provided, it is set to an array containing empty arrays for the
+     * full pattern match and any possible subpattern match that might be expected.
+     * The algorithm to determine the length of this array simply counts the number of opening parentheses in the
+     * `$pattern`, which may result in a longer array than expected, but guarantees that it is at least as long as
+     * expected.
+     *
+     * This method does not currently support the `$flags` or `$offset` parameters.
+     *
+     * @param non-empty-string $pattern
+     * @param array<int, array<int, string>> $matches
+     *
+     * @throws \RuntimeException
+     */
+    public function matchAll(string $pattern, string $subject, ?array &$matches = null): int
+    {
+        $result = \preg_match_all($pattern, $subject, $matches);
+
+        if ($result === false) {
+            $this->logOrThrowPregLastError();
+            $result = 0;
+            $matches = \array_fill(0, \substr_count($pattern, '(') + 1, []);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Obtains the name of the error constant for `preg_last_error`
+     * (based on code posted at {@see https://www.php.net/manual/en/function.preg-last-error.php#124124})
+     * and puts it into an error message which is either passed to `trigger_error`
+     * or used in the exception which is thrown (depending on the `$throwExceptions` property).
+     *
+     * @throws \RuntimeException
+     */
+    private function logOrThrowPregLastError(): void
+    {
+        $pcreConstants = \get_defined_constants(true)['pcre'];
+        $pcreErrorConstantNames = \array_flip(\array_filter(
+            $pcreConstants,
+            static function (string $key): bool {
+                return \substr($key, -6) === '_ERROR';
+            },
+            ARRAY_FILTER_USE_KEY
+        ));
+
+        $pregLastError = \preg_last_error();
+        $message = 'PCRE regex execution error `' . (string) ($pcreErrorConstantNames[$pregLastError] ?? $pregLastError)
+            . '`';
+
+        if ($this->throwExceptions) {
+            throw new \RuntimeException($message, 1592870147);
+        }
+        \trigger_error($message);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Psr/Container/ContainerExceptionInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Psr\Container;
+
+use Throwable;
+
+/**
+ * Base interface representing a generic exception in a container.
+ */
+interface ContainerExceptionInterface extends Throwable
+{
+}

wp-content/plugins/woocommerce/lib/packages/Psr/Container/ContainerInterface.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Psr\Container;
+
+/**
+ * Describes the interface of a container that exposes methods to read its entries.
+ */
+interface ContainerInterface
+{
+    /**
+     * Finds an entry of the container by its identifier and returns it.
+     *
+     * @param string $id Identifier of the entry to look for.
+     *
+     * @throws NotFoundExceptionInterface  No entry was found for **this** identifier.
+     * @throws ContainerExceptionInterface Error while retrieving the entry.
+     *
+     * @return mixed Entry.
+     */
+    public function get(string $id);
+
+    /**
+     * Returns true if the container can return an entry for the given identifier.
+     * Returns false otherwise.
+     *
+     * `has($id)` returning true does not mean that `get($id)` will not throw an exception.
+     * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`.
+     *
+     * @param string $id Identifier of the entry to look for.
+     *
+     * @return bool
+     */
+    public function has(string $id);
+}

wp-content/plugins/woocommerce/lib/packages/Psr/Container/NotFoundExceptionInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Psr\Container;
+
+/**
+ * No entry was found in the container.
+ */
+interface NotFoundExceptionInterface extends ContainerExceptionInterface
+{
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/CSSElement.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS;
+
+/**
+ * Represents any entity in the CSS that is encapsulated by a class.
+ *
+ * Its primary purpose is to provide a type for use with `Document::getAllValues()`
+ * when a subset of values from a particular part of the document is required.
+ *
+ * Thus, elements which don't contain `Value`s (such as statement at-rules) don't need to implement this.
+ *
+ * It extends `Renderable` because every element is renderable.
+ */
+interface CSSElement extends Renderable {}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/CSSList/AtRuleBlockList.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\AtRule;
+
+/**
+ * A `BlockList` constructed by an unknown at-rule. `@media` rules are rendered into `AtRuleBlockList` objects.
+ */
+class AtRuleBlockList extends CSSBlockList implements AtRule
+{
+    /**
+     * @var string
+     */
+    private $sType;
+
+    /**
+     * @var string
+     */
+    private $sArgs;
+
+    /**
+     * @param string $sType
+     * @param string $sArgs
+     * @param int $iLineNo
+     */
+    public function __construct($sType, $sArgs = '', $iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+        $this->sType = $sType;
+        $this->sArgs = $sArgs;
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleName()
+    {
+        return $this->sType;
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleArgs()
+    {
+        return $this->sArgs;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        $sResult = $oOutputFormat->comments($this);
+        $sResult .= $oOutputFormat->sBeforeAtRuleBlock;
+        $sArgs = $this->sArgs;
+        if ($sArgs) {
+            $sArgs = ' ' . $sArgs;
+        }
+        $sResult .= "@{$this->sType}$sArgs{$oOutputFormat->spaceBeforeOpeningBrace()}{";
+        $sResult .= $this->renderListContents($oOutputFormat);
+        $sResult .= '}';
+        $sResult .= $oOutputFormat->sAfterAtRuleBlock;
+        return $sResult;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isRootList()
+    {
+        return false;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/CSSList/CSSBlockList.php

@@ -0,0 +1,190 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSElement;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Selector;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Rule\Rule;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\DeclarationBlock;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\RuleSet;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\CSSFunction;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\Value;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\ValueList;
+
+/**
+ * A `CSSBlockList` is a `CSSList` whose `DeclarationBlock`s are guaranteed to contain valid declaration blocks or
+ * at-rules.
+ *
+ * Most `CSSList`s conform to this category but some at-rules (such as `@keyframes`) do not.
+ */
+abstract class CSSBlockList extends CSSList
+{
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+    }
+
+    /**
+     * @param array<int, DeclarationBlock> $aResult
+     *
+     * @return void
+     */
+    protected function allDeclarationBlocks(array &$aResult)
+    {
+        foreach ($this->aContents as $mContent) {
+            if ($mContent instanceof DeclarationBlock) {
+                $aResult[] = $mContent;
+            } elseif ($mContent instanceof CSSBlockList) {
+                $mContent->allDeclarationBlocks($aResult);
+            }
+        }
+    }
+
+    /**
+     * @param array<int, RuleSet> $aResult
+     *
+     * @return void
+     */
+    protected function allRuleSets(array &$aResult)
+    {
+        foreach ($this->aContents as $mContent) {
+            if ($mContent instanceof RuleSet) {
+                $aResult[] = $mContent;
+            } elseif ($mContent instanceof CSSBlockList) {
+                $mContent->allRuleSets($aResult);
+            }
+        }
+    }
+
+    /**
+     * Returns all `Value` objects found recursively in `Rule`s in the tree.
+     *
+     * @param CSSElement|string|null $element
+     *        This is the `CSSList` or `RuleSet` to start the search from (defaults to the whole document).
+     *        If a string is given, it is used as a rule name filter.
+     *        Passing a string for this parameter is deprecated in version 8.9.0, and will not work from v9.0;
+     *        use the following parameter to pass a rule name filter instead.
+     * @param string|bool|null $ruleSearchPatternOrSearchInFunctionArguments
+     *        This allows filtering rules by property name
+     *        (e.g. if "color" is passed, only `Value`s from `color` properties will be returned,
+     *        or if "font-" is provided, `Value`s from all font rules, like `font-size`, and including `font` itself,
+     *        will be returned).
+     *        If a Boolean is provided, it is treated as the `$searchInFunctionArguments` argument.
+     *        Passing a Boolean for this parameter is deprecated in version 8.9.0, and will not work from v9.0;
+     *        use the `$searchInFunctionArguments` parameter instead.
+     * @param bool $searchInFunctionArguments whether to also return Value objects used as Function arguments.
+     *
+     * @return array<int, Value>
+     *
+     * @see RuleSet->getRules()
+     */
+    public function getAllValues(
+        $element = null,
+        $ruleSearchPatternOrSearchInFunctionArguments = null,
+        $searchInFunctionArguments = false
+    ) {
+        if (\is_bool($ruleSearchPatternOrSearchInFunctionArguments)) {
+            $searchInFunctionArguments = $ruleSearchPatternOrSearchInFunctionArguments;
+            $searchString = null;
+        } else {
+            $searchString = $ruleSearchPatternOrSearchInFunctionArguments;
+        }
+
+        if ($element === null) {
+            $element = $this;
+        } elseif (\is_string($element)) {
+            $searchString = $element;
+            $element = $this;
+        }
+
+        $result = [];
+        $this->allValues($element, $result, $searchString, $searchInFunctionArguments);
+        return $result;
+    }
+
+    /**
+     * @param CSSElement|string $oElement
+     * @param array<int, Value> $aResult
+     * @param string|null $sSearchString
+     * @param bool $bSearchInFunctionArguments
+     *
+     * @return void
+     */
+    protected function allValues($oElement, array &$aResult, $sSearchString = null, $bSearchInFunctionArguments = false)
+    {
+        if ($oElement instanceof CSSBlockList) {
+            foreach ($oElement->getContents() as $oContent) {
+                $this->allValues($oContent, $aResult, $sSearchString, $bSearchInFunctionArguments);
+            }
+        } elseif ($oElement instanceof RuleSet) {
+            foreach ($oElement->getRules($sSearchString) as $oRule) {
+                $this->allValues($oRule, $aResult, $sSearchString, $bSearchInFunctionArguments);
+            }
+        } elseif ($oElement instanceof Rule) {
+            $this->allValues($oElement->getValue(), $aResult, $sSearchString, $bSearchInFunctionArguments);
+        } elseif ($oElement instanceof ValueList) {
+            if ($bSearchInFunctionArguments || !($oElement instanceof CSSFunction)) {
+                foreach ($oElement->getListComponents() as $mComponent) {
+                    $this->allValues($mComponent, $aResult, $sSearchString, $bSearchInFunctionArguments);
+                }
+            }
+        } else {
+            // Non-List `Value` or `CSSString` (CSS identifier)
+            $aResult[] = $oElement;
+        }
+    }
+
+    /**
+     * @param array<int, Selector> $aResult
+     * @param string|null $sSpecificitySearch
+     *
+     * @return void
+     */
+    protected function allSelectors(array &$aResult, $sSpecificitySearch = null)
+    {
+        /** @var array<int, DeclarationBlock> $aDeclarationBlocks */
+        $aDeclarationBlocks = [];
+        $this->allDeclarationBlocks($aDeclarationBlocks);
+        foreach ($aDeclarationBlocks as $oBlock) {
+            foreach ($oBlock->getSelectors() as $oSelector) {
+                if ($sSpecificitySearch === null) {
+                    $aResult[] = $oSelector;
+                } else {
+                    $sComparator = '===';
+                    $aSpecificitySearch = explode(' ', $sSpecificitySearch);
+                    $iTargetSpecificity = $aSpecificitySearch[0];
+                    if (count($aSpecificitySearch) > 1) {
+                        $sComparator = $aSpecificitySearch[0];
+                        $iTargetSpecificity = $aSpecificitySearch[1];
+                    }
+                    $iTargetSpecificity = (int)$iTargetSpecificity;
+                    $iSelectorSpecificity = $oSelector->getSpecificity();
+                    $bMatches = false;
+                    switch ($sComparator) {
+                        case '<=':
+                            $bMatches = $iSelectorSpecificity <= $iTargetSpecificity;
+                            break;
+                        case '<':
+                            $bMatches = $iSelectorSpecificity < $iTargetSpecificity;
+                            break;
+                        case '>=':
+                            $bMatches = $iSelectorSpecificity >= $iTargetSpecificity;
+                            break;
+                        case '>':
+                            $bMatches = $iSelectorSpecificity > $iTargetSpecificity;
+                            break;
+                        default:
+                            $bMatches = $iSelectorSpecificity === $iTargetSpecificity;
+                            break;
+                    }
+                    if ($bMatches) {
+                        $aResult[] = $oSelector;
+                    }
+                }
+            }
+        }
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/CSSList/CSSList.php

@@ -0,0 +1,496 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Comment;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Commentable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSElement;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\SourceException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\AtRule;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Charset;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\CSSNamespace;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Import;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Selector;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Renderable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\AtRuleSet;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\DeclarationBlock;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\RuleSet;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Settings;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\CSSString;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\URL;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\Value;
+
+/**
+ * This is the most generic container available. It can contain `DeclarationBlock`s (rule sets with a selector),
+ * `RuleSet`s as well as other `CSSList` objects.
+ *
+ * It can also contain `Import` and `Charset` objects stemming from at-rules.
+ */
+abstract class CSSList implements Commentable, CSSElement, Positionable
+{
+    use Position;
+
+    /**
+     * @var array<array-key, Comment>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aComments;
+
+    /**
+     * @var array<int, RuleSet|CSSList|Import|Charset>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aContents;
+
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        $this->aComments = [];
+        $this->aContents = [];
+        $this->setPosition($iLineNo);
+    }
+
+    /**
+     * @return void
+     *
+     * @throws UnexpectedTokenException
+     * @throws SourceException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parseList(ParserState $oParserState, CSSList $oList)
+    {
+        $bIsRoot = $oList instanceof Document;
+        if (is_string($oParserState)) {
+            $oParserState = new ParserState($oParserState, Settings::create());
+        }
+        $bLenientParsing = $oParserState->getSettings()->bLenientParsing;
+        $aComments = [];
+        while (!$oParserState->isEnd()) {
+            $aComments = array_merge($aComments, $oParserState->consumeWhiteSpace());
+            $oListItem = null;
+            if ($bLenientParsing) {
+                try {
+                    $oListItem = self::parseListItem($oParserState, $oList);
+                } catch (UnexpectedTokenException $e) {
+                    $oListItem = false;
+                }
+            } else {
+                $oListItem = self::parseListItem($oParserState, $oList);
+            }
+            if ($oListItem === null) {
+                // List parsing finished
+                return;
+            }
+            if ($oListItem) {
+                $oListItem->addComments($aComments);
+                $oList->append($oListItem);
+            }
+            $aComments = $oParserState->consumeWhiteSpace();
+        }
+        $oList->addComments($aComments);
+        if (!$bIsRoot && !$bLenientParsing) {
+            throw new SourceException("Unexpected end of document", $oParserState->currentLine());
+        }
+    }
+
+    /**
+     * @return AtRuleBlockList|KeyFrame|Charset|CSSNamespace|Import|AtRuleSet|DeclarationBlock|null|false
+     *
+     * @throws SourceException
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     */
+    private static function parseListItem(ParserState $oParserState, CSSList $oList)
+    {
+        $bIsRoot = $oList instanceof Document;
+        if ($oParserState->comes('@')) {
+            $oAtRule = self::parseAtRule($oParserState);
+            if ($oAtRule instanceof Charset) {
+                if (!$bIsRoot) {
+                    throw new UnexpectedTokenException(
+                        '@charset may only occur in root document',
+                        '',
+                        'custom',
+                        $oParserState->currentLine()
+                    );
+                }
+                if (count($oList->getContents()) > 0) {
+                    throw new UnexpectedTokenException(
+                        '@charset must be the first parseable token in a document',
+                        '',
+                        'custom',
+                        $oParserState->currentLine()
+                    );
+                }
+                $oParserState->setCharset($oAtRule->getCharset());
+            }
+            return $oAtRule;
+        } elseif ($oParserState->comes('}')) {
+            if ($bIsRoot) {
+                if ($oParserState->getSettings()->bLenientParsing) {
+                    return DeclarationBlock::parse($oParserState);
+                } else {
+                    throw new SourceException("Unopened {", $oParserState->currentLine());
+                }
+            } else {
+                // End of list
+                return null;
+            }
+        } else {
+            return DeclarationBlock::parse($oParserState, $oList);
+        }
+    }
+
+    /**
+     * @param ParserState $oParserState
+     *
+     * @return AtRuleBlockList|KeyFrame|Charset|CSSNamespace|Import|AtRuleSet|null
+     *
+     * @throws SourceException
+     * @throws UnexpectedTokenException
+     * @throws UnexpectedEOFException
+     */
+    private static function parseAtRule(ParserState $oParserState)
+    {
+        $oParserState->consume('@');
+        $sIdentifier = $oParserState->parseIdentifier();
+        $iIdentifierLineNum = $oParserState->currentLine();
+        $oParserState->consumeWhiteSpace();
+        if ($sIdentifier === 'import') {
+            $oLocation = URL::parse($oParserState);
+            $oParserState->consumeWhiteSpace();
+            $sMediaQuery = null;
+            if (!$oParserState->comes(';')) {
+                $sMediaQuery = trim($oParserState->consumeUntil([';', ParserState::EOF]));
+            }
+            $oParserState->consumeUntil([';', ParserState::EOF], true, true);
+            return new Import($oLocation, $sMediaQuery ?: null, $iIdentifierLineNum);
+        } elseif ($sIdentifier === 'charset') {
+            $oCharsetString = CSSString::parse($oParserState);
+            $oParserState->consumeWhiteSpace();
+            $oParserState->consumeUntil([';', ParserState::EOF], true, true);
+            return new Charset($oCharsetString, $iIdentifierLineNum);
+        } elseif (self::identifierIs($sIdentifier, 'keyframes')) {
+            $oResult = new KeyFrame($iIdentifierLineNum);
+            $oResult->setVendorKeyFrame($sIdentifier);
+            $oResult->setAnimationName(trim($oParserState->consumeUntil('{', false, true)));
+            CSSList::parseList($oParserState, $oResult);
+            if ($oParserState->comes('}')) {
+                $oParserState->consume('}');
+            }
+            return $oResult;
+        } elseif ($sIdentifier === 'namespace') {
+            $sPrefix = null;
+            $mUrl = Value::parsePrimitiveValue($oParserState);
+            if (!$oParserState->comes(';')) {
+                $sPrefix = $mUrl;
+                $mUrl = Value::parsePrimitiveValue($oParserState);
+            }
+            $oParserState->consumeUntil([';', ParserState::EOF], true, true);
+            if ($sPrefix !== null && !is_string($sPrefix)) {
+                throw new UnexpectedTokenException('Wrong namespace prefix', $sPrefix, 'custom', $iIdentifierLineNum);
+            }
+            if (!($mUrl instanceof CSSString || $mUrl instanceof URL)) {
+                throw new UnexpectedTokenException(
+                    'Wrong namespace url of invalid type',
+                    $mUrl,
+                    'custom',
+                    $iIdentifierLineNum
+                );
+            }
+            return new CSSNamespace($mUrl, $sPrefix, $iIdentifierLineNum);
+        } else {
+            // Unknown other at rule (font-face or such)
+            $sArgs = trim($oParserState->consumeUntil('{', false, true));
+            if (substr_count($sArgs, "(") != substr_count($sArgs, ")")) {
+                if ($oParserState->getSettings()->bLenientParsing) {
+                    return null;
+                } else {
+                    throw new SourceException("Unmatched brace count in media query", $oParserState->currentLine());
+                }
+            }
+            $bUseRuleSet = true;
+            foreach (explode('/', AtRule::BLOCK_RULES) as $sBlockRuleName) {
+                if (self::identifierIs($sIdentifier, $sBlockRuleName)) {
+                    $bUseRuleSet = false;
+                    break;
+                }
+            }
+            if ($bUseRuleSet) {
+                $oAtRule = new AtRuleSet($sIdentifier, $sArgs, $iIdentifierLineNum);
+                RuleSet::parseRuleSet($oParserState, $oAtRule);
+            } else {
+                $oAtRule = new AtRuleBlockList($sIdentifier, $sArgs, $iIdentifierLineNum);
+                CSSList::parseList($oParserState, $oAtRule);
+                if ($oParserState->comes('}')) {
+                    $oParserState->consume('}');
+                }
+            }
+            return $oAtRule;
+        }
+    }
+
+    /**
+     * Tests an identifier for a given value. Since identifiers are all keywords, they can be vendor-prefixed.
+     * We need to check for these versions too.
+     *
+     * @param string $sIdentifier
+     * @param string $sMatch
+     *
+     * @return bool
+     */
+    private static function identifierIs($sIdentifier, $sMatch)
+    {
+        return (strcasecmp($sIdentifier, $sMatch) === 0)
+            ?: preg_match("/^(-\\w+-)?$sMatch$/i", $sIdentifier) === 1;
+    }
+
+    /**
+     * Prepends an item to the list of contents.
+     *
+     * @param RuleSet|CSSList|Import|Charset $oItem
+     *
+     * @return void
+     */
+    public function prepend($oItem)
+    {
+        array_unshift($this->aContents, $oItem);
+    }
+
+    /**
+     * Appends an item to the list of contents.
+     *
+     * @param RuleSet|CSSList|Import|Charset $oItem
+     *
+     * @return void
+     */
+    public function append($oItem)
+    {
+        $this->aContents[] = $oItem;
+    }
+
+    /**
+     * Splices the list of contents.
+     *
+     * @param int $iOffset
+     * @param int $iLength
+     * @param array<int, RuleSet|CSSList|Import|Charset> $mReplacement
+     *
+     * @return void
+     */
+    public function splice($iOffset, $iLength = null, $mReplacement = null)
+    {
+        array_splice($this->aContents, $iOffset, $iLength, $mReplacement);
+    }
+
+    /**
+     * Inserts an item in the CSS list before its sibling. If the desired sibling cannot be found,
+     * the item is appended at the end.
+     *
+     * @param RuleSet|CSSList|Import|Charset $item
+     * @param RuleSet|CSSList|Import|Charset $sibling
+     */
+    public function insertBefore($item, $sibling)
+    {
+        if (in_array($sibling, $this->aContents, true)) {
+            $this->replace($sibling, [$item, $sibling]);
+        } else {
+            $this->append($item);
+        }
+    }
+
+    /**
+     * Removes an item from the CSS list.
+     *
+     * @param RuleSet|Import|Charset|CSSList $oItemToRemove
+     *        May be a RuleSet (most likely a DeclarationBlock), a Import,
+     *        a Charset or another CSSList (most likely a MediaQuery)
+     *
+     * @return bool whether the item was removed
+     */
+    public function remove($oItemToRemove)
+    {
+        $iKey = array_search($oItemToRemove, $this->aContents, true);
+        if ($iKey !== false) {
+            unset($this->aContents[$iKey]);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Replaces an item from the CSS list.
+     *
+     * @param RuleSet|Import|Charset|CSSList $oOldItem
+     *        May be a `RuleSet` (most likely a `DeclarationBlock`), an `Import`, a `Charset`
+     *        or another `CSSList` (most likely a `MediaQuery`)
+     *
+     * @return bool
+     */
+    public function replace($oOldItem, $mNewItem)
+    {
+        $iKey = array_search($oOldItem, $this->aContents, true);
+        if ($iKey !== false) {
+            if (is_array($mNewItem)) {
+                array_splice($this->aContents, $iKey, 1, $mNewItem);
+            } else {
+                array_splice($this->aContents, $iKey, 1, [$mNewItem]);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @param array<int, RuleSet|Import|Charset|CSSList> $aContents
+     */
+    public function setContents(array $aContents)
+    {
+        $this->aContents = [];
+        foreach ($aContents as $content) {
+            $this->append($content);
+        }
+    }
+
+    /**
+     * Removes a declaration block from the CSS list if it matches all given selectors.
+     *
+     * @param DeclarationBlock|array<array-key, Selector>|string $mSelector the selectors to match
+     * @param bool $bRemoveAll whether to stop at the first declaration block found or remove all blocks
+     *
+     * @return void
+     */
+    public function removeDeclarationBlockBySelector($mSelector, $bRemoveAll = false)
+    {
+        if ($mSelector instanceof DeclarationBlock) {
+            $mSelector = $mSelector->getSelectors();
+        }
+        if (!is_array($mSelector)) {
+            $mSelector = explode(',', $mSelector);
+        }
+        foreach ($mSelector as $iKey => &$mSel) {
+            if (!($mSel instanceof Selector)) {
+                if (!Selector::isValid($mSel)) {
+                    throw new UnexpectedTokenException(
+                        "Selector did not match '" . Selector::SELECTOR_VALIDATION_RX . "'.",
+                        $mSel,
+                        "custom"
+                    );
+                }
+                $mSel = new Selector($mSel);
+            }
+        }
+        foreach ($this->aContents as $iKey => $mItem) {
+            if (!($mItem instanceof DeclarationBlock)) {
+                continue;
+            }
+            if ($mItem->getSelectors() == $mSelector) {
+                unset($this->aContents[$iKey]);
+                if (!$bRemoveAll) {
+                    return;
+                }
+            }
+        }
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @return string
+     */
+    protected function renderListContents(OutputFormat $oOutputFormat)
+    {
+        $sResult = '';
+        $bIsFirst = true;
+        $oNextLevel = $oOutputFormat;
+        if (!$this->isRootList()) {
+            $oNextLevel = $oOutputFormat->nextLevel();
+        }
+        foreach ($this->aContents as $oContent) {
+            $sRendered = $oOutputFormat->safely(function () use ($oNextLevel, $oContent) {
+                return $oContent->render($oNextLevel);
+            });
+            if ($sRendered === null) {
+                continue;
+            }
+            if ($bIsFirst) {
+                $bIsFirst = false;
+                $sResult .= $oNextLevel->spaceBeforeBlocks();
+            } else {
+                $sResult .= $oNextLevel->spaceBetweenBlocks();
+            }
+            $sResult .= $sRendered;
+        }
+
+        if (!$bIsFirst) {
+            // Had some output
+            $sResult .= $oOutputFormat->spaceAfterBlocks();
+        }
+
+        return $sResult;
+    }
+
+    /**
+     * Return true if the list can not be further outdented. Only important when rendering.
+     *
+     * @return bool
+     */
+    abstract public function isRootList();
+
+    /**
+     * Returns the stored items.
+     *
+     * @return array<int, RuleSet|Import|Charset|CSSList>
+     */
+    public function getContents()
+    {
+        return $this->aContents;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function addComments(array $aComments)
+    {
+        $this->aComments = array_merge($this->aComments, $aComments);
+    }
+
+    /**
+     * @return array<array-key, Comment>
+     */
+    public function getComments()
+    {
+        return $this->aComments;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function setComments(array $aComments)
+    {
+        $this->aComments = $aComments;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/CSSList/Document.php

@@ -0,0 +1,151 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\SourceException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Selector;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\DeclarationBlock;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet\RuleSet;
+
+/**
+ * This class represents the root of a parsed CSS file. It contains all top-level CSS contents: mostly declaration
+ * blocks, but also any at-rules encountered (`Import` and `Charset`).
+ */
+class Document extends CSSBlockList
+{
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+    }
+
+    /**
+     * @return Document
+     *
+     * @throws SourceException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState)
+    {
+        $oDocument = new Document($oParserState->currentLine());
+        CSSList::parseList($oParserState, $oDocument);
+        return $oDocument;
+    }
+
+    /**
+     * Gets all `DeclarationBlock` objects recursively, no matter how deeply nested the selectors are.
+     * Aliased as `getAllSelectors()`.
+     *
+     * @return array<int, DeclarationBlock>
+     */
+    public function getAllDeclarationBlocks()
+    {
+        /** @var array<int, DeclarationBlock> $aResult */
+        $aResult = [];
+        $this->allDeclarationBlocks($aResult);
+        return $aResult;
+    }
+
+    /**
+     * Gets all `DeclarationBlock` objects recursively.
+     *
+     * @return array<int, DeclarationBlock>
+     *
+     * @deprecated will be removed in version 9.0; use `getAllDeclarationBlocks()` instead
+     */
+    public function getAllSelectors()
+    {
+        return $this->getAllDeclarationBlocks();
+    }
+
+    /**
+     * Returns all `RuleSet` objects recursively found in the tree, no matter how deeply nested the rule sets are.
+     *
+     * @return array<int, RuleSet>
+     */
+    public function getAllRuleSets()
+    {
+        /** @var array<int, RuleSet> $aResult */
+        $aResult = [];
+        $this->allRuleSets($aResult);
+        return $aResult;
+    }
+
+    /**
+     * Returns all `Selector` objects with the requested specificity found recursively in the tree.
+     *
+     * Note that this does not yield the full `DeclarationBlock` that the selector belongs to
+     * (and, currently, there is no way to get to that).
+     *
+     * @param string|null $sSpecificitySearch
+     *        An optional filter by specificity.
+     *        May contain a comparison operator and a number or just a number (defaults to "==").
+     *
+     * @return array<int, Selector>
+     * @example `getSelectorsBySpecificity('>= 100')`
+     *
+     */
+    public function getSelectorsBySpecificity($sSpecificitySearch = null)
+    {
+        /** @var array<int, Selector> $aResult */
+        $aResult = [];
+        $this->allSelectors($aResult, $sSpecificitySearch);
+        return $aResult;
+    }
+
+    /**
+     * Expands all shorthand properties to their long value.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function expandShorthands()
+    {
+        foreach ($this->getAllDeclarationBlocks() as $oDeclaration) {
+            $oDeclaration->expandShorthands();
+        }
+    }
+
+    /**
+     * Create shorthands properties whenever possible.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createShorthands()
+    {
+        foreach ($this->getAllDeclarationBlocks() as $oDeclaration) {
+            $oDeclaration->createShorthands();
+        }
+    }
+
+    /**
+     * Overrides `render()` to make format argument optional.
+     *
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat = null)
+    {
+        if ($oOutputFormat === null) {
+            $oOutputFormat = new OutputFormat();
+        }
+        return $oOutputFormat->comments($this) . $this->renderListContents($oOutputFormat);
+    }
+
+    /**
+     * @return bool
+     */
+    public function isRootList()
+    {
+        return true;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/CSSList/KeyFrame.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\AtRule;
+
+class KeyFrame extends CSSList implements AtRule
+{
+    /**
+     * @var string|null
+     */
+    private $vendorKeyFrame;
+
+    /**
+     * @var string|null
+     */
+    private $animationName;
+
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+        $this->vendorKeyFrame = null;
+        $this->animationName = null;
+    }
+
+    /**
+     * @param string $vendorKeyFrame
+     */
+    public function setVendorKeyFrame($vendorKeyFrame)
+    {
+        $this->vendorKeyFrame = $vendorKeyFrame;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getVendorKeyFrame()
+    {
+        return $this->vendorKeyFrame;
+    }
+
+    /**
+     * @param string $animationName
+     */
+    public function setAnimationName($animationName)
+    {
+        $this->animationName = $animationName;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getAnimationName()
+    {
+        return $this->animationName;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        $sResult = $oOutputFormat->comments($this);
+        $sResult .= "@{$this->vendorKeyFrame} {$this->animationName}{$oOutputFormat->spaceBeforeOpeningBrace()}{";
+        $sResult .= $this->renderListContents($oOutputFormat);
+        $sResult .= '}';
+        return $sResult;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isRootList()
+    {
+        return false;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function atRuleName()
+    {
+        return $this->vendorKeyFrame;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function atRuleArgs()
+    {
+        return $this->animationName;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Comment/Comment.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Renderable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+
+class Comment implements Positionable, Renderable
+{
+    use Position;
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0
+     */
+    protected $sComment;
+
+    /**
+     * @param string $sComment
+     * @param int $iLineNo
+     */
+    public function __construct($sComment = '', $iLineNo = 0)
+    {
+        $this->sComment = $sComment;
+        $this->setPosition($iLineNo);
+    }
+
+    /**
+     * @return string
+     */
+    public function getComment()
+    {
+        return $this->sComment;
+    }
+
+    /**
+     * @param string $sComment
+     *
+     * @return void
+     */
+    public function setComment($sComment)
+    {
+        $this->sComment = $sComment;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return '/*' . $this->sComment . '*/';
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Comment/Commentable.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment;
+
+interface Commentable
+{
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function addComments(array $aComments);
+
+    /**
+     * @return array<array-key, Comment>
+     */
+    public function getComments();
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function setComments(array $aComments);
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/OutputFormat.php

@@ -0,0 +1,437 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS;
+
+/**
+ * Extending this class is deprecated in version 8.8.0; it will be made `final` in version 9.0.0.
+ *
+ * @method OutputFormat setSemicolonAfterLastRule(bool $bSemicolonAfterLastRule) Set whether semicolons are added after
+ *     last rule.
+ */
+class OutputFormat
+{
+    /**
+     * Value format: `"` means double-quote, `'` means single-quote
+     *
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sStringQuotingType = '"';
+
+    /**
+     * Output RGB colors in hash notation if possible
+     *
+     * @var bool
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $bRGBHashNotation = true;
+
+    /**
+     * Declaration format
+     *
+     * Semicolon after the last rule of a declaration block can be omitted. To do that, set this false.
+     *
+     * @var bool
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $bSemicolonAfterLastRule = true;
+
+    /**
+     * Spacing
+     * Note that these strings are not sanity-checked: the value should only consist of whitespace
+     * Any newline character will be indented according to the current level.
+     * The triples (After, Before, Between) can be set using a wildcard (e.g. `$oFormat->set('Space*Rules', "\n");`)
+     *
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceAfterRuleName = ' ';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceBeforeRules = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceAfterRules = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceBetweenRules = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceBeforeBlocks = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceAfterBlocks = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceBetweenBlocks = "\n";
+
+    /**
+     * Content injected in and around at-rule blocks.
+     *
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sBeforeAtRuleBlock = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sAfterAtRuleBlock = '';
+
+    /**
+     * This is what’s printed before and after the comma if a declaration block contains multiple selectors.
+     *
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceBeforeSelectorSeparator = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceAfterSelectorSeparator = ' ';
+
+    /**
+     * This is what’s inserted before the separator in value lists, by default.
+     *
+     * `array` is deprecated in version 8.8.0, and will be removed in version 9.0.0.
+     * To set the spacing for specific separators, use {@see $aSpaceBeforeListArgumentSeparators} instead.
+     *
+     * @var string|array<non-empty-string, string>
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceBeforeListArgumentSeparator = '';
+
+    /**
+     * Keys are separators (e.g. `,`).  Values are the space sequence to insert, or an empty string.
+     *
+     * @var array<non-empty-string, string>
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $aSpaceBeforeListArgumentSeparators = [];
+
+    /**
+     * This is what’s inserted after the separator in value lists, by default.
+     *
+     * `array` is deprecated in version 8.8.0, and will be removed in version 9.0.0.
+     * To set the spacing for specific separators, use {@see $aSpaceAfterListArgumentSeparators} instead.
+     *
+     * @var string|array<non-empty-string, string>
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceAfterListArgumentSeparator = '';
+
+    /**
+     * Keys are separators (e.g. `,`).  Values are the space sequence to insert, or an empty string.
+     *
+     * @var array<non-empty-string, string>
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $aSpaceAfterListArgumentSeparators = [];
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sSpaceBeforeOpeningBrace = ' ';
+
+    /**
+     * Content injected in and around declaration blocks.
+     *
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sBeforeDeclarationBlock = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sAfterDeclarationBlockSelectors = '';
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sAfterDeclarationBlock = '';
+
+    /**
+     * Indentation character(s) per level. Only applicable if newlines are used in any of the spacing settings.
+     *
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sIndentation = "\t";
+
+    /**
+     * Output exceptions.
+     *
+     * @var bool
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $bIgnoreExceptions = false;
+
+    /**
+     * Render comments for lists and RuleSets
+     *
+     * @var bool
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $bRenderComments = false;
+
+    /**
+     * @var OutputFormatter|null
+     */
+    private $oFormatter = null;
+
+    /**
+     * @var OutputFormat|null
+     */
+    private $oNextLevelFormat = null;
+
+    /**
+     * @var int
+     */
+    private $iIndentationLevel = 0;
+
+    /**
+     * @internal since V8.8.0. Use the factory methods `create()`, `createCompact()`, or `createPretty()` instead.
+     */
+    public function __construct()
+    {
+    }
+
+    /**
+     * @param string $sName
+     *
+     * @return string|null
+     *
+     * @deprecated since 8.8.0, will be removed in 9.0.0. Use specific getters instead.
+     */
+    public function get($sName)
+    {
+        $aVarPrefixes = ['a', 's', 'm', 'b', 'f', 'o', 'c', 'i'];
+        foreach ($aVarPrefixes as $sPrefix) {
+            $sFieldName = $sPrefix . ucfirst($sName);
+            if (isset($this->$sFieldName)) {
+                return $this->$sFieldName;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * @param array<array-key, string>|string $aNames
+     * @param mixed $mValue
+     *
+     * @return self|false
+     *
+     * @deprecated since 8.8.0, will be removed in 9.0.0. Use specific setters instead.
+     */
+    public function set($aNames, $mValue)
+    {
+        $aVarPrefixes = ['a', 's', 'm', 'b', 'f', 'o', 'c', 'i'];
+        if (is_string($aNames) && strpos($aNames, '*') !== false) {
+            $aNames =
+                [
+                    str_replace('*', 'Before', $aNames),
+                    str_replace('*', 'Between', $aNames),
+                    str_replace('*', 'After', $aNames),
+                ];
+        } elseif (!is_array($aNames)) {
+            $aNames = [$aNames];
+        }
+        foreach ($aVarPrefixes as $sPrefix) {
+            $bDidReplace = false;
+            foreach ($aNames as $sName) {
+                $sFieldName = $sPrefix . ucfirst($sName);
+                if (isset($this->$sFieldName)) {
+                    $this->$sFieldName = $mValue;
+                    $bDidReplace = true;
+                }
+            }
+            if ($bDidReplace) {
+                return $this;
+            }
+        }
+        // Break the chain so the user knows this option is invalid
+        return false;
+    }
+
+    /**
+     * @param string $sMethodName
+     * @param array<array-key, mixed> $aArguments
+     *
+     * @return mixed
+     *
+     * @throws \Exception
+     */
+    public function __call($sMethodName, array $aArguments)
+    {
+        if (strpos($sMethodName, 'set') === 0) {
+            return $this->set(substr($sMethodName, 3), $aArguments[0]);
+        } elseif (strpos($sMethodName, 'get') === 0) {
+            return $this->get(substr($sMethodName, 3));
+        } elseif (method_exists(OutputFormatter::class, $sMethodName)) {
+            // @deprecated since 8.8.0, will be removed in 9.0.0. Call the method on the formatter directly instead.
+            return call_user_func_array([$this->getFormatter(), $sMethodName], $aArguments);
+        } else {
+            throw new \Exception('Unknown OutputFormat method called: ' . $sMethodName);
+        }
+    }
+
+    /**
+     * @param int $iNumber
+     *
+     * @return self
+     */
+    public function indentWithTabs($iNumber = 1)
+    {
+        return $this->setIndentation(str_repeat("\t", $iNumber));
+    }
+
+    /**
+     * @param int $iNumber
+     *
+     * @return self
+     */
+    public function indentWithSpaces($iNumber = 2)
+    {
+        return $this->setIndentation(str_repeat(" ", $iNumber));
+    }
+
+    /**
+     * @return OutputFormat
+     *
+     * @internal since V8.8.0
+     */
+    public function nextLevel()
+    {
+        if ($this->oNextLevelFormat === null) {
+            $this->oNextLevelFormat = clone $this;
+            $this->oNextLevelFormat->iIndentationLevel++;
+            $this->oNextLevelFormat->oFormatter = null;
+        }
+        return $this->oNextLevelFormat;
+    }
+
+    /**
+     * @return void
+     */
+    public function beLenient()
+    {
+        $this->bIgnoreExceptions = true;
+    }
+
+    /**
+     * @return OutputFormatter
+     *
+     * @internal since 8.8.0
+     */
+    public function getFormatter()
+    {
+        if ($this->oFormatter === null) {
+            $this->oFormatter = new OutputFormatter($this);
+        }
+
+        return $this->oFormatter;
+    }
+
+    /**
+     * @return int
+     *
+     * @deprecated #869 since version V8.8.0, will be removed in V9.0.0. Use `getIndentationLevel()` instead.
+     */
+    public function level()
+    {
+        return $this->iIndentationLevel;
+    }
+
+    /**
+     * Creates an instance of this class without any particular formatting settings.
+     *
+     * @return self
+     */
+    public static function create()
+    {
+        return new OutputFormat();
+    }
+
+    /**
+     * Creates an instance of this class with a preset for compact formatting.
+     *
+     * @return self
+     */
+    public static function createCompact()
+    {
+        $format = self::create();
+        $format->set('Space*Rules', "")
+            ->set('Space*Blocks', "")
+            ->setSpaceAfterRuleName('')
+            ->setSpaceBeforeOpeningBrace('')
+            ->setSpaceAfterSelectorSeparator('')
+            ->setRenderComments(false);
+        return $format;
+    }
+
+    /**
+     * Creates an instance of this class with a preset for pretty formatting.
+     *
+     * @return self
+     */
+    public static function createPretty()
+    {
+        $format = self::create();
+        $format->set('Space*Rules', "\n")
+            ->set('Space*Blocks', "\n")
+            ->setSpaceBetweenBlocks("\n\n")
+            ->set('SpaceAfterListArgumentSeparators', [',' => ' '])
+            ->setRenderComments(true);
+        return $format;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/OutputFormatter.php

@@ -0,0 +1,268 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Commentable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\OutputException;
+
+/**
+ * @internal since 8.8.0
+ */
+class OutputFormatter
+{
+    /**
+     * @var OutputFormat
+     */
+    private $oFormat;
+
+    public function __construct(OutputFormat $oFormat)
+    {
+        $this->oFormat = $oFormat;
+    }
+
+    /**
+     * @param string $sName
+     * @param string|null $sType
+     *
+     * @return string
+     */
+    public function space($sName, $sType = null)
+    {
+        $sSpaceString = $this->oFormat->get("Space$sName");
+        // If $sSpaceString is an array, we have multiple values configured
+        // depending on the type of object the space applies to
+        if (is_array($sSpaceString)) {
+            if ($sType !== null && isset($sSpaceString[$sType])) {
+                $sSpaceString = $sSpaceString[$sType];
+            } else {
+                $sSpaceString = reset($sSpaceString);
+            }
+        }
+        return $this->prepareSpace($sSpaceString);
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceAfterRuleName()
+    {
+        return $this->space('AfterRuleName');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceBeforeRules()
+    {
+        return $this->space('BeforeRules');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceAfterRules()
+    {
+        return $this->space('AfterRules');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceBetweenRules()
+    {
+        return $this->space('BetweenRules');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceBeforeBlocks()
+    {
+        return $this->space('BeforeBlocks');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceAfterBlocks()
+    {
+        return $this->space('AfterBlocks');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceBetweenBlocks()
+    {
+        return $this->space('BetweenBlocks');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceBeforeSelectorSeparator()
+    {
+        return $this->space('BeforeSelectorSeparator');
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceAfterSelectorSeparator()
+    {
+        return $this->space('AfterSelectorSeparator');
+    }
+
+    /**
+     * @param string $sSeparator
+     *
+     * @return string
+     */
+    public function spaceBeforeListArgumentSeparator($sSeparator)
+    {
+        $spaceForSeparator = $this->oFormat->getSpaceBeforeListArgumentSeparators();
+        if (isset($spaceForSeparator[$sSeparator])) {
+            return $spaceForSeparator[$sSeparator];
+        }
+
+        return $this->space('BeforeListArgumentSeparator', $sSeparator);
+    }
+
+    /**
+     * @param string $sSeparator
+     *
+     * @return string
+     */
+    public function spaceAfterListArgumentSeparator($sSeparator)
+    {
+        $spaceForSeparator = $this->oFormat->getSpaceAfterListArgumentSeparators();
+        if (isset($spaceForSeparator[$sSeparator])) {
+            return $spaceForSeparator[$sSeparator];
+        }
+
+        return $this->space('AfterListArgumentSeparator', $sSeparator);
+    }
+
+    /**
+     * @return string
+     */
+    public function spaceBeforeOpeningBrace()
+    {
+        return $this->space('BeforeOpeningBrace');
+    }
+
+    /**
+     * Runs the given code, either swallowing or passing exceptions, depending on the `bIgnoreExceptions` setting.
+     *
+     * @param string $cCode the name of the function to call
+     *
+     * @return string|null
+     */
+    public function safely($cCode)
+    {
+        if ($this->oFormat->get('IgnoreExceptions')) {
+            // If output exceptions are ignored, run the code with exception guards
+            try {
+                return $cCode();
+            } catch (OutputException $e) {
+                return null;
+            } // Do nothing
+        } else {
+            // Run the code as-is
+            return $cCode();
+        }
+    }
+
+    /**
+     * Clone of the `implode` function, but calls `render` with the current output format instead of `__toString()`.
+     *
+     * @param string $sSeparator
+     * @param array<array-key, Renderable|string> $aValues
+     * @param bool $bIncreaseLevel
+     *
+     * @return string
+     */
+    public function implode($sSeparator, array $aValues, $bIncreaseLevel = false)
+    {
+        $sResult = '';
+        $oFormat = $this->oFormat;
+        if ($bIncreaseLevel) {
+            $oFormat = $oFormat->nextLevel();
+        }
+        $bIsFirst = true;
+        foreach ($aValues as $mValue) {
+            if ($bIsFirst) {
+                $bIsFirst = false;
+            } else {
+                $sResult .= $sSeparator;
+            }
+            if ($mValue instanceof Renderable) {
+                $sResult .= $mValue->render($oFormat);
+            } else {
+                $sResult .= $mValue;
+            }
+        }
+        return $sResult;
+    }
+
+    /**
+     * @param string $sString
+     *
+     * @return string
+     */
+    public function removeLastSemicolon($sString)
+    {
+        if ($this->oFormat->get('SemicolonAfterLastRule')) {
+            return $sString;
+        }
+        $sString = explode(';', $sString);
+        if (count($sString) < 2) {
+            return $sString[0];
+        }
+        $sLast = array_pop($sString);
+        $sNextToLast = array_pop($sString);
+        array_push($sString, $sNextToLast . $sLast);
+        return implode(';', $sString);
+    }
+
+    /**
+     *
+     * @param array<Commentable> $aComments
+     *
+     * @return string
+     */
+    public function comments(Commentable $oCommentable)
+    {
+        if (!$this->oFormat->bRenderComments) {
+            return '';
+        }
+
+        $sResult = '';
+        $aComments = $oCommentable->getComments();
+        $iLastCommentIndex = count($aComments) - 1;
+
+        foreach ($aComments as $i => $oComment) {
+            $sResult .= $oComment->render($this->oFormat);
+            $sResult .= $i === $iLastCommentIndex ? $this->spaceAfterBlocks() : $this->spaceBetweenBlocks();
+        }
+        return $sResult;
+    }
+
+    /**
+     * @param string $sSpaceString
+     *
+     * @return string
+     */
+    private function prepareSpace($sSpaceString)
+    {
+        return str_replace("\n", "\n" . $this->indent(), $sSpaceString);
+    }
+
+    /**
+     * @return string
+     */
+    private function indent()
+    {
+        return str_repeat($this->oFormat->sIndentation, $this->oFormat->getIndentationLevel());
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Parser.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList\Document;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\SourceException;
+
+/**
+ * This class parses CSS from text into a data structure.
+ */
+class Parser
+{
+    /**
+     * @var ParserState
+     */
+    private $oParserState;
+
+    /**
+     * @param string $sText the complete CSS as text (i.e., usually the contents of a CSS file)
+     * @param Settings|null $oParserSettings
+     * @param int $iLineNo the line number (starting from 1, not from 0)
+     */
+    public function __construct($sText, $oParserSettings = null, $iLineNo = 1)
+    {
+        if ($oParserSettings === null) {
+            $oParserSettings = Settings::create();
+        }
+        $this->oParserState = new ParserState($sText, $oParserSettings, $iLineNo);
+    }
+
+    /**
+     * Sets the charset to be used if the CSS does not contain an `@charset` declaration.
+     *
+     * @param string $sCharset
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed in version 9.0.0 with #687
+     */
+    public function setCharset($sCharset)
+    {
+        $this->oParserState->setCharset($sCharset);
+    }
+
+    /**
+     * Returns the charset that is used if the CSS does not contain an `@charset` declaration.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed in version 9.0.0 with #687
+     */
+    public function getCharset()
+    {
+        // Note: The `return` statement is missing here. This is a bug that needs to be fixed.
+        $this->oParserState->getCharset();
+    }
+
+    /**
+     * Parses the CSS provided to the constructor and creates a `Document` from it.
+     *
+     * @return Document
+     *
+     * @throws SourceException
+     */
+    public function parse()
+    {
+        return Document::parse($this->oParserState);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Parsing/Anchor.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing;
+
+/**
+ * @internal since 8.7.0
+ */
+class Anchor
+{
+    /**
+     * @var int
+     */
+    private $iPosition;
+
+    /**
+     * @var \Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState
+     */
+    private $oParserState;
+
+    /**
+     * @param int $iPosition
+     * @param \Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState $oParserState
+     */
+    public function __construct($iPosition, ParserState $oParserState)
+    {
+        $this->iPosition = $iPosition;
+        $this->oParserState = $oParserState;
+    }
+
+    /**
+     * @return void
+     */
+    public function backtrack()
+    {
+        $this->oParserState->setPosition($this->iPosition);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Parsing/OutputException.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing;
+
+/**
+ * Thrown if the CSS parser attempts to print something invalid.
+ */
+class OutputException extends SourceException
+{
+    /**
+     * @param string $sMessage
+     * @param int $iLineNo
+     */
+    public function __construct($sMessage, $iLineNo = 0)
+    {
+        parent::__construct($sMessage, $iLineNo);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Parsing/ParserState.php

@@ -0,0 +1,552 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Comment;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Settings;
+
+/**
+ * @internal since 8.7.0
+ */
+class ParserState
+{
+    /**
+     * @var null
+     *
+     * @internal since 8.5.2
+     */
+    const EOF = null;
+
+    /**
+     * @var Settings
+     */
+    private $oParserSettings;
+
+    /**
+     * @var string
+     */
+    private $sText;
+
+    /**
+     * @var array<int, string>
+     */
+    private $aText;
+
+    /**
+     * @var int
+     */
+    private $iCurrentPosition;
+
+    /**
+     * will only be used if the CSS does not contain an `@charset` declaration
+     *
+     * @var string
+     */
+    private $sCharset;
+
+    /**
+     * @var int
+     */
+    private $iLength;
+
+    /**
+     * @var int
+     */
+    private $iLineNo;
+
+    /**
+     * @param string $sText the complete CSS as text (i.e., usually the contents of a CSS file)
+     * @param int $iLineNo
+     */
+    public function __construct($sText, Settings $oParserSettings, $iLineNo = 1)
+    {
+        $this->oParserSettings = $oParserSettings;
+        $this->sText = $sText;
+        $this->iCurrentPosition = 0;
+        $this->iLineNo = $iLineNo;
+        $this->setCharset($this->oParserSettings->sDefaultCharset);
+    }
+
+    /**
+     * Sets the charset to be used if the CSS does not contain an `@charset` declaration.
+     *
+     * @param string $sCharset
+     *
+     * @return void
+     */
+    public function setCharset($sCharset)
+    {
+        $this->sCharset = $sCharset;
+        $this->aText = $this->strsplit($this->sText);
+        if (is_array($this->aText)) {
+            $this->iLength = count($this->aText);
+        }
+    }
+
+    /**
+     * Returns the charset that is used if the CSS does not contain an `@charset` declaration.
+     *
+     * @return string
+     */
+    public function getCharset()
+    {
+        return $this->sCharset;
+    }
+
+    /**
+     * @return int
+     */
+    public function currentLine()
+    {
+        return $this->iLineNo;
+    }
+
+    /**
+     * @return int
+     */
+    public function currentColumn()
+    {
+        return $this->iCurrentPosition;
+    }
+
+    /**
+     * @return Settings
+     */
+    public function getSettings()
+    {
+        return $this->oParserSettings;
+    }
+
+    /**
+     * @return \Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\Anchor
+     */
+    public function anchor()
+    {
+        return new Anchor($this->iCurrentPosition, $this);
+    }
+
+    /**
+     * @param int $iPosition
+     *
+     * @return void
+     */
+    public function setPosition($iPosition)
+    {
+        $this->iCurrentPosition = $iPosition;
+    }
+
+    /**
+     * @param bool $bIgnoreCase
+     *
+     * @return string
+     *
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public function parseIdentifier($bIgnoreCase = true)
+    {
+        if ($this->isEnd()) {
+            throw new UnexpectedEOFException('', '', 'identifier', $this->iLineNo);
+        }
+        $sResult = $this->parseCharacter(true);
+        if ($sResult === null) {
+            throw new UnexpectedTokenException($sResult, $this->peek(5), 'identifier', $this->iLineNo);
+        }
+        $sCharacter = null;
+        while (!$this->isEnd() && ($sCharacter = $this->parseCharacter(true)) !== null) {
+            if (preg_match('/[a-zA-Z0-9\x{00A0}-\x{FFFF}_-]/Sux', $sCharacter)) {
+                $sResult .= $sCharacter;
+            } else {
+                $sResult .= '\\' . $sCharacter;
+            }
+        }
+        if ($bIgnoreCase) {
+            $sResult = $this->strtolower($sResult);
+        }
+        return $sResult;
+    }
+
+    /**
+     * @param bool $bIsForIdentifier
+     *
+     * @return string|null
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public function parseCharacter($bIsForIdentifier)
+    {
+        if ($this->peek() === '\\') {
+            if (
+                $bIsForIdentifier && $this->oParserSettings->bLenientParsing
+                && ($this->comes('\0') || $this->comes('\9'))
+            ) {
+                // Non-strings can contain \0 or \9 which is an IE hack supported in lenient parsing.
+                return null;
+            }
+            $this->consume('\\');
+            if ($this->comes('\n') || $this->comes('\r')) {
+                return '';
+            }
+            if (preg_match('/[0-9a-fA-F]/Su', $this->peek()) === 0) {
+                return $this->consume(1);
+            }
+            $sUnicode = $this->consumeExpression('/^[0-9a-fA-F]{1,6}/u', 6);
+            if ($this->strlen($sUnicode) < 6) {
+                // Consume whitespace after incomplete unicode escape
+                if (preg_match('/\\s/isSu', $this->peek())) {
+                    if ($this->comes('\r\n')) {
+                        $this->consume(2);
+                    } else {
+                        $this->consume(1);
+                    }
+                }
+            }
+            $iUnicode = intval($sUnicode, 16);
+            $sUtf32 = "";
+            for ($i = 0; $i < 4; ++$i) {
+                $sUtf32 .= chr($iUnicode & 0xff);
+                $iUnicode = $iUnicode >> 8;
+            }
+            return iconv('utf-32le', $this->sCharset, $sUtf32);
+        }
+        if ($bIsForIdentifier) {
+            $peek = ord($this->peek());
+            // Ranges: a-z A-Z 0-9 - _
+            if (
+                ($peek >= 97 && $peek <= 122)
+                || ($peek >= 65 && $peek <= 90)
+                || ($peek >= 48 && $peek <= 57)
+                || ($peek === 45)
+                || ($peek === 95)
+                || ($peek > 0xa1)
+            ) {
+                return $this->consume(1);
+            }
+        } else {
+            return $this->consume(1);
+        }
+        return null;
+    }
+
+    /**
+     * @return array<int, Comment>|void
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     */
+    public function consumeWhiteSpace()
+    {
+        $aComments = [];
+        do {
+            while (preg_match('/\\s/isSu', $this->peek()) === 1) {
+                $this->consume(1);
+            }
+            if ($this->oParserSettings->bLenientParsing) {
+                try {
+                    $oComment = $this->consumeComment();
+                } catch (UnexpectedEOFException $e) {
+                    $this->iCurrentPosition = $this->iLength;
+                    return $aComments;
+                }
+            } else {
+                $oComment = $this->consumeComment();
+            }
+            if ($oComment !== false) {
+                $aComments[] = $oComment;
+            }
+        } while ($oComment !== false);
+        return $aComments;
+    }
+
+    /**
+     * @param string $sString
+     * @param bool $bCaseInsensitive
+     *
+     * @return bool
+     */
+    public function comes($sString, $bCaseInsensitive = false)
+    {
+        $sPeek = $this->peek(strlen($sString));
+        return ($sPeek == '')
+            ? false
+            : $this->streql($sPeek, $sString, $bCaseInsensitive);
+    }
+
+    /**
+     * @param int $iLength
+     * @param int $iOffset
+     *
+     * @return string
+     */
+    public function peek($iLength = 1, $iOffset = 0)
+    {
+        $iOffset += $this->iCurrentPosition;
+        if ($iOffset >= $this->iLength) {
+            return '';
+        }
+        return $this->substr($iOffset, $iLength);
+    }
+
+    /**
+     * @param int $mValue
+     *
+     * @return string
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     */
+    public function consume($mValue = 1)
+    {
+        if (is_string($mValue)) {
+            $iLineCount = substr_count($mValue, "\n");
+            $iLength = $this->strlen($mValue);
+            if (!$this->streql($this->substr($this->iCurrentPosition, $iLength), $mValue)) {
+                throw new UnexpectedTokenException($mValue, $this->peek(max($iLength, 5)), $this->iLineNo);
+            }
+            $this->iLineNo += $iLineCount;
+            $this->iCurrentPosition += $this->strlen($mValue);
+            return $mValue;
+        } else {
+            if ($this->iCurrentPosition + $mValue > $this->iLength) {
+                throw new UnexpectedEOFException($mValue, $this->peek(5), 'count', $this->iLineNo);
+            }
+            $sResult = $this->substr($this->iCurrentPosition, $mValue);
+            $iLineCount = substr_count($sResult, "\n");
+            $this->iLineNo += $iLineCount;
+            $this->iCurrentPosition += $mValue;
+            return $sResult;
+        }
+    }
+
+    /**
+     * @param string $mExpression
+     * @param int|null $iMaxLength
+     *
+     * @return string
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     */
+    public function consumeExpression($mExpression, $iMaxLength = null)
+    {
+        $aMatches = null;
+        $sInput = $iMaxLength !== null ? $this->peek($iMaxLength) : $this->inputLeft();
+        if (preg_match($mExpression, $sInput, $aMatches, PREG_OFFSET_CAPTURE) === 1) {
+            return $this->consume($aMatches[0][0]);
+        }
+        throw new UnexpectedTokenException($mExpression, $this->peek(5), 'expression', $this->iLineNo);
+    }
+
+    /**
+     * @return Comment|false
+     */
+    public function consumeComment()
+    {
+        $mComment = false;
+        if ($this->comes('/*')) {
+            $iLineNo = $this->iLineNo;
+            $this->consume(1);
+            $mComment = '';
+            while (($char = $this->consume(1)) !== '') {
+                $mComment .= $char;
+                if ($this->comes('*/')) {
+                    $this->consume(2);
+                    break;
+                }
+            }
+        }
+
+        if ($mComment !== false) {
+            // We skip the * which was included in the comment.
+            return new Comment(substr($mComment, 1), $iLineNo);
+        }
+
+        return $mComment;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isEnd()
+    {
+        return $this->iCurrentPosition >= $this->iLength;
+    }
+
+    /**
+     * @param array<array-key, string>|string $aEnd
+     * @param string $bIncludeEnd
+     * @param string $consumeEnd
+     * @param array<int, Comment> $comments
+     *
+     * @return string
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     */
+    public function consumeUntil($aEnd, $bIncludeEnd = false, $consumeEnd = false, array &$comments = [])
+    {
+        $aEnd = is_array($aEnd) ? $aEnd : [$aEnd];
+        $out = '';
+        $start = $this->iCurrentPosition;
+
+        while (!$this->isEnd()) {
+            $char = $this->consume(1);
+            if (in_array($char, $aEnd)) {
+                if ($bIncludeEnd) {
+                    $out .= $char;
+                } elseif (!$consumeEnd) {
+                    $this->iCurrentPosition -= $this->strlen($char);
+                }
+                return $out;
+            }
+            $out .= $char;
+            if ($comment = $this->consumeComment()) {
+                $comments[] = $comment;
+            }
+        }
+
+        if (in_array(self::EOF, $aEnd)) {
+            return $out;
+        }
+
+        $this->iCurrentPosition = $start;
+        throw new UnexpectedEOFException(
+            'One of ("' . implode('","', $aEnd) . '")',
+            $this->peek(5),
+            'search',
+            $this->iLineNo
+        );
+    }
+
+    /**
+     * @return string
+     */
+    private function inputLeft()
+    {
+        return $this->substr($this->iCurrentPosition, -1);
+    }
+
+    /**
+     * @param string $sString1
+     * @param string $sString2
+     * @param bool $bCaseInsensitive
+     *
+     * @return bool
+     */
+    public function streql($sString1, $sString2, $bCaseInsensitive = true)
+    {
+        if ($bCaseInsensitive) {
+            return $this->strtolower($sString1) === $this->strtolower($sString2);
+        } else {
+            return $sString1 === $sString2;
+        }
+    }
+
+    /**
+     * @param int $iAmount
+     *
+     * @return void
+     */
+    public function backtrack($iAmount)
+    {
+        $this->iCurrentPosition -= $iAmount;
+    }
+
+    /**
+     * @param string $sString
+     *
+     * @return int
+     */
+    public function strlen($sString)
+    {
+        if ($this->oParserSettings->bMultibyteSupport) {
+            return mb_strlen($sString, $this->sCharset);
+        } else {
+            return strlen($sString);
+        }
+    }
+
+    /**
+     * @param int $iStart
+     * @param int $iLength
+     *
+     * @return string
+     */
+    private function substr($iStart, $iLength)
+    {
+        if ($iLength < 0) {
+            $iLength = $this->iLength - $iStart + $iLength;
+        }
+        if ($iStart + $iLength > $this->iLength) {
+            $iLength = $this->iLength - $iStart;
+        }
+        $sResult = '';
+        while ($iLength > 0) {
+            $sResult .= $this->aText[$iStart];
+            $iStart++;
+            $iLength--;
+        }
+        return $sResult;
+    }
+
+    /**
+     * @param string $sString
+     *
+     * @return string
+     */
+    private function strtolower($sString)
+    {
+        if ($this->oParserSettings->bMultibyteSupport) {
+            return mb_strtolower($sString, $this->sCharset);
+        } else {
+            return strtolower($sString);
+        }
+    }
+
+    /**
+     * @param string $sString
+     *
+     * @return array<int, string>
+     */
+    private function strsplit($sString)
+    {
+        if ($this->oParserSettings->bMultibyteSupport) {
+            if ($this->streql($this->sCharset, 'utf-8')) {
+                return preg_split('//u', $sString, -1, PREG_SPLIT_NO_EMPTY);
+            } else {
+                $iLength = mb_strlen($sString, $this->sCharset);
+                $aResult = [];
+                for ($i = 0; $i < $iLength; ++$i) {
+                    $aResult[] = mb_substr($sString, $i, 1, $this->sCharset);
+                }
+                return $aResult;
+            }
+        } else {
+            if ($sString === '') {
+                return [];
+            } else {
+                return str_split($sString);
+            }
+        }
+    }
+
+    /**
+     * @param string $sString
+     * @param string $sNeedle
+     * @param int $iOffset
+     *
+     * @return int|false
+     */
+    private function strpos($sString, $sNeedle, $iOffset)
+    {
+        if ($this->oParserSettings->bMultibyteSupport) {
+            return mb_strpos($sString, $sNeedle, $iOffset, $this->sCharset);
+        } else {
+            return strpos($sString, $sNeedle, $iOffset);
+        }
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Parsing/SourceException.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+
+class SourceException extends \Exception implements Positionable
+{
+    use Position;
+
+    /**
+     * @param string $sMessage
+     * @param int $iLineNo
+     */
+    public function __construct($sMessage, $iLineNo = 0)
+    {
+        $this->setPosition($iLineNo);
+        if (!empty($iLineNo)) {
+            $sMessage .= " [line no: $iLineNo]";
+        }
+        parent::__construct($sMessage);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Parsing/UnexpectedEOFException.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing;
+
+/**
+ * Thrown if the CSS parser encounters end of file it did not expect.
+ *
+ * Extends `UnexpectedTokenException` in order to preserve backwards compatibility.
+ */
+class UnexpectedEOFException extends UnexpectedTokenException
+{
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Parsing/UnexpectedTokenException.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing;
+
+/**
+ * Thrown if the CSS parser encounters a token it did not expect.
+ */
+class UnexpectedTokenException extends SourceException
+{
+    /**
+     * @var string
+     */
+    private $sExpected;
+
+    /**
+     * @var string
+     */
+    private $sFound;
+
+    /**
+     * Possible values: literal, identifier, count, expression, search
+     *
+     * @var string
+     */
+    private $sMatchType;
+
+    /**
+     * @param string $sExpected
+     * @param string $sFound
+     * @param string $sMatchType
+     * @param int $iLineNo
+     */
+    public function __construct($sExpected, $sFound, $sMatchType = 'literal', $iLineNo = 0)
+    {
+        $this->sExpected = $sExpected;
+        $this->sFound = $sFound;
+        $this->sMatchType = $sMatchType;
+        $sMessage = "Token “{$sExpected}” ({$sMatchType}) not found. Got “{$sFound}”.";
+        if ($this->sMatchType === 'search') {
+            $sMessage = "Search for “{$sExpected}” returned no results. Context: “{$sFound}”.";
+        } elseif ($this->sMatchType === 'count') {
+            $sMessage = "Next token was expected to have {$sExpected} chars. Context: “{$sFound}”.";
+        } elseif ($this->sMatchType === 'identifier') {
+            $sMessage = "Identifier expected. Got “{$sFound}”";
+        } elseif ($this->sMatchType === 'custom') {
+            $sMessage = trim("$sExpected $sFound");
+        }
+
+        parent::__construct($sMessage, $iLineNo);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Position/Position.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position;
+
+/**
+ * Provides a standard reusable implementation of `Positionable`.
+ *
+ * @internal
+ *
+ * @phpstan-require-implements Positionable
+ */
+trait Position
+{
+    /**
+     * @var int<1, max>|null
+     */
+    protected $lineNumber;
+
+    /**
+     * @var int<0, max>|null
+     */
+    protected $columnNumber;
+
+    /**
+     * @return int<1, max>|null
+     */
+    public function getLineNumber()
+    {
+        return $this->lineNumber;
+    }
+
+    /**
+     * @return int<0, max>
+     */
+    public function getLineNo()
+    {
+        $lineNumber = $this->getLineNumber();
+
+        return $lineNumber !== null ? $lineNumber : 0;
+    }
+
+    /**
+     * @return int<0, max>|null
+     */
+    public function getColumnNumber()
+    {
+        return $this->columnNumber;
+    }
+
+    /**
+     * @return int<0, max>
+     */
+    public function getColNo()
+    {
+        $columnNumber = $this->getColumnNumber();
+
+        return $columnNumber !== null ? $columnNumber : 0;
+    }
+
+    /**
+     * @param int<0, max>|null $lineNumber
+     * @param int<0, max>|null $columnNumber
+     */
+    public function setPosition($lineNumber, $columnNumber = null)
+    {
+        // The conditional is for backwards compatibility (backcompat); `0` will not be allowed in future.
+        $this->lineNumber = $lineNumber !== 0 ? $lineNumber : null;
+        $this->columnNumber = $columnNumber;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Position/Positionable.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position;
+
+/**
+ * Represents a CSS item that may have a position in the source CSS document (line number and possibly column number).
+ *
+ * A standard implementation of this interface is available in the `Position` trait.
+ */
+interface Positionable
+{
+    /**
+     * @return int<1, max>|null
+     */
+    public function getLineNumber();
+
+    /**
+     * @return int<0, max>
+     *
+     * @deprecated in version 8.9.0, will be removed in v9.0. Use `getLineNumber()` instead.
+     */
+    public function getLineNo();
+
+    /**
+     * @return int<0, max>|null
+     */
+    public function getColumnNumber();
+
+    /**
+     * @return int<0, max>
+     *
+     * @deprecated in version 8.9.0, will be removed in v9.0. Use `getColumnNumber()` instead.
+     */
+    public function getColNo();
+
+    /**
+     * @param int<0, max>|null $lineNumber
+     *        Providing zero for this parameter is deprecated in version 8.9.0, and will not be supported from v9.0.
+     *        Use `null` instead when no line number is available.
+     * @param int<0, max>|null $columnNumber
+     */
+    public function setPosition($lineNumber, $columnNumber = null);
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Property/AtRule.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Commentable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Renderable;
+
+interface AtRule extends Renderable, Commentable
+{
+    /**
+     * Since there are more set rules than block rules,
+     * we’re whitelisting the block rules and have anything else be treated as a set rule.
+     *
+     * @var string
+     *
+     * @internal since 8.5.2
+     */
+    const BLOCK_RULES = 'media/document/supports/region-style/font-feature-values';
+
+    /**
+     * … and more font-specific ones (to be used inside font-feature-values)
+     *
+     * @var string
+     *
+     * @internal since 8.5.2
+     */
+    const SET_RULES = 'font-face/counter-style/page/swash/styleset/annotation';
+
+    /**
+     * @return string|null
+     */
+    public function atRuleName();
+
+    /**
+     * @return string|null
+     */
+    public function atRuleArgs();
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Property/CSSNamespace.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Comment;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+
+/**
+ * `CSSNamespace` represents an `@namespace` rule.
+ */
+class CSSNamespace implements AtRule, Positionable
+{
+    use Position;
+
+    /**
+     * @var string
+     */
+    private $mUrl;
+
+    /**
+     * @var string
+     */
+    private $sPrefix;
+
+    /**
+     * @var int
+     */
+    private $iLineNo;
+
+    /**
+     * @var array<array-key, Comment>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aComments;
+
+    /**
+     * @param string $mUrl
+     * @param string|null $sPrefix
+     * @param int $iLineNo
+     */
+    public function __construct($mUrl, $sPrefix = null, $iLineNo = 0)
+    {
+        $this->mUrl = $mUrl;
+        $this->sPrefix = $sPrefix;
+        $this->setPosition($iLineNo);
+        $this->aComments = [];
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return '@namespace ' . ($this->sPrefix === null ? '' : $this->sPrefix . ' ')
+            . $this->mUrl->render($oOutputFormat) . ';';
+    }
+
+    /**
+     * @return string
+     */
+    public function getUrl()
+    {
+        return $this->mUrl;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getPrefix()
+    {
+        return $this->sPrefix;
+    }
+
+    /**
+     * @param string $mUrl
+     *
+     * @return void
+     */
+    public function setUrl($mUrl)
+    {
+        $this->mUrl = $mUrl;
+    }
+
+    /**
+     * @param string $sPrefix
+     *
+     * @return void
+     */
+    public function setPrefix($sPrefix)
+    {
+        $this->sPrefix = $sPrefix;
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleName()
+    {
+        return 'namespace';
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    public function atRuleArgs()
+    {
+        $aResult = [$this->mUrl];
+        if ($this->sPrefix) {
+            array_unshift($aResult, $this->sPrefix);
+        }
+        return $aResult;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function addComments(array $aComments)
+    {
+        $this->aComments = array_merge($this->aComments, $aComments);
+    }
+
+    /**
+     * @return array<array-key, Comment>
+     */
+    public function getComments()
+    {
+        return $this->aComments;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function setComments(array $aComments)
+    {
+        $this->aComments = $aComments;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Property/Charset.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Comment;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\CSSString;
+
+/**
+ * Class representing an `@charset` rule.
+ *
+ * The following restrictions apply:
+ * - May not be found in any CSSList other than the Document.
+ * - May only appear at the very top of a Document’s contents.
+ * - Must not appear more than once.
+ */
+class Charset implements AtRule, Positionable
+{
+    use Position;
+
+    /**
+     * @var CSSString
+     */
+    private $oCharset;
+
+    /**
+     * @var int
+     *
+     * @internal since 8.8.0
+     */
+    protected $iLineNo;
+
+    /**
+     * @var array<array-key, Comment>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aComments;
+
+    /**
+     * @param CSSString $oCharset
+     * @param int $iLineNo
+     */
+    public function __construct(CSSString $oCharset, $iLineNo = 0)
+    {
+        $this->oCharset = $oCharset;
+        $this->setPosition($iLineNo);
+        $this->aComments = [];
+    }
+
+    /**
+     * @param string|CSSString $oCharset
+     *
+     * @return void
+     */
+    public function setCharset($sCharset)
+    {
+        $sCharset = $sCharset instanceof CSSString ? $sCharset : new CSSString($sCharset);
+        $this->oCharset = $sCharset;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCharset()
+    {
+        return $this->oCharset->getString();
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return "{$oOutputFormat->comments($this)}@charset {$this->oCharset->render($oOutputFormat)};";
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleName()
+    {
+        return 'charset';
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleArgs()
+    {
+        return $this->oCharset;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function addComments(array $aComments)
+    {
+        $this->aComments = array_merge($this->aComments, $aComments);
+    }
+
+    /**
+     * @return array<array-key, Comment>
+     */
+    public function getComments()
+    {
+        return $this->aComments;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function setComments(array $aComments)
+    {
+        $this->aComments = $aComments;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Property/Import.php

@@ -0,0 +1,142 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Comment;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\URL;
+
+/**
+ * Class representing an `@import` rule.
+ */
+class Import implements AtRule, Positionable
+{
+    use Position;
+
+    /**
+     * @var URL
+     */
+    private $oLocation;
+
+    /**
+     * @var string
+     */
+    private $sMediaQuery;
+
+    /**
+     * @var array<array-key, Comment>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aComments;
+
+    /**
+     * @param URL $oLocation
+     * @param string $sMediaQuery
+     * @param int $iLineNo
+     */
+    public function __construct(URL $oLocation, $sMediaQuery, $iLineNo = 0)
+    {
+        $this->oLocation = $oLocation;
+        $this->sMediaQuery = $sMediaQuery;
+        $this->setPosition($iLineNo);
+        $this->aComments = [];
+    }
+
+    /**
+     * @param URL $oLocation
+     *
+     * @return void
+     */
+    public function setLocation($oLocation)
+    {
+        $this->oLocation = $oLocation;
+    }
+
+    /**
+     * @return URL
+     */
+    public function getLocation()
+    {
+        return $this->oLocation;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return $oOutputFormat->comments($this) . "@import " . $this->oLocation->render($oOutputFormat)
+            . ($this->sMediaQuery === null ? '' : ' ' . $this->sMediaQuery) . ';';
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleName()
+    {
+        return 'import';
+    }
+
+    /**
+     * @return array<int, URL|string>
+     */
+    public function atRuleArgs()
+    {
+        $aResult = [$this->oLocation];
+        if ($this->sMediaQuery) {
+            array_push($aResult, $this->sMediaQuery);
+        }
+        return $aResult;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function addComments(array $aComments)
+    {
+        $this->aComments = array_merge($this->aComments, $aComments);
+    }
+
+    /**
+     * @return array<array-key, Comment>
+     */
+    public function getComments()
+    {
+        return $this->aComments;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function setComments(array $aComments)
+    {
+        $this->aComments = $aComments;
+    }
+
+    /**
+     * @return string
+     */
+    public function getMediaQuery()
+    {
+        return $this->sMediaQuery;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Property/KeyframeSelector.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property;
+
+class KeyframeSelector extends Selector
+{
+    /**
+     * regexp for specificity calculations
+     *
+     * @var string
+     *
+     * @internal since 8.5.2
+     */
+    const SELECTOR_VALIDATION_RX = '/
+    ^(
+        (?:
+            [a-zA-Z0-9\x{00A0}-\x{FFFF}_^$|*="\'~\[\]()\-\s\.:#+>]* # any sequence of valid unescaped characters
+            (?:\\\\.)?                                              # a single escaped character
+            (?:([\'"]).*?(?<!\\\\)\2)?                              # a quoted text like [id="example"]
+        )*
+    )|
+    (\d+%)                                                          # keyframe animation progress percentage (e.g. 50%)
+    $
+    /ux';
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Property/Selector.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property;
+
+/**
+ * Class representing a single CSS selector. Selectors have to be split by the comma prior to being passed into this
+ * class.
+ */
+class Selector
+{
+    /**
+     * regexp for specificity calculations
+     *
+     * @var string
+     *
+     * @internal
+     */
+    const NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX = '/
+        (\.[\w]+)                   # classes
+        |
+        \[(\w+)                     # attributes
+        |
+        (\:(                        # pseudo classes
+            link|visited|active
+            |hover|focus
+            |lang
+            |target
+            |enabled|disabled|checked|indeterminate
+            |root
+            |nth-child|nth-last-child|nth-of-type|nth-last-of-type
+            |first-child|last-child|first-of-type|last-of-type
+            |only-child|only-of-type
+            |empty|contains
+        ))
+        /ix';
+
+    /**
+     * regexp for specificity calculations
+     *
+     * @var string
+     *
+     * @internal
+     */
+    const ELEMENTS_AND_PSEUDO_ELEMENTS_RX = '/
+        ((^|[\s\+\>\~]+)[\w]+   # elements
+        |
+        \:{1,2}(                # pseudo-elements
+            after|before|first-letter|first-line|selection
+        ))
+        /ix';
+
+    /**
+     * regexp for specificity calculations
+     *
+     * @var string
+     *
+     * @internal since 8.5.2
+     */
+    const SELECTOR_VALIDATION_RX = '/
+        ^(
+            (?:
+                [a-zA-Z0-9\x{00A0}-\x{FFFF}_^$|*="\'~\[\]()\-\s\.:#+>]* # any sequence of valid unescaped characters
+                (?:\\\\.)?                                              # a single escaped character
+                (?:([\'"]).*?(?<!\\\\)\2)?                              # a quoted text like [id="example"]
+            )*
+        )$
+        /ux';
+
+    /**
+     * @var string
+     */
+    private $sSelector;
+
+    /**
+     * @var int|null
+     */
+    private $iSpecificity;
+
+    /**
+     * @param string $sSelector
+     *
+     * @return bool
+     *
+     * @internal since V8.8.0
+     */
+    public static function isValid($sSelector)
+    {
+        return preg_match(static::SELECTOR_VALIDATION_RX, $sSelector);
+    }
+
+    /**
+     * @param string $sSelector
+     * @param bool $bCalculateSpecificity @deprecated since V8.8.0, will be removed in V9.0.0
+     */
+    public function __construct($sSelector, $bCalculateSpecificity = false)
+    {
+        $this->setSelector($sSelector);
+        if ($bCalculateSpecificity) {
+            $this->getSpecificity();
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getSelector()
+    {
+        return $this->sSelector;
+    }
+
+    /**
+     * @param string $sSelector
+     *
+     * @return void
+     */
+    public function setSelector($sSelector)
+    {
+        $this->sSelector = trim($sSelector);
+        $this->iSpecificity = null;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->getSelector();
+    }
+
+    /**
+     * @return int
+     */
+    public function getSpecificity()
+    {
+        if ($this->iSpecificity === null) {
+            $a = 0;
+            /// @todo should exclude \# as well as "#"
+            $aMatches = null;
+            $b = substr_count($this->sSelector, '#');
+            $c = preg_match_all(self::NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX, $this->sSelector, $aMatches);
+            $d = preg_match_all(self::ELEMENTS_AND_PSEUDO_ELEMENTS_RX, $this->sSelector, $aMatches);
+            $this->iSpecificity = ($a * 1000) + ($b * 100) + ($c * 10) + $d;
+        }
+        return $this->iSpecificity;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Renderable.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS;
+
+interface Renderable
+{
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString();
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat);
+
+    /**
+     * @return int
+     */
+    public function getLineNo();
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Rule/Rule.php

@@ -0,0 +1,383 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Rule;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Comment;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Commentable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSElement;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\RuleValueList;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\Value;
+
+/**
+ * `Rule`s just have a string key (the rule) and a 'Value'.
+ *
+ * In CSS, `Rule`s are expressed as follows: “key: value[0][0] value[0][1], value[1][0] value[1][1];”
+ */
+class Rule implements Commentable, CSSElement, Positionable
+{
+    use Position;
+
+    /**
+     * @var string
+     */
+    private $sRule;
+
+    /**
+     * @var RuleValueList|string|null
+     */
+    private $mValue;
+
+    /**
+     * @var bool
+     */
+    private $bIsImportant;
+
+    /**
+     * @var array<int, int>
+     */
+    private $aIeHack;
+
+    /**
+     * @var array<array-key, Comment>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aComments;
+
+    /**
+     * @param string $sRule
+     * @param int $iLineNo
+     * @param int $iColNo
+     */
+    public function __construct($sRule, $iLineNo = 0, $iColNo = 0)
+    {
+        $this->sRule = $sRule;
+        $this->mValue = null;
+        $this->bIsImportant = false;
+        $this->aIeHack = [];
+        $this->setPosition($iLineNo, $iColNo);
+        $this->aComments = [];
+    }
+
+    /**
+     * @param array<int, Comment> $commentsBeforeRule
+     *
+     * @return Rule
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState, $commentsBeforeRule = [])
+    {
+        $aComments = \array_merge($commentsBeforeRule, $oParserState->consumeWhiteSpace());
+        $oRule = new Rule(
+            $oParserState->parseIdentifier(!$oParserState->comes("--")),
+            $oParserState->currentLine(),
+            $oParserState->currentColumn()
+        );
+        $oRule->setComments($aComments);
+        $oRule->addComments($oParserState->consumeWhiteSpace());
+        $oParserState->consume(':');
+        $oValue = Value::parseValue($oParserState, self::listDelimiterForRule($oRule->getRule()));
+        $oRule->setValue($oValue);
+        if ($oParserState->getSettings()->bLenientParsing) {
+            while ($oParserState->comes('\\')) {
+                $oParserState->consume('\\');
+                $oRule->addIeHack($oParserState->consume());
+                $oParserState->consumeWhiteSpace();
+            }
+        }
+        $oParserState->consumeWhiteSpace();
+        if ($oParserState->comes('!')) {
+            $oParserState->consume('!');
+            $oParserState->consumeWhiteSpace();
+            $oParserState->consume('important');
+            $oRule->setIsImportant(true);
+        }
+        $oParserState->consumeWhiteSpace();
+        while ($oParserState->comes(';')) {
+            $oParserState->consume(';');
+        }
+
+        return $oRule;
+    }
+
+    /**
+     * Returns a list of delimiters (or separators).
+     * The first item is the innermost separator (or, put another way, the highest-precedence operator).
+     * The sequence continues to the outermost separator (or lowest-precedence operator).
+     *
+     * @param string $sRule
+     *
+     * @return list<non-empty-string>
+     */
+    private static function listDelimiterForRule($sRule)
+    {
+        if (preg_match('/^font($|-)/', $sRule)) {
+            return [',', '/', ' '];
+        }
+
+        switch ($sRule) {
+            case 'src':
+                return [' ', ','];
+            default:
+                return [',', ' ', '/'];
+        }
+    }
+
+    /**
+     * @param string $sRule
+     *
+     * @return void
+     */
+    public function setRule($sRule)
+    {
+        $this->sRule = $sRule;
+    }
+
+    /**
+     * @return string
+     */
+    public function getRule()
+    {
+        return $this->sRule;
+    }
+
+    /**
+     * @return RuleValueList|string|null
+     */
+    public function getValue()
+    {
+        return $this->mValue;
+    }
+
+    /**
+     * @param RuleValueList|string|null $mValue
+     *
+     * @return void
+     */
+    public function setValue($mValue)
+    {
+        $this->mValue = $mValue;
+    }
+
+    /**
+     * @param array<array-key, array<array-key, RuleValueList>> $aSpaceSeparatedValues
+     *
+     * @return RuleValueList
+     *
+     * @deprecated will be removed in version 9.0
+     *             Old-Style 2-dimensional array given. Retained for (some) backwards-compatibility.
+     *             Use `setValue()` instead and wrap the value inside a RuleValueList if necessary.
+     */
+    public function setValues(array $aSpaceSeparatedValues)
+    {
+        $oSpaceSeparatedList = null;
+        if (count($aSpaceSeparatedValues) > 1) {
+            $oSpaceSeparatedList = new RuleValueList(' ', $this->iLineNo);
+        }
+        foreach ($aSpaceSeparatedValues as $aCommaSeparatedValues) {
+            $oCommaSeparatedList = null;
+            if (count($aCommaSeparatedValues) > 1) {
+                $oCommaSeparatedList = new RuleValueList(',', $this->iLineNo);
+            }
+            foreach ($aCommaSeparatedValues as $mValue) {
+                if (!$oSpaceSeparatedList && !$oCommaSeparatedList) {
+                    $this->mValue = $mValue;
+                    return $mValue;
+                }
+                if ($oCommaSeparatedList) {
+                    $oCommaSeparatedList->addListComponent($mValue);
+                } else {
+                    $oSpaceSeparatedList->addListComponent($mValue);
+                }
+            }
+            if (!$oSpaceSeparatedList) {
+                $this->mValue = $oCommaSeparatedList;
+                return $oCommaSeparatedList;
+            } else {
+                $oSpaceSeparatedList->addListComponent($oCommaSeparatedList);
+            }
+        }
+        $this->mValue = $oSpaceSeparatedList;
+        return $oSpaceSeparatedList;
+    }
+
+    /**
+     * @return array<int, array<int, RuleValueList>>
+     *
+     * @deprecated will be removed in version 9.0
+     *             Old-Style 2-dimensional array returned. Retained for (some) backwards-compatibility.
+     *             Use `getValue()` instead and check for the existence of a (nested set of) ValueList object(s).
+     */
+    public function getValues()
+    {
+        if (!$this->mValue instanceof RuleValueList) {
+            return [[$this->mValue]];
+        }
+        if ($this->mValue->getListSeparator() === ',') {
+            return [$this->mValue->getListComponents()];
+        }
+        $aResult = [];
+        foreach ($this->mValue->getListComponents() as $mValue) {
+            if (!$mValue instanceof RuleValueList || $mValue->getListSeparator() !== ',') {
+                $aResult[] = [$mValue];
+                continue;
+            }
+            if ($this->mValue->getListSeparator() === ' ' || count($aResult) === 0) {
+                $aResult[] = [];
+            }
+            foreach ($mValue->getListComponents() as $mValue) {
+                $aResult[count($aResult) - 1][] = $mValue;
+            }
+        }
+        return $aResult;
+    }
+
+    /**
+     * Adds a value to the existing value. Value will be appended if a `RuleValueList` exists of the given type.
+     * Otherwise, the existing value will be wrapped by one.
+     *
+     * @param RuleValueList|array<int, RuleValueList> $mValue
+     * @param string $sType
+     *
+     * @return void
+     */
+    public function addValue($mValue, $sType = ' ')
+    {
+        if (!is_array($mValue)) {
+            $mValue = [$mValue];
+        }
+        if (!$this->mValue instanceof RuleValueList || $this->mValue->getListSeparator() !== $sType) {
+            $mCurrentValue = $this->mValue;
+            $this->mValue = new RuleValueList($sType, $this->getLineNumber());
+            if ($mCurrentValue) {
+                $this->mValue->addListComponent($mCurrentValue);
+            }
+        }
+        foreach ($mValue as $mValueItem) {
+            $this->mValue->addListComponent($mValueItem);
+        }
+    }
+
+    /**
+     * @param int $iModifier
+     *
+     * @return void
+     *
+     * @deprecated since V8.8.0, will be removed in V9.0
+     */
+    public function addIeHack($iModifier)
+    {
+        $this->aIeHack[] = $iModifier;
+    }
+
+    /**
+     * @param array<int, int> $aModifiers
+     *
+     * @return void
+     *
+     * @deprecated since V8.8.0, will be removed in V9.0
+     */
+    public function setIeHack(array $aModifiers)
+    {
+        $this->aIeHack = $aModifiers;
+    }
+
+    /**
+     * @return array<int, int>
+     *
+     * @deprecated since V8.8.0, will be removed in V9.0
+     */
+    public function getIeHack()
+    {
+        return $this->aIeHack;
+    }
+
+    /**
+     * @param bool $bIsImportant
+     *
+     * @return void
+     */
+    public function setIsImportant($bIsImportant)
+    {
+        $this->bIsImportant = $bIsImportant;
+    }
+
+    /**
+     * @return bool
+     */
+    public function getIsImportant()
+    {
+        return $this->bIsImportant;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        $sResult = "{$oOutputFormat->comments($this)}{$this->sRule}:{$oOutputFormat->spaceAfterRuleName()}";
+        if ($this->mValue instanceof Value) { // Can also be a ValueList
+            $sResult .= $this->mValue->render($oOutputFormat);
+        } else {
+            $sResult .= $this->mValue;
+        }
+        if (!empty($this->aIeHack)) {
+            $sResult .= ' \\' . implode('\\', $this->aIeHack);
+        }
+        if ($this->bIsImportant) {
+            $sResult .= ' !important';
+        }
+        $sResult .= ';';
+        return $sResult;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function addComments(array $aComments)
+    {
+        $this->aComments = array_merge($this->aComments, $aComments);
+    }
+
+    /**
+     * @return array<array-key, Comment>
+     */
+    public function getComments()
+    {
+        return $this->aComments;
+    }
+
+    /**
+     * @param array<array-key, Comment> $aComments
+     *
+     * @return void
+     */
+    public function setComments(array $aComments)
+    {
+        $this->aComments = $aComments;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/RuleSet/AtRuleSet.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\AtRule;
+
+/**
+ * This class represents rule sets for generic at-rules which are not covered by specific classes, i.e., not
+ * `@import`, `@charset` or `@media`.
+ *
+ * A common example for this is `@font-face`.
+ */
+class AtRuleSet extends RuleSet implements AtRule
+{
+    /**
+     * @var string
+     */
+    private $sType;
+
+    /**
+     * @var string
+     */
+    private $sArgs;
+
+    /**
+     * @param string $sType
+     * @param string $sArgs
+     * @param int $iLineNo
+     */
+    public function __construct($sType, $sArgs = '', $iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+        $this->sType = $sType;
+        $this->sArgs = $sArgs;
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleName()
+    {
+        return $this->sType;
+    }
+
+    /**
+     * @return string
+     */
+    public function atRuleArgs()
+    {
+        return $this->sArgs;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        $sResult = $oOutputFormat->comments($this);
+        $sArgs = $this->sArgs;
+        if ($sArgs) {
+            $sArgs = ' ' . $sArgs;
+        }
+        $sResult .= "@{$this->sType}$sArgs{$oOutputFormat->spaceBeforeOpeningBrace()}{";
+        $sResult .= $this->renderRules($oOutputFormat);
+        $sResult .= '}';
+        return $sResult;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/RuleSet/DeclarationBlock.php

@@ -0,0 +1,871 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList\CSSList;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSList\KeyFrame;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\OutputException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\KeyframeSelector;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Property\Selector;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Rule\Rule;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\Color;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\RuleValueList;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\Size;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\URL;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value\Value;
+
+/**
+ * This class represents a `RuleSet` constrained by a `Selector`.
+ *
+ * It contains an array of selector objects (comma-separated in the CSS) as well as the rules to be applied to the
+ * matching elements.
+ *
+ * Declaration blocks usually appear directly inside a `Document` or another `CSSList` (mostly a `MediaQuery`).
+ */
+class DeclarationBlock extends RuleSet
+{
+    /**
+     * @var array<int, Selector|string>
+     */
+    private $aSelectors;
+
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+        $this->aSelectors = [];
+    }
+
+    /**
+     * @param CSSList|null $oList
+     *
+     * @return DeclarationBlock|false
+     *
+     * @throws UnexpectedTokenException
+     * @throws UnexpectedEOFException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState, $oList = null)
+    {
+        $aComments = [];
+        $oResult = new DeclarationBlock($oParserState->currentLine());
+        try {
+            $aSelectorParts = [];
+            $sStringWrapperChar = false;
+            do {
+                $aSelectorParts[] = $oParserState->consume(1)
+                    . $oParserState->consumeUntil(['{', '}', '\'', '"'], false, false, $aComments);
+                if (in_array($oParserState->peek(), ['\'', '"']) && substr(end($aSelectorParts), -1) != "\\") {
+                    if ($sStringWrapperChar === false) {
+                        $sStringWrapperChar = $oParserState->peek();
+                    } elseif ($sStringWrapperChar == $oParserState->peek()) {
+                        $sStringWrapperChar = false;
+                    }
+                }
+            } while (!in_array($oParserState->peek(), ['{', '}']) || $sStringWrapperChar !== false);
+            $oResult->setSelectors(implode('', $aSelectorParts), $oList);
+            if ($oParserState->comes('{')) {
+                $oParserState->consume(1);
+            }
+        } catch (UnexpectedTokenException $e) {
+            if ($oParserState->getSettings()->bLenientParsing) {
+                if (!$oParserState->comes('}')) {
+                    $oParserState->consumeUntil('}', false, true);
+                }
+                return false;
+            } else {
+                throw $e;
+            }
+        }
+        $oResult->setComments($aComments);
+        RuleSet::parseRuleSet($oParserState, $oResult);
+        return $oResult;
+    }
+
+    /**
+     * @param array<int, Selector|string>|string $mSelector
+     * @param CSSList|null $oList
+     *
+     * @throws UnexpectedTokenException
+     */
+    public function setSelectors($mSelector, $oList = null)
+    {
+        if (is_array($mSelector)) {
+            $this->aSelectors = $mSelector;
+        } else {
+            $this->aSelectors = explode(',', $mSelector);
+        }
+        foreach ($this->aSelectors as $iKey => $mSelector) {
+            if (!($mSelector instanceof Selector)) {
+                if ($oList === null || !($oList instanceof KeyFrame)) {
+                    if (!Selector::isValid($mSelector)) {
+                        throw new UnexpectedTokenException(
+                            "Selector did not match '" . Selector::SELECTOR_VALIDATION_RX . "'.",
+                            $mSelector,
+                            "custom"
+                        );
+                    }
+                    $this->aSelectors[$iKey] = new Selector($mSelector);
+                } else {
+                    if (!KeyframeSelector::isValid($mSelector)) {
+                        throw new UnexpectedTokenException(
+                            "Selector did not match '" . KeyframeSelector::SELECTOR_VALIDATION_RX . "'.",
+                            $mSelector,
+                            "custom"
+                        );
+                    }
+                    $this->aSelectors[$iKey] = new KeyframeSelector($mSelector);
+                }
+            }
+        }
+    }
+
+    /**
+     * Remove one of the selectors of the block.
+     *
+     * @param Selector|string $mSelector
+     *
+     * @return bool
+     */
+    public function removeSelector($mSelector)
+    {
+        if ($mSelector instanceof Selector) {
+            $mSelector = $mSelector->getSelector();
+        }
+        foreach ($this->aSelectors as $iKey => $oSelector) {
+            if ($oSelector->getSelector() === $mSelector) {
+                unset($this->aSelectors[$iKey]);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @return array<int, Selector|string>
+     *
+     * @deprecated will be removed in version 9.0; use `getSelectors()` instead
+     */
+    public function getSelector()
+    {
+        return $this->getSelectors();
+    }
+
+    /**
+     * @param Selector|string $mSelector
+     * @param CSSList|null $oList
+     *
+     * @return void
+     *
+     * @deprecated will be removed in version 9.0; use `setSelectors()` instead
+     */
+    public function setSelector($mSelector, $oList = null)
+    {
+        $this->setSelectors($mSelector, $oList);
+    }
+
+    /**
+     * @return array<int, Selector|string>
+     */
+    public function getSelectors()
+    {
+        return $this->aSelectors;
+    }
+
+    /**
+     * Splits shorthand declarations (e.g. `margin` or `font`) into their constituent parts.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function expandShorthands()
+    {
+        // border must be expanded before dimensions
+        $this->expandBorderShorthand();
+        $this->expandDimensionsShorthand();
+        $this->expandFontShorthand();
+        $this->expandBackgroundShorthand();
+        $this->expandListStyleShorthand();
+    }
+
+    /**
+     * Creates shorthand declarations (e.g. `margin` or `font`) whenever possible.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createShorthands()
+    {
+        $this->createBackgroundShorthand();
+        $this->createDimensionsShorthand();
+        // border must be shortened after dimensions
+        $this->createBorderShorthand();
+        $this->createFontShorthand();
+        $this->createListStyleShorthand();
+    }
+
+    /**
+     * Splits shorthand border declarations (e.g. `border: 1px red;`).
+     *
+     * Additional splitting happens in expandDimensionsShorthand.
+     *
+     * Multiple borders are not yet supported as of 3.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function expandBorderShorthand()
+    {
+        $aBorderRules = [
+            'border',
+            'border-left',
+            'border-right',
+            'border-top',
+            'border-bottom',
+        ];
+        $aBorderSizes = [
+            'thin',
+            'medium',
+            'thick',
+        ];
+        $aRules = $this->getRulesAssoc();
+        foreach ($aBorderRules as $sBorderRule) {
+            if (!isset($aRules[$sBorderRule])) {
+                continue;
+            }
+            $oRule = $aRules[$sBorderRule];
+            $mRuleValue = $oRule->getValue();
+            $aValues = [];
+            if (!$mRuleValue instanceof RuleValueList) {
+                $aValues[] = $mRuleValue;
+            } else {
+                $aValues = $mRuleValue->getListComponents();
+            }
+            foreach ($aValues as $mValue) {
+                if ($mValue instanceof Value) {
+                    $mNewValue = clone $mValue;
+                } else {
+                    $mNewValue = $mValue;
+                }
+                if ($mValue instanceof Size) {
+                    $sNewRuleName = $sBorderRule . "-width";
+                } elseif ($mValue instanceof Color) {
+                    $sNewRuleName = $sBorderRule . "-color";
+                } else {
+                    if (in_array($mValue, $aBorderSizes)) {
+                        $sNewRuleName = $sBorderRule . "-width";
+                    } else {
+                        $sNewRuleName = $sBorderRule . "-style";
+                    }
+                }
+                $oNewRule = new Rule($sNewRuleName, $oRule->getLineNo(), $oRule->getColNo());
+                $oNewRule->setIsImportant($oRule->getIsImportant());
+                $oNewRule->addValue([$mNewValue]);
+                $this->addRule($oNewRule);
+            }
+            $this->removeRule($sBorderRule);
+        }
+    }
+
+    /**
+     * Splits shorthand dimensional declarations (e.g. `margin: 0px auto;`)
+     * into their constituent parts.
+     *
+     * Handles `margin`, `padding`, `border-color`, `border-style` and `border-width`.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function expandDimensionsShorthand()
+    {
+        $aExpansions = [
+            'margin' => 'margin-%s',
+            'padding' => 'padding-%s',
+            'border-color' => 'border-%s-color',
+            'border-style' => 'border-%s-style',
+            'border-width' => 'border-%s-width',
+        ];
+        $aRules = $this->getRulesAssoc();
+        foreach ($aExpansions as $sProperty => $sExpanded) {
+            if (!isset($aRules[$sProperty])) {
+                continue;
+            }
+            $oRule = $aRules[$sProperty];
+            $mRuleValue = $oRule->getValue();
+            $aValues = [];
+            if (!$mRuleValue instanceof RuleValueList) {
+                $aValues[] = $mRuleValue;
+            } else {
+                $aValues = $mRuleValue->getListComponents();
+            }
+            $top = $right = $bottom = $left = null;
+            switch (count($aValues)) {
+                case 1:
+                    $top = $right = $bottom = $left = $aValues[0];
+                    break;
+                case 2:
+                    $top = $bottom = $aValues[0];
+                    $left = $right = $aValues[1];
+                    break;
+                case 3:
+                    $top = $aValues[0];
+                    $left = $right = $aValues[1];
+                    $bottom = $aValues[2];
+                    break;
+                case 4:
+                    $top = $aValues[0];
+                    $right = $aValues[1];
+                    $bottom = $aValues[2];
+                    $left = $aValues[3];
+                    break;
+            }
+            foreach (['top', 'right', 'bottom', 'left'] as $sPosition) {
+                $oNewRule = new Rule(sprintf($sExpanded, $sPosition), $oRule->getLineNo(), $oRule->getColNo());
+                $oNewRule->setIsImportant($oRule->getIsImportant());
+                $oNewRule->addValue(${$sPosition});
+                $this->addRule($oNewRule);
+            }
+            $this->removeRule($sProperty);
+        }
+    }
+
+    /**
+     * Converts shorthand font declarations
+     * (e.g. `font: 300 italic 11px/14px verdana, helvetica, sans-serif;`)
+     * into their constituent parts.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function expandFontShorthand()
+    {
+        $aRules = $this->getRulesAssoc();
+        if (!isset($aRules['font'])) {
+            return;
+        }
+        $oRule = $aRules['font'];
+        // reset properties to 'normal' per http://www.w3.org/TR/21/fonts.html#font-shorthand
+        $aFontProperties = [
+            'font-style' => 'normal',
+            'font-variant' => 'normal',
+            'font-weight' => 'normal',
+            'font-size' => 'normal',
+            'line-height' => 'normal',
+        ];
+        $mRuleValue = $oRule->getValue();
+        $aValues = [];
+        if (!$mRuleValue instanceof RuleValueList) {
+            $aValues[] = $mRuleValue;
+        } else {
+            $aValues = $mRuleValue->getListComponents();
+        }
+        foreach ($aValues as $mValue) {
+            if (!$mValue instanceof Value) {
+                $mValue = mb_strtolower($mValue);
+            }
+            if (in_array($mValue, ['normal', 'inherit'])) {
+                foreach (['font-style', 'font-weight', 'font-variant'] as $sProperty) {
+                    if (!isset($aFontProperties[$sProperty])) {
+                        $aFontProperties[$sProperty] = $mValue;
+                    }
+                }
+            } elseif (in_array($mValue, ['italic', 'oblique'])) {
+                $aFontProperties['font-style'] = $mValue;
+            } elseif ($mValue == 'small-caps') {
+                $aFontProperties['font-variant'] = $mValue;
+            } elseif (
+                in_array($mValue, ['bold', 'bolder', 'lighter'])
+                || ($mValue instanceof Size
+                    && in_array($mValue->getSize(), range(100, 900, 100)))
+            ) {
+                $aFontProperties['font-weight'] = $mValue;
+            } elseif ($mValue instanceof RuleValueList && $mValue->getListSeparator() == '/') {
+                list($oSize, $oHeight) = $mValue->getListComponents();
+                $aFontProperties['font-size'] = $oSize;
+                $aFontProperties['line-height'] = $oHeight;
+            } elseif ($mValue instanceof Size && $mValue->getUnit() !== null) {
+                $aFontProperties['font-size'] = $mValue;
+            } else {
+                $aFontProperties['font-family'] = $mValue;
+            }
+        }
+        foreach ($aFontProperties as $sProperty => $mValue) {
+            $oNewRule = new Rule($sProperty, $oRule->getLineNo(), $oRule->getColNo());
+            $oNewRule->addValue($mValue);
+            $oNewRule->setIsImportant($oRule->getIsImportant());
+            $this->addRule($oNewRule);
+        }
+        $this->removeRule('font');
+    }
+
+    /**
+     * Converts shorthand background declarations
+     * (e.g. `background: url("chess.png") gray 50% repeat fixed;`)
+     * into their constituent parts.
+     *
+     * @see http://www.w3.org/TR/21/colors.html#propdef-background
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function expandBackgroundShorthand()
+    {
+        $aRules = $this->getRulesAssoc();
+        if (!isset($aRules['background'])) {
+            return;
+        }
+        $oRule = $aRules['background'];
+        $aBgProperties = [
+            'background-color' => ['transparent'],
+            'background-image' => ['none'],
+            'background-repeat' => ['repeat'],
+            'background-attachment' => ['scroll'],
+            'background-position' => [
+                new Size(0, '%', false, $this->getLineNo()),
+                new Size(0, '%', false, $this->getLineNo()),
+            ],
+        ];
+        $mRuleValue = $oRule->getValue();
+        $aValues = [];
+        if (!$mRuleValue instanceof RuleValueList) {
+            $aValues[] = $mRuleValue;
+        } else {
+            $aValues = $mRuleValue->getListComponents();
+        }
+        if (count($aValues) == 1 && $aValues[0] == 'inherit') {
+            foreach ($aBgProperties as $sProperty => $mValue) {
+                $oNewRule = new Rule($sProperty, $oRule->getLineNo(), $oRule->getColNo());
+                $oNewRule->addValue('inherit');
+                $oNewRule->setIsImportant($oRule->getIsImportant());
+                $this->addRule($oNewRule);
+            }
+            $this->removeRule('background');
+            return;
+        }
+        $iNumBgPos = 0;
+        foreach ($aValues as $mValue) {
+            if (!$mValue instanceof Value) {
+                $mValue = mb_strtolower($mValue);
+            }
+            if ($mValue instanceof URL) {
+                $aBgProperties['background-image'] = $mValue;
+            } elseif ($mValue instanceof Color) {
+                $aBgProperties['background-color'] = $mValue;
+            } elseif (in_array($mValue, ['scroll', 'fixed'])) {
+                $aBgProperties['background-attachment'] = $mValue;
+            } elseif (in_array($mValue, ['repeat', 'no-repeat', 'repeat-x', 'repeat-y'])) {
+                $aBgProperties['background-repeat'] = $mValue;
+            } elseif (
+                in_array($mValue, ['left', 'center', 'right', 'top', 'bottom'])
+                || $mValue instanceof Size
+            ) {
+                if ($iNumBgPos == 0) {
+                    $aBgProperties['background-position'][0] = $mValue;
+                    $aBgProperties['background-position'][1] = 'center';
+                } else {
+                    $aBgProperties['background-position'][$iNumBgPos] = $mValue;
+                }
+                $iNumBgPos++;
+            }
+        }
+        foreach ($aBgProperties as $sProperty => $mValue) {
+            $oNewRule = new Rule($sProperty, $oRule->getLineNo(), $oRule->getColNo());
+            $oNewRule->setIsImportant($oRule->getIsImportant());
+            $oNewRule->addValue($mValue);
+            $this->addRule($oNewRule);
+        }
+        $this->removeRule('background');
+    }
+
+    /**
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function expandListStyleShorthand()
+    {
+        $aListProperties = [
+            'list-style-type' => 'disc',
+            'list-style-position' => 'outside',
+            'list-style-image' => 'none',
+        ];
+        $aListStyleTypes = [
+            'none',
+            'disc',
+            'circle',
+            'square',
+            'decimal-leading-zero',
+            'decimal',
+            'lower-roman',
+            'upper-roman',
+            'lower-greek',
+            'lower-alpha',
+            'lower-latin',
+            'upper-alpha',
+            'upper-latin',
+            'hebrew',
+            'armenian',
+            'georgian',
+            'cjk-ideographic',
+            'hiragana',
+            'hira-gana-iroha',
+            'katakana-iroha',
+            'katakana',
+        ];
+        $aListStylePositions = [
+            'inside',
+            'outside',
+        ];
+        $aRules = $this->getRulesAssoc();
+        if (!isset($aRules['list-style'])) {
+            return;
+        }
+        $oRule = $aRules['list-style'];
+        $mRuleValue = $oRule->getValue();
+        $aValues = [];
+        if (!$mRuleValue instanceof RuleValueList) {
+            $aValues[] = $mRuleValue;
+        } else {
+            $aValues = $mRuleValue->getListComponents();
+        }
+        if (count($aValues) == 1 && $aValues[0] == 'inherit') {
+            foreach ($aListProperties as $sProperty => $mValue) {
+                $oNewRule = new Rule($sProperty, $oRule->getLineNo(), $oRule->getColNo());
+                $oNewRule->addValue('inherit');
+                $oNewRule->setIsImportant($oRule->getIsImportant());
+                $this->addRule($oNewRule);
+            }
+            $this->removeRule('list-style');
+            return;
+        }
+        foreach ($aValues as $mValue) {
+            if (!$mValue instanceof Value) {
+                $mValue = mb_strtolower($mValue);
+            }
+            if ($mValue instanceof Url) {
+                $aListProperties['list-style-image'] = $mValue;
+            } elseif (in_array($mValue, $aListStyleTypes)) {
+                $aListProperties['list-style-types'] = $mValue;
+            } elseif (in_array($mValue, $aListStylePositions)) {
+                $aListProperties['list-style-position'] = $mValue;
+            }
+        }
+        foreach ($aListProperties as $sProperty => $mValue) {
+            $oNewRule = new Rule($sProperty, $oRule->getLineNo(), $oRule->getColNo());
+            $oNewRule->setIsImportant($oRule->getIsImportant());
+            $oNewRule->addValue($mValue);
+            $this->addRule($oNewRule);
+        }
+        $this->removeRule('list-style');
+    }
+
+    /**
+     * @param array<array-key, string> $aProperties
+     * @param string $sShorthand
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createShorthandProperties(array $aProperties, $sShorthand)
+    {
+        $aRules = $this->getRulesAssoc();
+        $oRule = null;
+        $aNewValues = [];
+        foreach ($aProperties as $sProperty) {
+            if (!isset($aRules[$sProperty])) {
+                continue;
+            }
+            $oRule = $aRules[$sProperty];
+            if (!$oRule->getIsImportant()) {
+                $mRuleValue = $oRule->getValue();
+                $aValues = [];
+                if (!$mRuleValue instanceof RuleValueList) {
+                    $aValues[] = $mRuleValue;
+                } else {
+                    $aValues = $mRuleValue->getListComponents();
+                }
+                foreach ($aValues as $mValue) {
+                    $aNewValues[] = $mValue;
+                }
+                $this->removeRule($sProperty);
+            }
+        }
+        if ($aNewValues !== [] && $oRule instanceof Rule) {
+            $oNewRule = new Rule($sShorthand, $oRule->getLineNo(), $oRule->getColNo());
+            foreach ($aNewValues as $mValue) {
+                $oNewRule->addValue($mValue);
+            }
+            $this->addRule($oNewRule);
+        }
+    }
+
+    /**
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createBackgroundShorthand()
+    {
+        $aProperties = [
+            'background-color',
+            'background-image',
+            'background-repeat',
+            'background-position',
+            'background-attachment',
+        ];
+        $this->createShorthandProperties($aProperties, 'background');
+    }
+
+    /**
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createListStyleShorthand()
+    {
+        $aProperties = [
+            'list-style-type',
+            'list-style-position',
+            'list-style-image',
+        ];
+        $this->createShorthandProperties($aProperties, 'list-style');
+    }
+
+    /**
+     * Combines `border-color`, `border-style` and `border-width` into `border`.
+     *
+     * Should be run after `create_dimensions_shorthand`!
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createBorderShorthand()
+    {
+        $aProperties = [
+            'border-width',
+            'border-style',
+            'border-color',
+        ];
+        $this->createShorthandProperties($aProperties, 'border');
+    }
+
+    /**
+     * Looks for long format CSS dimensional properties
+     * (margin, padding, border-color, border-style and border-width)
+     * and converts them into shorthand CSS properties.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createDimensionsShorthand()
+    {
+        $aPositions = ['top', 'right', 'bottom', 'left'];
+        $aExpansions = [
+            'margin' => 'margin-%s',
+            'padding' => 'padding-%s',
+            'border-color' => 'border-%s-color',
+            'border-style' => 'border-%s-style',
+            'border-width' => 'border-%s-width',
+        ];
+        $aRules = $this->getRulesAssoc();
+        foreach ($aExpansions as $sProperty => $sExpanded) {
+            $aFoldable = [];
+            foreach ($aRules as $sRuleName => $oRule) {
+                foreach ($aPositions as $sPosition) {
+                    if ($sRuleName == sprintf($sExpanded, $sPosition)) {
+                        $aFoldable[$sRuleName] = $oRule;
+                    }
+                }
+            }
+            // All four dimensions must be present
+            if (count($aFoldable) == 4) {
+                $aValues = [];
+                foreach ($aPositions as $sPosition) {
+                    $oRule = $aRules[sprintf($sExpanded, $sPosition)];
+                    $mRuleValue = $oRule->getValue();
+                    $aRuleValues = [];
+                    if (!$mRuleValue instanceof RuleValueList) {
+                        $aRuleValues[] = $mRuleValue;
+                    } else {
+                        $aRuleValues = $mRuleValue->getListComponents();
+                    }
+                    $aValues[$sPosition] = $aRuleValues;
+                }
+                $oNewRule = new Rule($sProperty, $oRule->getLineNo(), $oRule->getColNo());
+                if ((string)$aValues['left'][0] == (string)$aValues['right'][0]) {
+                    if ((string)$aValues['top'][0] == (string)$aValues['bottom'][0]) {
+                        if ((string)$aValues['top'][0] == (string)$aValues['left'][0]) {
+                            // All 4 sides are equal
+                            $oNewRule->addValue($aValues['top']);
+                        } else {
+                            // Top and bottom are equal, left and right are equal
+                            $oNewRule->addValue($aValues['top']);
+                            $oNewRule->addValue($aValues['left']);
+                        }
+                    } else {
+                        // Only left and right are equal
+                        $oNewRule->addValue($aValues['top']);
+                        $oNewRule->addValue($aValues['left']);
+                        $oNewRule->addValue($aValues['bottom']);
+                    }
+                } else {
+                    // No sides are equal
+                    $oNewRule->addValue($aValues['top']);
+                    $oNewRule->addValue($aValues['left']);
+                    $oNewRule->addValue($aValues['bottom']);
+                    $oNewRule->addValue($aValues['right']);
+                }
+                $this->addRule($oNewRule);
+                foreach ($aPositions as $sPosition) {
+                    $this->removeRule(sprintf($sExpanded, $sPosition));
+                }
+            }
+        }
+    }
+
+    /**
+     * Looks for long format CSS font properties (e.g. `font-weight`) and
+     * tries to convert them into a shorthand CSS `font` property.
+     *
+     * At least `font-size` AND `font-family` must be present in order to create a shorthand declaration.
+     *
+     * @return void
+     *
+     * @deprecated since 8.7.0, will be removed without substitution in version 9.0 in #511
+     */
+    public function createFontShorthand()
+    {
+        $aFontProperties = [
+            'font-style',
+            'font-variant',
+            'font-weight',
+            'font-size',
+            'line-height',
+            'font-family',
+        ];
+        $aRules = $this->getRulesAssoc();
+        if (!isset($aRules['font-size']) || !isset($aRules['font-family'])) {
+            return;
+        }
+        $oOldRule = isset($aRules['font-size']) ? $aRules['font-size'] : $aRules['font-family'];
+        $oNewRule = new Rule('font', $oOldRule->getLineNo(), $oOldRule->getColNo());
+        unset($oOldRule);
+        foreach (['font-style', 'font-variant', 'font-weight'] as $sProperty) {
+            if (isset($aRules[$sProperty])) {
+                $oRule = $aRules[$sProperty];
+                $mRuleValue = $oRule->getValue();
+                $aValues = [];
+                if (!$mRuleValue instanceof RuleValueList) {
+                    $aValues[] = $mRuleValue;
+                } else {
+                    $aValues = $mRuleValue->getListComponents();
+                }
+                if ($aValues[0] !== 'normal') {
+                    $oNewRule->addValue($aValues[0]);
+                }
+            }
+        }
+        // Get the font-size value
+        $oRule = $aRules['font-size'];
+        $mRuleValue = $oRule->getValue();
+        $aFSValues = [];
+        if (!$mRuleValue instanceof RuleValueList) {
+            $aFSValues[] = $mRuleValue;
+        } else {
+            $aFSValues = $mRuleValue->getListComponents();
+        }
+        // But wait to know if we have line-height to add it
+        if (isset($aRules['line-height'])) {
+            $oRule = $aRules['line-height'];
+            $mRuleValue = $oRule->getValue();
+            $aLHValues = [];
+            if (!$mRuleValue instanceof RuleValueList) {
+                $aLHValues[] = $mRuleValue;
+            } else {
+                $aLHValues = $mRuleValue->getListComponents();
+            }
+            if ($aLHValues[0] !== 'normal') {
+                $val = new RuleValueList('/', $this->getLineNo());
+                $val->addListComponent($aFSValues[0]);
+                $val->addListComponent($aLHValues[0]);
+                $oNewRule->addValue($val);
+            }
+        } else {
+            $oNewRule->addValue($aFSValues[0]);
+        }
+        $oRule = $aRules['font-family'];
+        $mRuleValue = $oRule->getValue();
+        $aFFValues = [];
+        if (!$mRuleValue instanceof RuleValueList) {
+            $aFFValues[] = $mRuleValue;
+        } else {
+            $aFFValues = $mRuleValue->getListComponents();
+        }
+        $oFFValue = new RuleValueList(',', $this->getLineNo());
+        $oFFValue->setListComponents($aFFValues);
+        $oNewRule->addValue($oFFValue);
+
+        $this->addRule($oNewRule);
+        foreach ($aFontProperties as $sProperty) {
+            $this->removeRule($sProperty);
+        }
+    }
+
+    /**
+     * @return string
+     *
+     * @throws OutputException
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     *
+     * @throws OutputException
+     */
+    public function render($oOutputFormat)
+    {
+        $sResult = $oOutputFormat->comments($this);
+        if (count($this->aSelectors) === 0) {
+            // If all the selectors have been removed, this declaration block becomes invalid
+            throw new OutputException(
+                'Attempt to print declaration block with missing selector',
+                $this->getLineNumber()
+            );
+        }
+        $sResult .= $oOutputFormat->sBeforeDeclarationBlock;
+        $sResult .= $oOutputFormat->implode(
+            $oOutputFormat->spaceBeforeSelectorSeparator() . ',' . $oOutputFormat->spaceAfterSelectorSeparator(),
+            $this->aSelectors
+        );
+        $sResult .= $oOutputFormat->sAfterDeclarationBlockSelectors;
+        $sResult .= $oOutputFormat->spaceBeforeOpeningBrace() . '{';
+        $sResult .= $this->renderRules($oOutputFormat);
+        $sResult .= '}';
+        $sResult .= $oOutputFormat->sAfterDeclarationBlock;
+        return $sResult;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/RuleSet/RuleSet.php

@@ -0,0 +1,357 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\RuleSet;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Comment;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Comment\Commentable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSElement;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Renderable;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Rule\Rule;
+
+/**
+ * This class is a container for individual 'Rule's.
+ *
+ * The most common form of a rule set is one constrained by a selector, i.e., a `DeclarationBlock`.
+ * However, unknown `AtRule`s (like `@font-face`) are rule sets as well.
+ *
+ * If you want to manipulate a `RuleSet`, use the methods `addRule(Rule $rule)`, `getRules()` and `removeRule($rule)`
+ * (which accepts either a `Rule` or a rule name; optionally suffixed by a dash to remove all related rules).
+ */
+abstract class RuleSet implements CSSElement, Commentable, Positionable
+{
+    use Position;
+
+    /**
+     * the rules in this rule set, using the property name as the key,
+     * with potentially multiple rules per property name.
+     *
+     * @var array<string, array<int<0, max>, Rule>>
+     */
+    private $aRules;
+
+    /**
+     * @var array<array-key, Comment>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aComments;
+
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        $this->aRules = [];
+        $this->setPosition($iLineNo);
+        $this->aComments = [];
+    }
+
+    /**
+     * @return void
+     *
+     * @throws UnexpectedTokenException
+     * @throws UnexpectedEOFException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parseRuleSet(ParserState $oParserState, RuleSet $oRuleSet)
+    {
+        while ($oParserState->comes(';')) {
+            $oParserState->consume(';');
+        }
+        while (true) {
+            $commentsBeforeRule = $oParserState->consumeWhiteSpace();
+            if ($oParserState->comes('}')) {
+                break;
+            }
+            $oRule = null;
+            if ($oParserState->getSettings()->bLenientParsing) {
+                try {
+                    $oRule = Rule::parse($oParserState, $commentsBeforeRule);
+                } catch (UnexpectedTokenException $e) {
+                    try {
+                        $sConsume = $oParserState->consumeUntil(["\n", ";", '}'], true);
+                        // We need to “unfind” the matches to the end of the ruleSet as this will be matched later
+                        if ($oParserState->streql(substr($sConsume, -1), '}')) {
+                            $oParserState->backtrack(1);
+                        } else {
+                            while ($oParserState->comes(';')) {
+                                $oParserState->consume(';');
+                            }
+                        }
+                    } catch (UnexpectedTokenException $e) {
+                        // We’ve reached the end of the document. Just close the RuleSet.
+                        return;
+                    }
+                }
+            } else {
+                $oRule = Rule::parse($oParserState, $commentsBeforeRule);
+            }
+            if ($oRule) {
+                $oRuleSet->addRule($oRule);
+            }
+        }
+        $oParserState->consume('}');
+    }
+
+    /**
+     * @param Rule|null $oSibling
+     *
+     * @return void
+     */
+    public function addRule(Rule $oRule, $oSibling = null)
+    {
+        $sRule = $oRule->getRule();
+        if (!isset($this->aRules[$sRule])) {
+            $this->aRules[$sRule] = [];
+        }
+
+        $iPosition = count($this->aRules[$sRule]);
+
+        if ($oSibling !== null) {
+            $iSiblingPos = array_search($oSibling, $this->aRules[$sRule], true);
+            if ($iSiblingPos !== false) {
+                $iPosition = $iSiblingPos;
+                $oRule->setPosition($oSibling->getLineNo(), $oSibling->getColNo() - 1);
+            }
+        }
+        if ($oRule->getLineNumber() === null) {
+            //this node is added manually, give it the next best line
+            $columnNumber = $oRule->getColNo();
+            $rules = $this->getRules();
+            $pos = count($rules);
+            if ($pos > 0) {
+                $last = $rules[$pos - 1];
+                $oRule->setPosition($last->getLineNo() + 1, $columnNumber);
+            } else {
+                $oRule->setPosition(1, $columnNumber);
+            }
+        } elseif ($oRule->getColumnNumber() === null) {
+            $oRule->setPosition($oRule->getLineNumber(), 0);
+        }
+
+        array_splice($this->aRules[$sRule], $iPosition, 0, [$oRule]);
+    }
+
+    /**
+     * Returns all rules matching the given rule name
+     *
+     * @example $oRuleSet->getRules('font') // returns array(0 => $oRule, …) or array().
+     *
+     * @example $oRuleSet->getRules('font-')
+     *          //returns an array of all rules either beginning with font- or matching font.
+     *
+     * @param Rule|string|null $mRule
+     *        Pattern to search for. If null, returns all rules.
+     *        If the pattern ends with a dash, all rules starting with the pattern are returned
+     *        as well as one matching the pattern with the dash excluded.
+     *        Passing a `Rule` for this parameter is deprecated in version 8.9.0, and will not work from v9.0.
+     *        Call `getRules($rule->getRule())` instead.
+     *
+     * @return array<int, Rule>
+     */
+    public function getRules($mRule = null)
+    {
+        if ($mRule instanceof Rule) {
+            $mRule = $mRule->getRule();
+        }
+        /** @var array<int, Rule> $aResult */
+        $aResult = [];
+        foreach ($this->aRules as $sName => $aRules) {
+            // Either no search rule is given or the search rule matches the found rule exactly
+            // or the search rule ends in “-” and the found rule starts with the search rule.
+            if (
+                !$mRule || $sName === $mRule
+                || (
+                    strrpos($mRule, '-') === strlen($mRule) - strlen('-')
+                    && (strpos($sName, $mRule) === 0 || $sName === substr($mRule, 0, -1))
+                )
+            ) {
+                $aResult = array_merge($aResult, $aRules);
+            }
+        }
+        usort($aResult, function (Rule $first, Rule $second) {
+            if ($first->getLineNo() === $second->getLineNo()) {
+                return $first->getColNo() - $second->getColNo();
+            }
+            return $first->getLineNo() - $second->getLineNo();
+        });
+        return $aResult;
+    }
+
+    /**
+     * Overrides all the rules of this set.
+     *
+     * @param array<array-key, Rule> $aRules The rules to override with.
+     *
+     * @return void
+     */
+    public function setRules(array $aRules)
+    {
+        $this->aRules = [];
+        foreach ($aRules as $rule) {
+            $this->addRule($rule);
+        }
+    }
+
+    /**
+     * Returns all rules matching the given pattern and returns them in an associative array with the rule’s name
+     * as keys. This method exists mainly for backwards-compatibility and is really only partially useful.
+     *
+     * Note: This method loses some information: Calling this (with an argument of `background-`) on a declaration block
+     * like `{ background-color: green; background-color; rgba(0, 127, 0, 0.7); }` will only yield an associative array
+     * containing the rgba-valued rule while `getRules()` would yield an indexed array containing both.
+     *
+     * @param Rule|string|null $mRule $mRule
+     *        Pattern to search for. If null, returns all rules. If the pattern ends with a dash,
+     *        all rules starting with the pattern are returned as well as one matching the pattern with the dash
+     *        excluded.
+     *        Passing a `Rule` for this parameter is deprecated in version 8.9.0, and will not work from v9.0.
+     *        Call `getRulesAssoc($rule->getRule())` instead.
+     *
+     * @return array<string, Rule>
+     */
+    public function getRulesAssoc($mRule = null)
+    {
+        /** @var array<string, Rule> $aResult */
+        $aResult = [];
+        foreach ($this->getRules($mRule) as $oRule) {
+            $aResult[$oRule->getRule()] = $oRule;
+        }
+        return $aResult;
+    }
+
+    /**
+     * Removes a `Rule` from this `RuleSet` by identity.
+     *
+     * @param Rule|string|null $mRule
+     *        `Rule` to remove.
+     *        Passing a `string` or `null` is deprecated in version 8.9.0, and will no longer work from v9.0.
+     *        Use `removeMatchingRules()` or `removeAllRules()` instead.
+     */
+    public function removeRule($mRule)
+    {
+        if ($mRule instanceof Rule) {
+            $sRule = $mRule->getRule();
+            if (!isset($this->aRules[$sRule])) {
+                return;
+            }
+            foreach ($this->aRules[$sRule] as $iKey => $oRule) {
+                if ($oRule === $mRule) {
+                    unset($this->aRules[$sRule][$iKey]);
+                }
+            }
+        } elseif ($mRule !== null) {
+            $this->removeMatchingRules($mRule);
+        } else {
+            $this->removeAllRules();
+        }
+    }
+
+    /**
+     * Removes rules by property name or search pattern.
+     *
+     * @param string $searchPattern
+     *        pattern to remove.
+     *        If the pattern ends in a dash,
+     *        all rules starting with the pattern are removed as well as one matching the pattern with the dash
+     *        excluded.
+     */
+    public function removeMatchingRules($searchPattern)
+    {
+        foreach ($this->aRules as $propertyName => $rules) {
+            // Either the search rule matches the found rule exactly
+            // or the search rule ends in “-” and the found rule starts with the search rule or equals it
+            // (without the trailing dash).
+            if (
+                $propertyName === $searchPattern
+                || (\strrpos($searchPattern, '-') === \strlen($searchPattern) - \strlen('-')
+                    && (\strpos($propertyName, $searchPattern) === 0
+                        || $propertyName === \substr($searchPattern, 0, -1)))
+            ) {
+                unset($this->aRules[$propertyName]);
+            }
+        }
+    }
+
+    public function removeAllRules()
+    {
+        $this->aRules = [];
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @return string
+     */
+    protected function renderRules(OutputFormat $oOutputFormat)
+    {
+        $sResult = '';
+        $bIsFirst = true;
+        $oNextLevel = $oOutputFormat->nextLevel();
+        foreach ($this->getRules() as $oRule) {
+            $sRendered = $oNextLevel->safely(function () use ($oRule, $oNextLevel) {
+                return $oRule->render($oNextLevel);
+            });
+            if ($sRendered === null) {
+                continue;
+            }
+            if ($bIsFirst) {
+                $bIsFirst = false;
+                $sResult .= $oNextLevel->spaceBeforeRules();
+            } else {
+                $sResult .= $oNextLevel->spaceBetweenRules();
+            }
+            $sResult .= $sRendered;
+        }
+
+        if (!$bIsFirst) {
+            // Had some output
+            $sResult .= $oOutputFormat->spaceAfterRules();
+        }
+
+        return $oOutputFormat->removeLastSemicolon($sResult);
+    }
+
+    /**
+     * @param array<string, Comment> $aComments
+     *
+     * @return void
+     */
+    public function addComments(array $aComments)
+    {
+        $this->aComments = array_merge($this->aComments, $aComments);
+    }
+
+    /**
+     * @return array<string, Comment>
+     */
+    public function getComments()
+    {
+        return $this->aComments;
+    }
+
+    /**
+     * @param array<string, Comment> $aComments
+     *
+     * @return void
+     */
+    public function setComments(array $aComments)
+    {
+        $this->aComments = $aComments;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Settings.php

@@ -0,0 +1,106 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS;
+
+/**
+ * Parser settings class.
+ *
+ * Configure parser behaviour here.
+ */
+class Settings
+{
+    /**
+     * Multi-byte string support.
+     *
+     * If `true` (`mbstring` extension must be enabled), will use (slower) `mb_strlen`, `mb_convert_case`, `mb_substr`
+     * and `mb_strpos` functions. Otherwise, the normal (ASCII-Only) functions will be used.
+     *
+     * @var bool
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $bMultibyteSupport;
+
+    /**
+     * The default charset for the CSS if no `@charset` declaration is found. Defaults to utf-8.
+     *
+     * @var string
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $sDefaultCharset = 'utf-8';
+
+    /**
+     * Whether the parser silently ignore invalid rules instead of choking on them.
+     *
+     * @var bool
+     *
+     * @internal since 8.8.0, will be made private in 9.0.0
+     */
+    public $bLenientParsing = true;
+
+    private function __construct()
+    {
+        $this->bMultibyteSupport = extension_loaded('mbstring');
+    }
+
+    /**
+     * @return self new instance
+     */
+    public static function create()
+    {
+        return new Settings();
+    }
+
+    /**
+     * Enables/disables multi-byte string support.
+     *
+     * If `true` (`mbstring` extension must be enabled), will use (slower) `mb_strlen`, `mb_convert_case`, `mb_substr`
+     * and `mb_strpos` functions. Otherwise, the normal (ASCII-Only) functions will be used.
+     *
+     * @param bool $bMultibyteSupport
+     *
+     * @return self fluent interface
+     */
+    public function withMultibyteSupport($bMultibyteSupport = true)
+    {
+        $this->bMultibyteSupport = $bMultibyteSupport;
+        return $this;
+    }
+
+    /**
+     * Sets the charset to be used if the CSS does not contain an `@charset` declaration.
+     *
+     * @param string $sDefaultCharset
+     *
+     * @return self fluent interface
+     */
+    public function withDefaultCharset($sDefaultCharset)
+    {
+        $this->sDefaultCharset = $sDefaultCharset;
+        return $this;
+    }
+
+    /**
+     * Configures whether the parser should silently ignore invalid rules.
+     *
+     * @param bool $bLenientParsing
+     *
+     * @return self fluent interface
+     */
+    public function withLenientParsing($bLenientParsing = true)
+    {
+        $this->bLenientParsing = $bLenientParsing;
+        return $this;
+    }
+
+    /**
+     * Configures the parser to choke on invalid rules.
+     *
+     * @return self fluent interface
+     */
+    public function beStrict()
+    {
+        return $this->withLenientParsing(false);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/CSSFunction.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\SourceException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+
+/**
+ * A `CSSFunction` represents a special kind of value that also contains a function name and where the values are the
+ * function’s arguments. It also handles equals-sign-separated argument lists like `filter: alpha(opacity=90);`.
+ */
+class CSSFunction extends ValueList
+{
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0
+     */
+    protected $sName;
+
+    /**
+     * @param string $sName
+     * @param RuleValueList|array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string> $aArguments
+     * @param string $sSeparator
+     * @param int $iLineNo
+     */
+    public function __construct($sName, $aArguments, $sSeparator = ',', $iLineNo = 0)
+    {
+        if ($aArguments instanceof RuleValueList) {
+            $sSeparator = $aArguments->getListSeparator();
+            $aArguments = $aArguments->getListComponents();
+        }
+        $this->sName = $sName;
+        $this->setPosition($iLineNo); // TODO: redundant?
+        parent::__construct($aArguments, $sSeparator, $iLineNo);
+    }
+
+    /**
+     * @param ParserState $oParserState
+     * @param bool $bIgnoreCase
+     *
+     * @return CSSFunction
+     *
+     * @throws SourceException
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState, $bIgnoreCase = false)
+    {
+        $mResult = $oParserState->parseIdentifier($bIgnoreCase);
+        $oParserState->consume('(');
+        $aArguments = Value::parseValue($oParserState, ['=', ' ', ',']);
+        $mResult = new CSSFunction($mResult, $aArguments, ',', $oParserState->currentLine());
+        $oParserState->consume(')');
+        return $mResult;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->sName;
+    }
+
+    /**
+     * @param string $sName
+     *
+     * @return void
+     */
+    public function setName($sName)
+    {
+        $this->sName = $sName;
+    }
+
+    /**
+     * @return array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string>
+     */
+    public function getArguments()
+    {
+        return $this->aComponents;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        $aArguments = parent::render($oOutputFormat);
+        return "{$this->sName}({$aArguments})";
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/CSSString.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\SourceException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+
+/**
+ * This class is a wrapper for quoted strings to distinguish them from keywords.
+ *
+ * `CSSString`s always output with double quotes.
+ */
+class CSSString extends PrimitiveValue
+{
+    /**
+     * @var string
+     */
+    private $sString;
+
+    /**
+     * @param string $sString
+     * @param int $iLineNo
+     */
+    public function __construct($sString, $iLineNo = 0)
+    {
+        $this->sString = $sString;
+        parent::__construct($iLineNo);
+    }
+
+    /**
+     * @return CSSString
+     *
+     * @throws SourceException
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState)
+    {
+        $sBegin = $oParserState->peek();
+        $sQuote = null;
+        if ($sBegin === "'") {
+            $sQuote = "'";
+        } elseif ($sBegin === '"') {
+            $sQuote = '"';
+        }
+        if ($sQuote !== null) {
+            $oParserState->consume($sQuote);
+        }
+        $sResult = "";
+        $sContent = null;
+        if ($sQuote === null) {
+            // Unquoted strings end in whitespace or with braces, brackets, parentheses
+            while (!preg_match('/[\\s{}()<>\\[\\]]/isu', $oParserState->peek())) {
+                $sResult .= $oParserState->parseCharacter(false);
+            }
+        } else {
+            while (!$oParserState->comes($sQuote)) {
+                $sContent = $oParserState->parseCharacter(false);
+                if ($sContent === null) {
+                    throw new SourceException(
+                        "Non-well-formed quoted string {$oParserState->peek(3)}",
+                        $oParserState->currentLine()
+                    );
+                }
+                $sResult .= $sContent;
+            }
+            $oParserState->consume($sQuote);
+        }
+        return new CSSString($sResult, $oParserState->currentLine());
+    }
+
+    /**
+     * @param string $sString
+     *
+     * @return void
+     */
+    public function setString($sString)
+    {
+        $this->sString = $sString;
+    }
+
+    /**
+     * @return string
+     */
+    public function getString()
+    {
+        return $this->sString;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        $sString = addslashes($this->sString);
+        $sString = str_replace("\n", '\A', $sString);
+        return $oOutputFormat->getStringQuotingType() . $sString . $oOutputFormat->getStringQuotingType();
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/CalcFunction.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+
+/**
+ * Support for `-webkit-calc` and `-moz-calc` is deprecated in version 8.8.0, and will be removed in version 9.0.0.
+ */
+class CalcFunction extends CSSFunction
+{
+    /**
+     * @var int
+     *
+     * @internal
+     */
+    const T_OPERAND = 1;
+
+    /**
+     * @var int
+     *
+     * @internal
+     */
+    const T_OPERATOR = 2;
+
+    /**
+     * @param ParserState $oParserState
+     * @param bool $bIgnoreCase
+     *
+     * @return CalcFunction
+     *
+     * @throws UnexpectedTokenException
+     * @throws UnexpectedEOFException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState, $bIgnoreCase = false)
+    {
+        $aOperators = ['+', '-', '*', '/'];
+        $sFunction = $oParserState->parseIdentifier();
+        if ($oParserState->peek() != '(') {
+            // Found ; or end of line before an opening bracket
+            throw new UnexpectedTokenException('(', $oParserState->peek(), 'literal', $oParserState->currentLine());
+        } elseif (!in_array($sFunction, ['calc', '-moz-calc', '-webkit-calc'])) {
+            // Found invalid calc definition. Example calc (...
+            throw new UnexpectedTokenException('calc', $sFunction, 'literal', $oParserState->currentLine());
+        }
+        $oParserState->consume('(');
+        $oCalcList = new CalcRuleValueList($oParserState->currentLine());
+        $oList = new RuleValueList(',', $oParserState->currentLine());
+        $iNestingLevel = 0;
+        $iLastComponentType = null;
+        while (!$oParserState->comes(')') || $iNestingLevel > 0) {
+            if ($oParserState->isEnd() && $iNestingLevel === 0) {
+                break;
+            }
+
+            $oParserState->consumeWhiteSpace();
+            if ($oParserState->comes('(')) {
+                $iNestingLevel++;
+                $oCalcList->addListComponent($oParserState->consume(1));
+                $oParserState->consumeWhiteSpace();
+                continue;
+            } elseif ($oParserState->comes(')')) {
+                $iNestingLevel--;
+                $oCalcList->addListComponent($oParserState->consume(1));
+                $oParserState->consumeWhiteSpace();
+                continue;
+            }
+            if ($iLastComponentType != CalcFunction::T_OPERAND) {
+                $oVal = Value::parsePrimitiveValue($oParserState);
+                $oCalcList->addListComponent($oVal);
+                $iLastComponentType = CalcFunction::T_OPERAND;
+            } else {
+                if (in_array($oParserState->peek(), $aOperators)) {
+                    if (($oParserState->comes('-') || $oParserState->comes('+'))) {
+                        if (
+                            $oParserState->peek(1, -1) != ' '
+                            || !($oParserState->comes('- ')
+                                || $oParserState->comes('+ '))
+                        ) {
+                            throw new UnexpectedTokenException(
+                                " {$oParserState->peek()} ",
+                                $oParserState->peek(1, -1) . $oParserState->peek(2),
+                                'literal',
+                                $oParserState->currentLine()
+                            );
+                        }
+                    }
+                    $oCalcList->addListComponent($oParserState->consume(1));
+                    $iLastComponentType = CalcFunction::T_OPERATOR;
+                } else {
+                    throw new UnexpectedTokenException(
+                        sprintf(
+                            'Next token was expected to be an operand of type %s. Instead "%s" was found.',
+                            implode(', ', $aOperators),
+                            $oParserState->peek()
+                        ),
+                        '',
+                        'custom',
+                        $oParserState->currentLine()
+                    );
+                }
+            }
+            $oParserState->consumeWhiteSpace();
+        }
+        $oList->addListComponent($oCalcList);
+        if (!$oParserState->isEnd()) {
+            $oParserState->consume(')');
+        }
+        return new CalcFunction($sFunction, $oList, ',', $oParserState->currentLine());
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/CalcRuleValueList.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+
+class CalcRuleValueList extends RuleValueList
+{
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        parent::__construct(',', $iLineNo);
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return $oOutputFormat->implode(' ', $this->aComponents);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/Color.php

@@ -0,0 +1,186 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+
+/**
+ * `Color's can be input in the form #rrggbb, #rgb or schema(val1, val2, …) but are always stored as an array of
+ * ('s' => val1, 'c' => val2, 'h' => val3, …) and output in the second form.
+ */
+class Color extends CSSFunction
+{
+    /**
+     * @param array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string> $aColor
+     * @param int $iLineNo
+     */
+    public function __construct(array $aColor, $iLineNo = 0)
+    {
+        parent::__construct(implode('', array_keys($aColor)), $aColor, ',', $iLineNo);
+    }
+
+    /**
+     * @param ParserState $oParserState
+     * @param bool $bIgnoreCase
+     *
+     * @return Color|CSSFunction
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState, $bIgnoreCase = false)
+    {
+        $aColor = [];
+        if ($oParserState->comes('#')) {
+            $oParserState->consume('#');
+            $sValue = $oParserState->parseIdentifier(false);
+            if ($oParserState->strlen($sValue) === 3) {
+                $sValue = $sValue[0] . $sValue[0] . $sValue[1] . $sValue[1] . $sValue[2] . $sValue[2];
+            } elseif ($oParserState->strlen($sValue) === 4) {
+                $sValue = $sValue[0] . $sValue[0] . $sValue[1] . $sValue[1] . $sValue[2] . $sValue[2] . $sValue[3]
+                    . $sValue[3];
+            }
+
+            if ($oParserState->strlen($sValue) === 8) {
+                $aColor = [
+                    'r' => new Size(intval($sValue[0] . $sValue[1], 16), null, true, $oParserState->currentLine()),
+                    'g' => new Size(intval($sValue[2] . $sValue[3], 16), null, true, $oParserState->currentLine()),
+                    'b' => new Size(intval($sValue[4] . $sValue[5], 16), null, true, $oParserState->currentLine()),
+                    'a' => new Size(
+                        round(self::mapRange(intval($sValue[6] . $sValue[7], 16), 0, 255, 0, 1), 2),
+                        null,
+                        true,
+                        $oParserState->currentLine()
+                    ),
+                ];
+            } elseif ($oParserState->strlen($sValue) === 6) {
+                $aColor = [
+                    'r' => new Size(intval($sValue[0] . $sValue[1], 16), null, true, $oParserState->currentLine()),
+                    'g' => new Size(intval($sValue[2] . $sValue[3], 16), null, true, $oParserState->currentLine()),
+                    'b' => new Size(intval($sValue[4] . $sValue[5], 16), null, true, $oParserState->currentLine()),
+                ];
+            } else {
+                throw new UnexpectedTokenException(
+                    'Invalid hex color value',
+                    $sValue,
+                    'custom',
+                    $oParserState->currentLine()
+                );
+            }
+        } else {
+            $sColorMode = $oParserState->parseIdentifier(true);
+            $oParserState->consumeWhiteSpace();
+            $oParserState->consume('(');
+
+            $bContainsVar = false;
+            $iLength = $oParserState->strlen($sColorMode);
+            for ($i = 0; $i < $iLength; ++$i) {
+                $oParserState->consumeWhiteSpace();
+                if ($oParserState->comes('var')) {
+                    $aColor[$sColorMode[$i]] = CSSFunction::parseIdentifierOrFunction($oParserState);
+                    $bContainsVar = true;
+                } else {
+                    $aColor[$sColorMode[$i]] = Size::parse($oParserState, true);
+                }
+
+                if ($bContainsVar && $oParserState->comes(')')) {
+                    // With a var argument the function can have fewer arguments
+                    break;
+                }
+
+                $oParserState->consumeWhiteSpace();
+                if ($i < ($iLength - 1)) {
+                    $oParserState->consume(',');
+                }
+            }
+            $oParserState->consume(')');
+
+            if ($bContainsVar) {
+                return new CSSFunction($sColorMode, array_values($aColor), ',', $oParserState->currentLine());
+            }
+        }
+        return new Color($aColor, $oParserState->currentLine());
+    }
+
+    /**
+     * @param float $fVal
+     * @param float $fFromMin
+     * @param float $fFromMax
+     * @param float $fToMin
+     * @param float $fToMax
+     *
+     * @return float
+     */
+    private static function mapRange($fVal, $fFromMin, $fFromMax, $fToMin, $fToMax)
+    {
+        $fFromRange = $fFromMax - $fFromMin;
+        $fToRange = $fToMax - $fToMin;
+        $fMultiplier = $fToRange / $fFromRange;
+        $fNewVal = $fVal - $fFromMin;
+        $fNewVal *= $fMultiplier;
+        return $fNewVal + $fToMin;
+    }
+
+    /**
+     * @return array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string>
+     */
+    public function getColor()
+    {
+        return $this->aComponents;
+    }
+
+    /**
+     * @param array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string> $aColor
+     *
+     * @return void
+     */
+    public function setColor(array $aColor)
+    {
+        $this->setName(implode('', array_keys($aColor)));
+        $this->aComponents = $aColor;
+    }
+
+    /**
+     * @return string
+     */
+    public function getColorDescription()
+    {
+        return $this->getName();
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        // Shorthand RGB color values
+        if ($oOutputFormat->getRGBHashNotation() && implode('', array_keys($this->aComponents)) === 'rgb') {
+            $sResult = sprintf(
+                '%02x%02x%02x',
+                $this->aComponents['r']->getSize(),
+                $this->aComponents['g']->getSize(),
+                $this->aComponents['b']->getSize()
+            );
+            return '#' . (($sResult[0] == $sResult[1]) && ($sResult[2] == $sResult[3]) && ($sResult[4] == $sResult[5])
+                    ? "$sResult[0]$sResult[2]$sResult[4]" : $sResult);
+        }
+        return parent::render($oOutputFormat);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/LineName.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+
+class LineName extends ValueList
+{
+    /**
+     * @param array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string> $aComponents
+     * @param int $iLineNo
+     */
+    public function __construct(array $aComponents = [], $iLineNo = 0)
+    {
+        parent::__construct($aComponents, ' ', $iLineNo);
+    }
+
+    /**
+     * @return LineName
+     *
+     * @throws UnexpectedTokenException
+     * @throws UnexpectedEOFException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState)
+    {
+        $oParserState->consume('[');
+        $oParserState->consumeWhiteSpace();
+        $aNames = [];
+        do {
+            if ($oParserState->getSettings()->bLenientParsing) {
+                try {
+                    $aNames[] = $oParserState->parseIdentifier();
+                } catch (UnexpectedTokenException $e) {
+                    if (!$oParserState->comes(']')) {
+                        throw $e;
+                    }
+                }
+            } else {
+                $aNames[] = $oParserState->parseIdentifier();
+            }
+            $oParserState->consumeWhiteSpace();
+        } while (!$oParserState->comes(']'));
+        $oParserState->consume(']');
+        return new LineName($aNames, $oParserState->currentLine());
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return '[' . parent::render(OutputFormat::createCompact()) . ']';
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/PrimitiveValue.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+abstract class PrimitiveValue extends Value
+{
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/RuleValueList.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+/**
+ * This class is used to represent all multivalued rules like `font: bold 12px/3 Helvetica, Verdana, sans-serif;`
+ * (where the value would be a whitespace-separated list of the primitive value `bold`, a slash-separated list
+ * and a comma-separated list).
+ */
+class RuleValueList extends ValueList
+{
+    /**
+     * @param string $sSeparator
+     * @param int $iLineNo
+     */
+    public function __construct($sSeparator = ',', $iLineNo = 0)
+    {
+        parent::__construct([], $sSeparator, $iLineNo);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/Size.php

@@ -0,0 +1,247 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+
+/**
+ * A `Size` consists of a numeric `size` value and a unit.
+ */
+class Size extends PrimitiveValue
+{
+    /**
+     * vh/vw/vm(ax)/vmin/rem are absolute insofar as they don’t scale to the immediate parent (only the viewport)
+     *
+     * @var array<int, string>
+     *
+     * @internal
+     */
+    const ABSOLUTE_SIZE_UNITS = [
+        'px',
+        'pt',
+        'pc',
+        'cm',
+        'mm',
+        'mozmm',
+        'in',
+        'vh',
+        'dvh',
+        'svh',
+        'lvh',
+        'vw',
+        'vmin',
+        'vmax',
+        'rem',
+    ];
+
+    /**
+     * @var array<int, string>
+     *
+     * @internal
+     */
+    const RELATIVE_SIZE_UNITS = ['%', 'em', 'ex', 'ch', 'fr'];
+
+    /**
+     * @var array<int, string>
+     *
+     * @internal
+     */
+    const NON_SIZE_UNITS = ['deg', 'grad', 'rad', 's', 'ms', 'turn', 'Hz', 'kHz'];
+
+    /**
+     * @var array<int, array<string, string>>|null
+     */
+    private static $SIZE_UNITS = null;
+
+    /**
+     * @var float
+     */
+    private $fSize;
+
+    /**
+     * @var string|null
+     */
+    private $sUnit;
+
+    /**
+     * @var bool
+     */
+    private $bIsColorComponent;
+
+    /**
+     * @param float|int|string $fSize
+     * @param string|null $sUnit
+     * @param bool $bIsColorComponent
+     * @param int $iLineNo
+     */
+    public function __construct($fSize, $sUnit = null, $bIsColorComponent = false, $iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+        $this->fSize = (float)$fSize;
+        $this->sUnit = $sUnit;
+        $this->bIsColorComponent = $bIsColorComponent;
+    }
+
+    /**
+     * @param bool $bIsColorComponent
+     *
+     * @return Size
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState, $bIsColorComponent = false)
+    {
+        $sSize = '';
+        if ($oParserState->comes('-')) {
+            $sSize .= $oParserState->consume('-');
+        }
+        while (is_numeric($oParserState->peek()) || $oParserState->comes('.') || $oParserState->comes('e', true)) {
+            if ($oParserState->comes('.')) {
+                $sSize .= $oParserState->consume('.');
+            } elseif ($oParserState->comes('e', true)) {
+                $sLookahead = $oParserState->peek(1, 1);
+                if (is_numeric($sLookahead) || $sLookahead === '+' || $sLookahead === '-') {
+                    $sSize .= $oParserState->consume(2);
+                } else {
+                    break; // Reached the unit part of the number like "em" or "ex"
+                }
+            } else {
+                $sSize .= $oParserState->consume(1);
+            }
+        }
+
+        $sUnit = null;
+        $aSizeUnits = self::getSizeUnits();
+        foreach ($aSizeUnits as $iLength => &$aValues) {
+            $sKey = strtolower($oParserState->peek($iLength));
+            if (array_key_exists($sKey, $aValues)) {
+                if (($sUnit = $aValues[$sKey]) !== null) {
+                    $oParserState->consume($iLength);
+                    break;
+                }
+            }
+        }
+        return new Size((float)$sSize, $sUnit, $bIsColorComponent, $oParserState->currentLine());
+    }
+
+    /**
+     * @return array<int, array<string, string>>
+     */
+    private static function getSizeUnits()
+    {
+        if (!is_array(self::$SIZE_UNITS)) {
+            self::$SIZE_UNITS = [];
+            foreach (array_merge(self::ABSOLUTE_SIZE_UNITS, self::RELATIVE_SIZE_UNITS, self::NON_SIZE_UNITS) as $val) {
+                $iSize = strlen($val);
+                if (!isset(self::$SIZE_UNITS[$iSize])) {
+                    self::$SIZE_UNITS[$iSize] = [];
+                }
+                self::$SIZE_UNITS[$iSize][strtolower($val)] = $val;
+            }
+
+            krsort(self::$SIZE_UNITS, SORT_NUMERIC);
+        }
+
+        return self::$SIZE_UNITS;
+    }
+
+    /**
+     * @param string $sUnit
+     *
+     * @return void
+     */
+    public function setUnit($sUnit)
+    {
+        $this->sUnit = $sUnit;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getUnit()
+    {
+        return $this->sUnit;
+    }
+
+    /**
+     * @param float|int|string $fSize
+     */
+    public function setSize($fSize)
+    {
+        $this->fSize = (float)$fSize;
+    }
+
+    /**
+     * @return float
+     */
+    public function getSize()
+    {
+        return $this->fSize;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isColorComponent()
+    {
+        return $this->bIsColorComponent;
+    }
+
+    /**
+     * Returns whether the number stored in this Size really represents a size (as in a length of something on screen).
+     *
+     * @return false if the unit an angle, a duration, a frequency or the number is a component in a Color object.
+     */
+    public function isSize()
+    {
+        if (in_array($this->sUnit, self::NON_SIZE_UNITS, true)) {
+            return false;
+        }
+        return !$this->isColorComponent();
+    }
+
+    /**
+     * @return bool
+     */
+    public function isRelative()
+    {
+        if (in_array($this->sUnit, self::RELATIVE_SIZE_UNITS, true)) {
+            return true;
+        }
+        if ($this->sUnit === null && $this->fSize != 0) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        $l = localeconv();
+        $sPoint = preg_quote($l['decimal_point'], '/');
+        $sSize = preg_match("/[\d\.]+e[+-]?\d+/i", (string)$this->fSize)
+            ? preg_replace("/$sPoint?0+$/", "", sprintf("%f", $this->fSize)) : (string)$this->fSize;
+        return preg_replace(["/$sPoint/", "/^(-?)0\./"], ['.', '$1.'], $sSize)
+            . ($this->sUnit === null ? '' : $this->sUnit);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/URL.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\SourceException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+
+/**
+ * This class represents URLs in CSS. `URL`s always output in `URL("")` notation.
+ */
+class URL extends PrimitiveValue
+{
+    /**
+     * @var CSSString
+     */
+    private $oURL;
+
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct(CSSString $oURL, $iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+        $this->oURL = $oURL;
+    }
+
+    /**
+     * @return URL
+     *
+     * @throws SourceException
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parse(ParserState $oParserState)
+    {
+        $oAnchor = $oParserState->anchor();
+        $sIdentifier = '';
+        for ($i = 0; $i < 3; $i++) {
+            $sChar = $oParserState->parseCharacter(true);
+            if ($sChar === null) {
+                break;
+            }
+            $sIdentifier .= $sChar;
+        }
+        $bUseUrl = $oParserState->streql($sIdentifier, 'url');
+        if ($bUseUrl) {
+            $oParserState->consumeWhiteSpace();
+            $oParserState->consume('(');
+        } else {
+            $oAnchor->backtrack();
+        }
+        $oParserState->consumeWhiteSpace();
+        $oResult = new URL(CSSString::parse($oParserState), $oParserState->currentLine());
+        if ($bUseUrl) {
+            $oParserState->consumeWhiteSpace();
+            $oParserState->consume(')');
+        }
+        return $oResult;
+    }
+
+    /**
+     * @return void
+     */
+    public function setURL(CSSString $oURL)
+    {
+        $this->oURL = $oURL;
+    }
+
+    /**
+     * @return CSSString
+     */
+    public function getURL()
+    {
+        return $this->oURL;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return "url({$this->oURL->render($oOutputFormat)})";
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/Value.php

@@ -0,0 +1,218 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\CSSElement;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\ParserState;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\SourceException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedEOFException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Parsing\UnexpectedTokenException;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Position;
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\Position\Positionable;
+
+/**
+ * Abstract base class for specific classes of CSS values: `Size`, `Color`, `CSSString` and `URL`, and another
+ * abstract subclass `ValueList`.
+ */
+abstract class Value implements CSSElement, Positionable
+{
+    use Position;
+
+    /**
+     * @param int $iLineNo
+     */
+    public function __construct($iLineNo = 0)
+    {
+        $this->setPosition($iLineNo);
+    }
+
+    /**
+     * @param array<array-key, string> $aListDelimiters
+     *
+     * @return RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string
+     *
+     * @throws UnexpectedTokenException
+     * @throws UnexpectedEOFException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parseValue(ParserState $oParserState, array $aListDelimiters = [])
+    {
+        /** @var array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string> $aStack */
+        $aStack = [];
+        $oParserState->consumeWhiteSpace();
+        //Build a list of delimiters and parsed values
+        while (
+            !($oParserState->comes('}') || $oParserState->comes(';') || $oParserState->comes('!')
+                || $oParserState->comes(')')
+                || $oParserState->comes('\\')
+                || $oParserState->isEnd())
+        ) {
+            if (count($aStack) > 0) {
+                $bFoundDelimiter = false;
+                foreach ($aListDelimiters as $sDelimiter) {
+                    if ($oParserState->comes($sDelimiter)) {
+                        array_push($aStack, $oParserState->consume($sDelimiter));
+                        $oParserState->consumeWhiteSpace();
+                        $bFoundDelimiter = true;
+                        break;
+                    }
+                }
+                if (!$bFoundDelimiter) {
+                    //Whitespace was the list delimiter
+                    array_push($aStack, ' ');
+                }
+            }
+            array_push($aStack, self::parsePrimitiveValue($oParserState));
+            $oParserState->consumeWhiteSpace();
+        }
+        // Convert the list to list objects
+        foreach ($aListDelimiters as $sDelimiter) {
+            $iStackLength = count($aStack);
+            if ($iStackLength === 1) {
+                return $aStack[0];
+            }
+            $aNewStack = [];
+            for ($iStartPosition = 0; $iStartPosition < $iStackLength; ++$iStartPosition) {
+                if ($iStartPosition === ($iStackLength - 1) || $sDelimiter !== $aStack[$iStartPosition + 1]) {
+                    $aNewStack[] = $aStack[$iStartPosition];
+                    continue;
+                }
+                $iLength = 2; //Number of elements to be joined
+                for ($i = $iStartPosition + 3; $i < $iStackLength; $i += 2, ++$iLength) {
+                    if ($sDelimiter !== $aStack[$i]) {
+                        break;
+                    }
+                }
+                $oList = new RuleValueList($sDelimiter, $oParserState->currentLine());
+                for ($i = $iStartPosition; $i - $iStartPosition < $iLength * 2; $i += 2) {
+                    $oList->addListComponent($aStack[$i]);
+                }
+                $aNewStack[] = $oList;
+                $iStartPosition += $iLength * 2 - 2;
+            }
+            $aStack = $aNewStack;
+        }
+        if (!isset($aStack[0])) {
+            throw new UnexpectedTokenException(
+                " {$oParserState->peek()} ",
+                $oParserState->peek(1, -1) . $oParserState->peek(2),
+                'literal',
+                $oParserState->currentLine()
+            );
+        }
+        return $aStack[0];
+    }
+
+    /**
+     * @param bool $bIgnoreCase
+     *
+     * @return CSSFunction|string
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parseIdentifierOrFunction(ParserState $oParserState, $bIgnoreCase = false)
+    {
+        $oAnchor = $oParserState->anchor();
+        $mResult = $oParserState->parseIdentifier($bIgnoreCase);
+
+        if ($oParserState->comes('(')) {
+            $oAnchor->backtrack();
+            if ($oParserState->streql('url', $mResult)) {
+                $mResult = URL::parse($oParserState);
+            } elseif (
+                $oParserState->streql('calc', $mResult)
+                || $oParserState->streql('-webkit-calc', $mResult)
+                || $oParserState->streql('-moz-calc', $mResult)
+            ) {
+                $mResult = CalcFunction::parse($oParserState);
+            } else {
+                $mResult = CSSFunction::parse($oParserState, $bIgnoreCase);
+            }
+        }
+
+        return $mResult;
+    }
+
+    /**
+     * @return CSSFunction|CSSString|LineName|Size|URL|string
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     * @throws SourceException
+     *
+     * @internal since V8.8.0
+     */
+    public static function parsePrimitiveValue(ParserState $oParserState)
+    {
+        $oValue = null;
+        $oParserState->consumeWhiteSpace();
+        if (
+            is_numeric($oParserState->peek())
+            || ($oParserState->comes('-.')
+                && is_numeric($oParserState->peek(1, 2)))
+            || (($oParserState->comes('-') || $oParserState->comes('.')) && is_numeric($oParserState->peek(1, 1)))
+        ) {
+            $oValue = Size::parse($oParserState);
+        } elseif ($oParserState->comes('#') || $oParserState->comes('rgb', true) || $oParserState->comes('hsl', true)) {
+            $oValue = Color::parse($oParserState);
+        } elseif ($oParserState->comes("'") || $oParserState->comes('"')) {
+            $oValue = CSSString::parse($oParserState);
+        } elseif ($oParserState->comes("progid:") && $oParserState->getSettings()->bLenientParsing) {
+            $oValue = self::parseMicrosoftFilter($oParserState);
+        } elseif ($oParserState->comes("[")) {
+            $oValue = LineName::parse($oParserState);
+        } elseif ($oParserState->comes("U+")) {
+            $oValue = self::parseUnicodeRangeValue($oParserState);
+        } else {
+            $sNextChar = $oParserState->peek(1);
+            try {
+                $oValue = self::parseIdentifierOrFunction($oParserState);
+            } catch (UnexpectedTokenException $e) {
+                if (\in_array($sNextChar, ['+', '-', '*', '/'], true)) {
+                    $oValue = $oParserState->consume(1);
+                } else {
+                    throw $e;
+                }
+            }
+        }
+        $oParserState->consumeWhiteSpace();
+        return $oValue;
+    }
+
+    /**
+     * @return CSSFunction
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     */
+    private static function parseMicrosoftFilter(ParserState $oParserState)
+    {
+        $sFunction = $oParserState->consumeUntil('(', false, true);
+        $aArguments = Value::parseValue($oParserState, [',', '=']);
+        return new CSSFunction($sFunction, $aArguments, ',', $oParserState->currentLine());
+    }
+
+    /**
+     * @return string
+     *
+     * @throws UnexpectedEOFException
+     * @throws UnexpectedTokenException
+     */
+    private static function parseUnicodeRangeValue(ParserState $oParserState)
+    {
+        $iCodepointMaxLength = 6; // Code points outside BMP can use up to six digits
+        $sRange = "";
+        $oParserState->consume("U+");
+        do {
+            if ($oParserState->comes('-')) {
+                $iCodepointMaxLength = 13; // Max length is 2 six digit code points + the dash(-) between them
+            }
+            $sRange .= $oParserState->consume(1);
+        } while (strlen($sRange) < $iCodepointMaxLength && preg_match("/[A-Fa-f0-9\?-]/", $oParserState->peek()));
+        return "U+{$sRange}";
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Sabberworm/CSS/Value/ValueList.php

@@ -0,0 +1,114 @@
+<?php
+
+namespace Automattic\WooCommerce\Vendor\Sabberworm\CSS\Value;
+
+use Automattic\WooCommerce\Vendor\Sabberworm\CSS\OutputFormat;
+
+/**
+ * A `ValueList` represents a lists of `Value`s, separated by some separation character
+ * (mostly `,`, whitespace, or `/`).
+ *
+ * There are two types of `ValueList`s: `RuleValueList` and `CSSFunction`
+ */
+abstract class ValueList extends Value
+{
+    /**
+     * @var array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string>
+     *
+     * @internal since 8.8.0
+     */
+    protected $aComponents;
+
+    /**
+     * @var string
+     *
+     * @internal since 8.8.0
+     */
+    protected $sSeparator;
+
+    /**
+     * phpcs:ignore Generic.Files.LineLength
+     * @param array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string>|RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string $aComponents
+     * @param string $sSeparator
+     * @param int $iLineNo
+     */
+    public function __construct($aComponents = [], $sSeparator = ',', $iLineNo = 0)
+    {
+        parent::__construct($iLineNo);
+        if (!is_array($aComponents)) {
+            $aComponents = [$aComponents];
+        }
+        $this->aComponents = $aComponents;
+        $this->sSeparator = $sSeparator;
+    }
+
+    /**
+     * @param RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string $mComponent
+     *
+     * @return void
+     */
+    public function addListComponent($mComponent)
+    {
+        $this->aComponents[] = $mComponent;
+    }
+
+    /**
+     * @return array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string>
+     */
+    public function getListComponents()
+    {
+        return $this->aComponents;
+    }
+
+    /**
+     * @param array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string> $aComponents
+     *
+     * @return void
+     */
+    public function setListComponents(array $aComponents)
+    {
+        $this->aComponents = $aComponents;
+    }
+
+    /**
+     * @return string
+     */
+    public function getListSeparator()
+    {
+        return $this->sSeparator;
+    }
+
+    /**
+     * @param string $sSeparator
+     *
+     * @return void
+     */
+    public function setListSeparator($sSeparator)
+    {
+        $this->sSeparator = $sSeparator;
+    }
+
+    /**
+     * @return string
+     *
+     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
+     */
+    public function __toString()
+    {
+        return $this->render(new OutputFormat());
+    }
+
+    /**
+     * @param OutputFormat|null $oOutputFormat
+     *
+     * @return string
+     */
+    public function render($oOutputFormat)
+    {
+        return $oOutputFormat->implode(
+            $oOutputFormat->spaceBeforeListArgumentSeparator($this->sSeparator) . $this->sSeparator
+            . $oOutputFormat->spaceAfterListArgumentSeparator($this->sSeparator),
+            $this->aComponents
+        );
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/CssSelectorConverter.php

@@ -0,0 +1,69 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Shortcut\ClassParser;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Shortcut\ElementParser;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Shortcut\EmptyStringParser;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Shortcut\HashParser;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\XPath\Extension\HtmlExtension;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\XPath\Translator;
+
+/**
+ * CssSelectorConverter is the main entry point of the component and can convert CSS
+ * selectors to XPath expressions.
+ *
+ * @author Christophe Coevoet <stof@notk.org>
+ */
+class CssSelectorConverter
+{
+    private $translator;
+    private $cache;
+
+    private static $xmlCache = [];
+    private static $htmlCache = [];
+
+    /**
+     * @param bool $html Whether HTML support should be enabled. Disable it for XML documents
+     */
+    public function __construct(bool $html = true)
+    {
+        $this->translator = new Translator();
+
+        if ($html) {
+            $this->translator->registerExtension(new HtmlExtension($this->translator));
+            $this->cache = &self::$htmlCache;
+        } else {
+            $this->cache = &self::$xmlCache;
+        }
+
+        $this->translator
+            ->registerParserShortcut(new EmptyStringParser())
+            ->registerParserShortcut(new ElementParser())
+            ->registerParserShortcut(new ClassParser())
+            ->registerParserShortcut(new HashParser())
+        ;
+    }
+
+    /**
+     * Translates a CSS expression to its XPath equivalent.
+     *
+     * Optionally, a prefix can be added to the resulting XPath
+     * expression with the $prefix parameter.
+     *
+     * @return string
+     */
+    public function toXPath(string $cssExpr, string $prefix = 'descendant-or-self::')
+    {
+        return $this->cache[$prefix][$cssExpr] ?? $this->cache[$prefix][$cssExpr] = $this->translator->cssToXPath($cssExpr, $prefix);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Exception/ExceptionInterface.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Exception;
+
+/**
+ * Interface for exceptions.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ */
+interface ExceptionInterface extends \Throwable
+{
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Exception/ExpressionErrorException.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Exception;
+
+/**
+ * ParseException is thrown when a CSS selector syntax is not valid.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ */
+class ExpressionErrorException extends ParseException
+{
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Exception/InternalErrorException.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Exception;
+
+/**
+ * ParseException is thrown when a CSS selector syntax is not valid.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ */
+class InternalErrorException extends ParseException
+{
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Exception/ParseException.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Exception;
+
+/**
+ * ParseException is thrown when a CSS selector syntax is not valid.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ParseException extends \Exception implements ExceptionInterface
+{
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Exception/SyntaxErrorException.php

@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Exception;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Token;
+
+/**
+ * ParseException is thrown when a CSS selector syntax is not valid.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ */
+class SyntaxErrorException extends ParseException
+{
+    /**
+     * @return self
+     */
+    public static function unexpectedToken(string $expectedValue, Token $foundToken)
+    {
+        return new self(sprintf('Expected %s, but %s found.', $expectedValue, $foundToken));
+    }
+
+    /**
+     * @return self
+     */
+    public static function pseudoElementFound(string $pseudoElement, string $unexpectedLocation)
+    {
+        return new self(sprintf('Unexpected pseudo-element "::%s" found %s.', $pseudoElement, $unexpectedLocation));
+    }
+
+    /**
+     * @return self
+     */
+    public static function unclosedString(int $position)
+    {
+        return new self(sprintf('Unclosed/invalid string at %s.', $position));
+    }
+
+    /**
+     * @return self
+     */
+    public static function nestedNot()
+    {
+        return new self('Got nested ::not().');
+    }
+
+    /**
+     * @return self
+     */
+    public static function stringAsFunctionArgument()
+    {
+        return new self('String not allowed as function argument.');
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-present Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/AbstractNode.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Abstract base node class.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+abstract class AbstractNode implements NodeInterface
+{
+    /**
+     * @var string
+     */
+    private $nodeName;
+
+    public function getNodeName(): string
+    {
+        if (null === $this->nodeName) {
+            $this->nodeName = preg_replace('~.*\\\\([^\\\\]+)Node$~', '$1', static::class);
+        }
+
+        return $this->nodeName;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/AttributeNode.php

@@ -0,0 +1,82 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a "<selector>[<namespace>|<attribute> <operator> <value>]" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class AttributeNode extends AbstractNode
+{
+    private $selector;
+    private $namespace;
+    private $attribute;
+    private $operator;
+    private $value;
+
+    public function __construct(NodeInterface $selector, ?string $namespace, string $attribute, string $operator, ?string $value)
+    {
+        $this->selector = $selector;
+        $this->namespace = $namespace;
+        $this->attribute = $attribute;
+        $this->operator = $operator;
+        $this->value = $value;
+    }
+
+    public function getSelector(): NodeInterface
+    {
+        return $this->selector;
+    }
+
+    public function getNamespace(): ?string
+    {
+        return $this->namespace;
+    }
+
+    public function getAttribute(): string
+    {
+        return $this->attribute;
+    }
+
+    public function getOperator(): string
+    {
+        return $this->operator;
+    }
+
+    public function getValue(): ?string
+    {
+        return $this->value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->selector->getSpecificity()->plus(new Specificity(0, 1, 0));
+    }
+
+    public function __toString(): string
+    {
+        $attribute = $this->namespace ? $this->namespace.'|'.$this->attribute : $this->attribute;
+
+        return 'exists' === $this->operator
+            ? sprintf('%s[%s[%s]]', $this->getNodeName(), $this->selector, $attribute)
+            : sprintf("%s[%s[%s %s '%s']]", $this->getNodeName(), $this->selector, $attribute, $this->operator, $this->value);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/ClassNode.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a "<selector>.<name>" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class ClassNode extends AbstractNode
+{
+    private $selector;
+    private $name;
+
+    public function __construct(NodeInterface $selector, string $name)
+    {
+        $this->selector = $selector;
+        $this->name = $name;
+    }
+
+    public function getSelector(): NodeInterface
+    {
+        return $this->selector;
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->selector->getSpecificity()->plus(new Specificity(0, 1, 0));
+    }
+
+    public function __toString(): string
+    {
+        return sprintf('%s[%s.%s]', $this->getNodeName(), $this->selector, $this->name);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/CombinedSelectorNode.php

@@ -0,0 +1,66 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a combined node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class CombinedSelectorNode extends AbstractNode
+{
+    private $selector;
+    private $combinator;
+    private $subSelector;
+
+    public function __construct(NodeInterface $selector, string $combinator, NodeInterface $subSelector)
+    {
+        $this->selector = $selector;
+        $this->combinator = $combinator;
+        $this->subSelector = $subSelector;
+    }
+
+    public function getSelector(): NodeInterface
+    {
+        return $this->selector;
+    }
+
+    public function getCombinator(): string
+    {
+        return $this->combinator;
+    }
+
+    public function getSubSelector(): NodeInterface
+    {
+        return $this->subSelector;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->selector->getSpecificity()->plus($this->subSelector->getSpecificity());
+    }
+
+    public function __toString(): string
+    {
+        $combinator = ' ' === $this->combinator ? '<followed>' : $this->combinator;
+
+        return sprintf('%s[%s %s %s]', $this->getNodeName(), $this->selector, $combinator, $this->subSelector);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/ElementNode.php

@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a "<namespace>|<element>" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class ElementNode extends AbstractNode
+{
+    private $namespace;
+    private $element;
+
+    public function __construct(?string $namespace = null, ?string $element = null)
+    {
+        $this->namespace = $namespace;
+        $this->element = $element;
+    }
+
+    public function getNamespace(): ?string
+    {
+        return $this->namespace;
+    }
+
+    public function getElement(): ?string
+    {
+        return $this->element;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return new Specificity(0, 0, $this->element ? 1 : 0);
+    }
+
+    public function __toString(): string
+    {
+        $element = $this->element ?: '*';
+
+        return sprintf('%s[%s]', $this->getNodeName(), $this->namespace ? $this->namespace.'|'.$element : $element);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/FunctionNode.php

@@ -0,0 +1,76 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Token;
+
+/**
+ * Represents a "<selector>:<name>(<arguments>)" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class FunctionNode extends AbstractNode
+{
+    private $selector;
+    private $name;
+    private $arguments;
+
+    /**
+     * @param Token[] $arguments
+     */
+    public function __construct(NodeInterface $selector, string $name, array $arguments = [])
+    {
+        $this->selector = $selector;
+        $this->name = strtolower($name);
+        $this->arguments = $arguments;
+    }
+
+    public function getSelector(): NodeInterface
+    {
+        return $this->selector;
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return Token[]
+     */
+    public function getArguments(): array
+    {
+        return $this->arguments;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->selector->getSpecificity()->plus(new Specificity(0, 1, 0));
+    }
+
+    public function __toString(): string
+    {
+        $arguments = implode(', ', array_map(function (Token $token) {
+            return "'".$token->getValue()."'";
+        }, $this->arguments));
+
+        return sprintf('%s[%s:%s(%s)]', $this->getNodeName(), $this->selector, $this->name, $arguments ? '['.$arguments.']' : '');
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/HashNode.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a "<selector>#<id>" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class HashNode extends AbstractNode
+{
+    private $selector;
+    private $id;
+
+    public function __construct(NodeInterface $selector, string $id)
+    {
+        $this->selector = $selector;
+        $this->id = $id;
+    }
+
+    public function getSelector(): NodeInterface
+    {
+        return $this->selector;
+    }
+
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->selector->getSpecificity()->plus(new Specificity(1, 0, 0));
+    }
+
+    public function __toString(): string
+    {
+        return sprintf('%s[%s#%s]', $this->getNodeName(), $this->selector, $this->id);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/NegationNode.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a "<selector>:not(<identifier>)" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class NegationNode extends AbstractNode
+{
+    private $selector;
+    private $subSelector;
+
+    public function __construct(NodeInterface $selector, NodeInterface $subSelector)
+    {
+        $this->selector = $selector;
+        $this->subSelector = $subSelector;
+    }
+
+    public function getSelector(): NodeInterface
+    {
+        return $this->selector;
+    }
+
+    public function getSubSelector(): NodeInterface
+    {
+        return $this->subSelector;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->selector->getSpecificity()->plus($this->subSelector->getSpecificity());
+    }
+
+    public function __toString(): string
+    {
+        return sprintf('%s[%s:not(%s)]', $this->getNodeName(), $this->selector, $this->subSelector);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/NodeInterface.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Interface for nodes.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+interface NodeInterface
+{
+    public function getNodeName(): string;
+
+    public function getSpecificity(): Specificity;
+
+    public function __toString(): string;
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/PseudoNode.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a "<selector>:<identifier>" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class PseudoNode extends AbstractNode
+{
+    private $selector;
+    private $identifier;
+
+    public function __construct(NodeInterface $selector, string $identifier)
+    {
+        $this->selector = $selector;
+        $this->identifier = strtolower($identifier);
+    }
+
+    public function getSelector(): NodeInterface
+    {
+        return $this->selector;
+    }
+
+    public function getIdentifier(): string
+    {
+        return $this->identifier;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->selector->getSpecificity()->plus(new Specificity(0, 1, 0));
+    }
+
+    public function __toString(): string
+    {
+        return sprintf('%s[%s:%s]', $this->getNodeName(), $this->selector, $this->identifier);
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/SelectorNode.php

@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a "<selector>(::|:)<pseudoElement>" node.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class SelectorNode extends AbstractNode
+{
+    private $tree;
+    private $pseudoElement;
+
+    public function __construct(NodeInterface $tree, ?string $pseudoElement = null)
+    {
+        $this->tree = $tree;
+        $this->pseudoElement = $pseudoElement ? strtolower($pseudoElement) : null;
+    }
+
+    public function getTree(): NodeInterface
+    {
+        return $this->tree;
+    }
+
+    public function getPseudoElement(): ?string
+    {
+        return $this->pseudoElement;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSpecificity(): Specificity
+    {
+        return $this->tree->getSpecificity()->plus(new Specificity(0, 0, $this->pseudoElement ? 1 : 0));
+    }
+
+    public function __toString(): string
+    {
+        return sprintf('%s[%s%s]', $this->getNodeName(), $this->tree, $this->pseudoElement ? '::'.$this->pseudoElement : '');
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Node/Specificity.php

@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Node;
+
+/**
+ * Represents a node specificity.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @see http://www.w3.org/TR/selectors/#specificity
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class Specificity
+{
+    public const A_FACTOR = 100;
+    public const B_FACTOR = 10;
+    public const C_FACTOR = 1;
+
+    private $a;
+    private $b;
+    private $c;
+
+    public function __construct(int $a, int $b, int $c)
+    {
+        $this->a = $a;
+        $this->b = $b;
+        $this->c = $c;
+    }
+
+    public function plus(self $specificity): self
+    {
+        return new self($this->a + $specificity->a, $this->b + $specificity->b, $this->c + $specificity->c);
+    }
+
+    public function getValue(): int
+    {
+        return $this->a * self::A_FACTOR + $this->b * self::B_FACTOR + $this->c * self::C_FACTOR;
+    }
+
+    /**
+     * Returns -1 if the object specificity is lower than the argument,
+     * 0 if they are equal, and 1 if the argument is lower.
+     */
+    public function compareTo(self $specificity): int
+    {
+        if ($this->a !== $specificity->a) {
+            return $this->a > $specificity->a ? 1 : -1;
+        }
+
+        if ($this->b !== $specificity->b) {
+            return $this->b > $specificity->b ? 1 : -1;
+        }
+
+        if ($this->c !== $specificity->c) {
+            return $this->c > $specificity->c ? 1 : -1;
+        }
+
+        return 0;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Parser/Handler/CommentHandler.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Handler;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Reader;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\TokenStream;
+
+/**
+ * CSS selector comment handler.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class CommentHandler implements HandlerInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(Reader $reader, TokenStream $stream): bool
+    {
+        if ('/*' !== $reader->getSubstring(2)) {
+            return false;
+        }
+
+        $offset = $reader->getOffset('*/');
+
+        if (false === $offset) {
+            $reader->moveToEnd();
+        } else {
+            $reader->moveForward($offset + 2);
+        }
+
+        return true;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Parser/Handler/HandlerInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Handler;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Reader;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\TokenStream;
+
+/**
+ * CSS selector handler interface.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+interface HandlerInterface
+{
+    public function handle(Reader $reader, TokenStream $stream): bool;
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Parser/Handler/HashHandler.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Handler;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Reader;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Token;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Tokenizer\TokenizerEscaping;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Tokenizer\TokenizerPatterns;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\TokenStream;
+
+/**
+ * CSS selector comment handler.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class HashHandler implements HandlerInterface
+{
+    private $patterns;
+    private $escaping;
+
+    public function __construct(TokenizerPatterns $patterns, TokenizerEscaping $escaping)
+    {
+        $this->patterns = $patterns;
+        $this->escaping = $escaping;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(Reader $reader, TokenStream $stream): bool
+    {
+        $match = $reader->findPattern($this->patterns->getHashPattern());
+
+        if (!$match) {
+            return false;
+        }
+
+        $value = $this->escaping->escapeUnicode($match[1]);
+        $stream->push(new Token(Token::TYPE_HASH, $value, $reader->getPosition()));
+        $reader->moveForward(\strlen($match[0]));
+
+        return true;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Parser/Handler/IdentifierHandler.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Handler;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Reader;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Token;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Tokenizer\TokenizerEscaping;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Tokenizer\TokenizerPatterns;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\TokenStream;
+
+/**
+ * CSS selector comment handler.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class IdentifierHandler implements HandlerInterface
+{
+    private $patterns;
+    private $escaping;
+
+    public function __construct(TokenizerPatterns $patterns, TokenizerEscaping $escaping)
+    {
+        $this->patterns = $patterns;
+        $this->escaping = $escaping;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(Reader $reader, TokenStream $stream): bool
+    {
+        $match = $reader->findPattern($this->patterns->getIdentifierPattern());
+
+        if (!$match) {
+            return false;
+        }
+
+        $value = $this->escaping->escapeUnicode($match[0]);
+        $stream->push(new Token(Token::TYPE_IDENTIFIER, $value, $reader->getPosition()));
+        $reader->moveForward(\strlen($match[0]));
+
+        return true;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Parser/Handler/NumberHandler.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Handler;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Reader;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Token;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Tokenizer\TokenizerPatterns;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\TokenStream;
+
+/**
+ * CSS selector comment handler.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class NumberHandler implements HandlerInterface
+{
+    private $patterns;
+
+    public function __construct(TokenizerPatterns $patterns)
+    {
+        $this->patterns = $patterns;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(Reader $reader, TokenStream $stream): bool
+    {
+        $match = $reader->findPattern($this->patterns->getNumberPattern());
+
+        if (!$match) {
+            return false;
+        }
+
+        $stream->push(new Token(Token::TYPE_NUMBER, $match[0], $reader->getPosition()));
+        $reader->moveForward(\strlen($match[0]));
+
+        return true;
+    }
+}

wp-content/plugins/woocommerce/lib/packages/Symfony/Component/CssSelector/Parser/Handler/StringHandler.php

@@ -0,0 +1,77 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Handler;
+
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Exception\InternalErrorException;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Exception\SyntaxErrorException;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Reader;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Token;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Tokenizer\TokenizerEscaping;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\Tokenizer\TokenizerPatterns;
+use Automattic\WooCommerce\Vendor\Symfony\Component\CssSelector\Parser\TokenStream;
+
+/**
+ * CSS selector comment handler.
+ *
+ * This component is a port of the Python cssselect library,
+ * which is copyright Ian Bicking, @see https://github.com/SimonSapin/cssselect.
+ *
+ * @author Jean-François Simon <jeanfrancois.simon@sensiolabs.com>
+ *
+ * @internal
+ */
+class StringHandler implements HandlerInterface
+{
+    private $patterns;
+    private $escaping;
+
+    public function __construct(TokenizerPatterns $patterns, TokenizerEscaping $escaping)
+    {
+        $this->patterns = $patterns;
+        $this->escaping = $escaping;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(Reader $reader, TokenStream $stream): bool
+    {
+        $quote = $reader->getSubstring(1);
+
+        if (!\in_array($quote, ["'", '"'])) {
+            return false;
+        }
+
+        $reader->moveForward(1);
+        $match = $reader->findPattern($this->patterns->getQuotedStringPattern($quote));
+
+        if (!$match) {
+            throw new InternalErrorException(sprintf('Should have found at least an empty match at %d.', $reader->getPosition()));
+        }
+
+        // check unclosed strings
+        if (\strlen($match[0]) === $reader->getRemainingLength()) {
+            throw SyntaxErrorException::unclosedString($reader->getPosition() - 1);
+        }
+
+        // check quotes pairs validity
+        if ($quote !== $reader->getSubstring(1, \strlen($match[0]))) {
+            throw SyntaxErrorException::unclosedString($reader->getPosition() - 1);
+        }
+
+        $string = $this->escaping->escapeUnicodeAndNewLine($match[0]);
+        $stream->push(new Token(Token::TYPE_STRING, $string, $reader->getPosition()));
+        $reader->moveForward(\strlen($match[0]) + 1);
+
+        return true;
+    }
+}