Load Google Fonts from Global Styles without Jetpack

.gitignore

@@ -3,7 +3,7 @@ deploy/
 twentynineteen/
 theme-dev-utils/
 theme-dev-utils
-vendor/
+# vendor/
 *.DS_Store
 *.zip
 *.rej

blockbase/composer.json

@@ -0,0 +1,9 @@
+{
+    "name": "automattic/blockbase",
+    "description": "WordPress theme",
+    "type": "project",
+    "require": {
+        "automattic/jetpack-google-fonts-provider": "^0.3.0"
+    },
+    "license": "GPL-2.0-or-later"
+}

blockbase/composer.lock

@@ -0,0 +1,65 @@
+{
+    "_readme": [
+        "This file locks the dependencies of your project to a known state",
+        "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+        "This file is @generated automatically"
+    ],
+    "content-hash": "c4626a994d9535042254e67ce1633371",
+    "packages": [
+        {
+            "name": "automattic/jetpack-google-fonts-provider",
+            "version": "v0.3.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/Automattic/jetpack-google-fonts-provider.git",
+                "reference": "cc26c71d0156bcdce80552cb7f084c23b5fe7be4"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/Automattic/jetpack-google-fonts-provider/zipball/cc26c71d0156bcdce80552cb7f084c23b5fe7be4",
+                "reference": "cc26c71d0156bcdce80552cb7f084c23b5fe7be4",
+                "shasum": ""
+            },
+            "require-dev": {
+                "automattic/jetpack-changelogger": "^3.1",
+                "brain/monkey": "2.6.1",
+                "yoast/phpunit-polyfills": "1.0.3"
+            },
+            "type": "jetpack-library",
+            "extra": {
+                "autotagger": true,
+                "mirror-repo": "Automattic/jetpack-google-fonts-provider",
+                "changelogger": {
+                    "link-template": "https://github.com/Automattic/jetpack-google-fonts-provider/compare/v${old}...v${new}"
+                },
+                "branch-alias": {
+                    "dev-master": "0.3.x-dev"
+                },
+                "textdomain": "jetpack-google-fonts-provider"
+            },
+            "autoload": {
+                "classmap": [
+                    "src/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "GPL-2.0-or-later"
+            ],
+            "description": "WordPress Webfonts provider for Google Fonts",
+            "support": {
+                "source": "https://github.com/Automattic/jetpack-google-fonts-provider/tree/v0.3.0"
+            },
+            "time": "2022-04-26T14:33:32+00:00"
+        }
+    ],
+    "packages-dev": [],
+    "aliases": [],
+    "minimum-stability": "stable",
+    "stability-flags": [],
+    "prefer-stable": false,
+    "prefer-lowest": false,
+    "platform": [],
+    "platform-dev": [],
+    "plugin-api-version": "2.2.0"
+}

blockbase/functions.php

@@ -1,4 +1,7 @@
 <?php
+
+require_once 'vendor/autoload.php';
+
 if ( ! function_exists( 'blockbase_support' ) ) :
 	function blockbase_support() {
 		// Alignwide and alignfull classes in the block editor.
@@ -92,93 +95,22 @@ function blockbase_scripts() {
 	if ( file_exists( get_stylesheet_directory() . '/assets/theme.css' ) ) {
 		wp_enqueue_style( 'blockbase-child-styles', get_stylesheet_directory_uri() . '/assets/theme.css', array('blockbase-ponyfill'), wp_get_theme()->get( 'Version' ) );
 	}
-
-	$legacy_fonts = blockbase_get_legacy_fonts();
-	wp_enqueue_style( 'global-styles-legacy-fonts', ' ', array( 'global-styles' ) ); // This needs to load after global_styles, hence the dependency
-	$css  = 'body {';
-
-	// TODO: escape font data
-	if ( isset( $legacy_fonts['body'] ) && is_legacy_font_used( 'body' ) ) {
-		$css .= "--wp--preset--font-family--{$legacy_fonts['body']['fontSlug']}:{$legacy_fonts['body']['fontFamily']};";
-	}
-
-	// TODO: escape font data
-	if ( isset( $legacy_fonts['heading'] ) && is_legacy_font_used( 'heading' ) ) {
-		$css .= "--wp--preset--font-family--{$legacy_fonts['heading']['fontSlug']}:{$legacy_fonts['heading']['fontFamily']};";
-	}
-	$css .= '}';
-	wp_add_inline_style( 'global-styles-legacy-fonts', $css );
 }
 add_action( 'wp_enqueue_scripts', 'blockbase_scripts' );
 
-/**
- * Retrieve blockbase legacy fonts data
- *
- * @return array
- */
-function blockbase_get_legacy_fonts() {
-	$legacy_settings_array = json_decode( get_option('blockbase_legacy_font_settings', '[]' ), true );
-
-	$fonts = array();
-
-	// Group by heading and body fonts
-	foreach( $legacy_settings_array as $setting ) {
-		if ( $setting['slug'] === 'body-font' ) {
-			$fonts['body'] = $setting;
-		}
-
-		if ( $setting['slug'] === 'heading-font' ) {
-			$fonts['heading'] = $setting;
-		}
-	}
-
-	return $fonts;
-}
-
-/**
- * Compares legacy fonts and global styles fonts to determine if legacy fonts are still being used
- *
- * @return bool
- */
-function is_legacy_font_used( $type = 'body' ) {
-	$legacy_fonts = blockbase_get_legacy_fonts();
-
-	$body_font = wp_get_global_styles( array( 'typography', 'fontFamily' ) );
-	preg_match( '/font-family\|(?P<slug>.+)$/', $body_font, $matches );
-	$body_font_slug = $matches['slug'] ?? '';
-
-	if (
-		isset( $legacy_fonts['body'] ) &&
-		$body_font_slug &&
-		$legacy_fonts['body']['fontSlug'] === $body_font_slug
-	) {
-		return true;
-	}
-
-	return false;
-}
-
 /**
  * Add Google webfonts
  *
  * @return $fonts_url
  */
 function blockbase_fonts_url() {
-	if ( ! class_exists( 'WP_Theme_JSON_Resolver_Gutenberg' ) ) {
-		return '';
-	}
-
-	$legacy_font_settings = blockbase_get_legacy_fonts();
-	if ( empty( $legacy_font_settings ) ) {
-		return '';
-	}
-
 	$font_families = [];
+	$global_styles_fonts = \Automattic\Jetpack\Fonts\Introspectors\Global_Styles::collect_fonts_from_global_styles();
+	$font_settings = blockbase_get_font_settings();
 
-	foreach( $legacy_font_settings as $font_type => $font ) {
-		// $font_type = array_slice( $font['slug'], 0, strpos( $font['slug'], '-' ) + 1 );
-		if ( ! empty( $font['google'] ) && is_legacy_font_used( $font_type ) ) {
-			$font_families[] = $font['google'];
+	foreach( $global_styles_fonts as $font_slug ) {
+		if ( isset( $font_settings[ $font_slug ]['google'] ) ) {
+			$font_families[] = $font_settings[ $font_slug ]['google'];
 		}
 	}
 
@@ -190,6 +122,17 @@ function blockbase_fonts_url() {
 	return esc_url_raw( 'https://fonts.googleapis.com/css2?' . implode( '&', array_unique( $font_families ) ) . '&display=swap' );
 }
 
+function blockbase_get_font_settings() {
+	$font_settings = wp_get_global_settings( array( 'typography', 'fontFamilies' ) );
+	$remapped_font_settings = array();
+
+	foreach( $font_settings['theme'] as $font ) {
+		$remapped_font_settings[ $font['slug'] ] = $font;
+	}
+
+	return $remapped_font_settings;
+}
+
 /**
  * Customize Global Styles
  */

blockbase/theme.json

@@ -371,6 +371,12 @@
 					"fontSlug": "system-font",
 					"slug": "heading-font",
 					"name": "Headings (System Font)"
+				},
+				{
+					"fontFamily": "\"Arvo\", serif",
+					"slug": "arvo",
+					"name": "\"Arvo\", serif",
+					"google": "family=Arvo:ital,wght@0,400;0,700;1,400;1,700"
 				}
 			],
 			"fontSizes": [

blockbase/vendor/autoload.php

@@ -0,0 +1,7 @@
+<?php
+
+// autoload.php @generated by Composer
+
+require_once __DIR__ . '/composer/autoload_real.php';
+
+return ComposerAutoloaderInit0777abd23b9615aca0bf30e3e2b460bb::getLoader();

blockbase/vendor/automattic/jetpack-google-fonts-provider/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.0] - 2022-04-26
+### Added
+- Add functions for enqueueing fonts used in block and global style settings
+
+### Changed
+- Updated package dependencies.
+- Update package.json metadata.
+
+## [0.2.2] - 2022-04-06
+### Added
+- Set composer package type to "jetpack-library" so i18n will work.
+
+## [0.2.1] - 2022-03-29
+### Added
+- Set composer package type to "jetpack-library" so i18n will work.
+
+## [0.2.0] - 2022-03-15
+### Changed
+- Updated package dependencies
+
+### Deprecated
+- Google Fonts: update the method used to preconnect Fonts source domain.
+
+## 0.1.0 - 2022-03-08
+### Added
+- Adds a provider for Google Fonts using the new Webfonts API in Gutenberg
+
+[0.3.0]: https://github.com/Automattic/jetpack-google-fonts-provider/compare/v0.2.2...v0.3.0
+[0.2.2]: https://github.com/Automattic/jetpack-google-fonts-provider/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/Automattic/jetpack-google-fonts-provider/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/Automattic/jetpack-google-fonts-provider/compare/v0.1.0...v0.2.0

blockbase/vendor/automattic/jetpack-google-fonts-provider/LICENSE.txt

@@ -0,0 +1,357 @@
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+===================================
+
+
+GNU GENERAL PUBLIC LICENSE
+   Version 2, June 1991
+
+Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+		Preamble
+
+The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+GNU GENERAL PUBLIC LICENSE
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+a) You must cause the modified files to carry prominent notices
+stating that you changed the files and the date of any change.
+
+b) You must cause any work that you distribute or publish, that in
+whole or in part contains or is derived from the Program or any
+part thereof, to be licensed as a whole at no charge to all third
+parties under the terms of this License.
+
+c) If the modified program normally reads commands interactively
+when run, you must cause it, when started running for such
+interactive use in the most ordinary way, to print or display an
+announcement including an appropriate copyright notice and a
+notice that there is no warranty (or else, saying that you provide
+a warranty) and that users may redistribute the program under
+these conditions, and telling the user how to view a copy of this
+License.  (Exception: if the Program itself is interactive but
+does not normally print such an announcement, your work based on
+the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+a) Accompany it with the complete corresponding machine-readable
+source code, which must be distributed under the terms of Sections
+1 and 2 above on a medium customarily used for software interchange; or,
+
+b) Accompany it with a written offer, valid for at least three
+years, to give any third party, for a charge no more than your
+cost of physically performing source distribution, a complete
+machine-readable copy of the corresponding source code, to be
+distributed under the terms of Sections 1 and 2 above on a medium
+customarily used for software interchange; or,
+
+c) Accompany it with the information you received as to the offer
+to distribute corresponding source code.  (This alternative is
+allowed only for noncommercial distribution and only if you
+received the program in object code or executable form with such
+an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+		NO WARRANTY
+
+11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+<one line to give the program's name and a brief idea of what it does.>
+Copyright (C) <year>  <name of author>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+Gnomovision version 69, Copyright (C) year name of author
+Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+This is free software, and you are welcome to redistribute it
+under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+`Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+<signature of Ty Coon>, 1 April 1989
+Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

blockbase/vendor/automattic/jetpack-google-fonts-provider/README.md

@@ -0,0 +1,61 @@
+# Jetpack Google Fonts Provider Package
+
+WordPress Webfonts provider for Google Fonts
+
+## How to install google-fonts-provider
+
+Package is published in [Packagist](https://packagist.org/packages/automattic/jetpack-google-fonts-provider). We recommend using the latest version there. You can install it in a composer managed project with `composer require automattic/jetpack-google-fonts-provider`.
+
+You can also test with the latest development versions like below:
+
+```json
+"require": {
+    "automattic/jetpack-google-fonts-provider": "dev-master"
+}
+```
+
+## Usage
+
+The WordPress Webfonts API is available by activating the Gutenberg plugin and is planned to be included in WordPress 6.0.
+
+### Register the provider
+
+This package contains the provider class, but the provider needs to be registered before it can be used.
+
+```php
+wp_register_webfont_provider( 'google-fonts', '\Automattic\Jetpack\Fonts\Google_Fonts_Provider' );
+```
+
+### Register fonts
+
+After registering the provider, you can register any of the fonts available in the [Google Fonts catalog](https://fonts.google.com) to make them available for use in the block editor typography settings, Global styles, and your site's CSS.
+
+```php
+wp_register_webfont(
+		array(
+			'font-family' => 'Lato',
+			'provider'    => 'google-fonts',
+		),
+);
+```
+
+### Add preconnect link
+
+Adding a preconnect link to the `<head>` of the page will help make sure the font files load as soon as possible, and reduce the layout shift when they are displayed. See [this list of webfont best practices](https://web.dev/font-best-practices/#preconnect-to-critical-third-party-origins) for more details. To do so, we can rely on WordPress' `wp_resource_hints` filter like so:
+
+```php
+add_filter( 'wp_resource_hints', '\Automattic\Jetpack\Fonts\Utils::font_source_resource_hint', 10, 2 );
+```
+
+### Additional info
+
+For a discussion about the Webfonts API in WordPress, see https://make.wordpress.org/core/2021/09/28/implementing-a-webfonts-api-in-wordpress-core/.
+
+## Security
+
+Need to report a security vulnerability? Go to [https://automattic.com/security/](https://automattic.com/security/) or directly to our security bug bounty site [https://hackerone.com/automattic](https://hackerone.com/automattic).
+
+## License
+
+Jetpack Google Fonts Provider is licensed under [GNU General Public License v2 (or later)](./LICENSE.txt)
+

blockbase/vendor/automattic/jetpack-google-fonts-provider/SECURITY.md

@@ -0,0 +1,38 @@
+# Security Policy
+
+Full details of the Automattic Security Policy can be found on [automattic.com](https://automattic.com/security/).
+
+## Supported Versions
+
+Generally, only the latest version of Jetpack has continued support. If a critical vulnerability is found in the current version of Jetpack, we may opt to backport any patches to previous versions. 
+
+## Reporting a Vulnerability
+
+[Jetpack](https://jetpack.com/) is an open-source plugin for WordPress. Our HackerOne program covers the plugin software, as well as a variety of related projects and infrastructure.
+
+**For responsible disclosure of security issues and to be eligible for our bug bounty program, please submit your report via the [HackerOne](https://hackerone.com/automattic) portal.**
+
+Our most critical targets are:
+
+* Jetpack and the Jetpack composer packages (all within this repo)
+* Jetpack.com -- the primary marketing site.
+* cloud.jetpack.com -- a management site.
+* wordpress.com -- the shared management site for both Jetpack and WordPress.com sites.
+
+For more targets, see the `In Scope` section on [HackerOne](https://hackerone.com/automattic).
+
+_Please note that the **WordPress software is a separate entity** from Automattic. Please report vulnerabilities for WordPress through [the WordPress Foundation's HackerOne page](https://hackerone.com/wordpress)._
+
+## Guidelines
+
+We're committed to working with security researchers to resolve the vulnerabilities they discover. You can help us by following these guidelines:
+
+*   Follow [HackerOne's disclosure guidelines](https://www.hackerone.com/disclosure-guidelines).
+*   Pen-testing Production:
+    *   Please **setup a local environment** instead whenever possible. Most of our code is open source (see above).
+    *   If that's not possible, **limit any data access/modification** to the bare minimum necessary to reproduce a PoC.
+    *   **_Don't_ automate form submissions!** That's very annoying for us, because it adds extra work for the volunteers who manage those systems, and reduces the signal/noise ratio in our communication channels.
+    *   To be eligible for a bounty, all of these guidelines must be followed.
+*   Be Patient - Give us a reasonable time to correct the issue before you disclose the vulnerability.
+
+We also expect you to comply with all applicable laws. You're responsible to pay any taxes associated with your bounties.

blockbase/vendor/automattic/jetpack-google-fonts-provider/composer.json

@@ -0,0 +1,41 @@
+{
+	"name": "automattic/jetpack-google-fonts-provider",
+	"description": "WordPress Webfonts provider for Google Fonts",
+	"type": "jetpack-library",
+	"license": "GPL-2.0-or-later",
+	"require": {},
+	"require-dev": {
+		"yoast/phpunit-polyfills": "1.0.3",
+		"automattic/jetpack-changelogger": "^3.1",
+		"brain/monkey": "2.6.1"
+	},
+	"autoload": {
+		"classmap": [
+			"src/"
+		]
+	},
+	"scripts": {
+		"phpunit": [
+			"./vendor/phpunit/phpunit/phpunit --colors=always"
+		],
+		"test-coverage": [
+			"php -dpcov.directory=. ./vendor/bin/phpunit --coverage-clover \"$COVERAGE_DIR/clover.xml\""
+		],
+		"test-php": [
+			"@composer phpunit"
+		]
+	},
+	"minimum-stability": "dev",
+	"prefer-stable": true,
+	"extra": {
+		"autotagger": true,
+		"mirror-repo": "Automattic/jetpack-google-fonts-provider",
+		"changelogger": {
+			"link-template": "https://github.com/Automattic/jetpack-google-fonts-provider/compare/v${old}...v${new}"
+		},
+		"branch-alias": {
+			"dev-master": "0.3.x-dev"
+		},
+		"textdomain": "jetpack-google-fonts-provider"
+	}
+}

blockbase/vendor/automattic/jetpack-google-fonts-provider/src/class-google-fonts-provider.php

@@ -0,0 +1,359 @@
+<?php
+/**
+ * WordPress webfonts provider for Google Fonts
+ *
+ * @package automattic/jetpack-google-fonts-provider
+ * @since 0.1.0
+ */
+
+namespace Automattic\Jetpack\Fonts;
+
+if ( ! class_exists( '\WP_Webfonts_Provider' ) ) {
+	return;
+}
+
+/**
+ * Google Font Provider
+ */
+class Google_Fonts_Provider extends \WP_Webfonts_Provider {
+	/**
+	 * Font provider ID.
+	 *
+	 * @var string
+	 */
+	protected $id = 'jetpack-google-fonts';
+
+	/**
+	 * The provider's root URL for retrieving font CSS.
+	 *
+	 * @var string
+	 */
+	protected $root_url = 'https://fonts.googleapis.com/css2';
+
+	/**
+	 * Prints out a preconnect link for improving performance when downloading
+	 * Google Font files.
+	 *
+	 * Hook this function into `wp_head` to enable the preconnect link.
+	 *
+	 * @deprecated 0.2.0 Use Automattic\Jetpack\Fonts\Utils::font_source_resource_hint() instead.
+	 *
+	 * @return void
+	 */
+	public static function preconnect_font_source() {
+		_deprecated_function( __METHOD__, '0.2.0', 'Automattic\\Jetpack\\Fonts\\Utils::font_source_resource_hint' );
+
+		$fonts_url = \set_url_scheme( 'https://fonts.gstatic.com' ); ?>
+<link rel="preconnect" href="<?php echo esc_url( $fonts_url ); ?>" crossorigin>
+		<?php
+	}
+
+	/**
+	 * Gets cached CSS from a remote URL.
+	 *
+	 * @param string $id   An ID used to cache the styles.
+	 * @param string $url  The URL to fetch.
+
+	 * @return string The styles.
+	 */
+	protected function get_cached_remote_styles( $id, $url ) {
+		$css = \get_site_transient( $id );
+
+		// Get remote response and cache the CSS if it hasn't been cached already.
+		if ( false === $css ) {
+			$css = $this->get_remote_styles( $url );
+
+			/*
+			* Early return if the request failed.
+			* Cache an empty string for 60 seconds to avoid bottlenecks.
+			*/
+			if ( empty( $css ) ) {
+				\set_site_transient( $id, '', MINUTE_IN_SECONDS );
+				return '';
+			}
+
+			// Cache the CSS for a month.
+			\set_site_transient( $id, $css, MONTH_IN_SECONDS );
+		}
+
+		return $css;
+	}
+
+	/**
+	 * Gets styles from the remote font service via the given URL.
+	 *
+	 * @param string $url  The URL to fetch.
+
+	 * @return string The styles on success. Empty string on failure.
+	 */
+	protected function get_remote_styles( $url ) {
+		// Use a modern user-agent, to get woff2 files.
+		$args = array( 'user-agent' => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:73.0) Gecko/20100101 Firefox/73.0' );
+
+		// Get the remote URL contents.
+		$response = \wp_safe_remote_get( $url, $args );
+
+		// Early return if the request failed.
+		if ( \is_wp_error( $response ) || 200 !== \wp_remote_retrieve_response_code( $response ) ) {
+			return '';
+		}
+
+		// Get the response body.
+		return \wp_remote_retrieve_body( $response );
+	}
+
+	/**
+	 * Gets the `@font-face` CSS styles for Google Fonts.
+	 *
+	 * This method does the following processing tasks:
+	 *    1. Orchestrates an optimized Google Fonts API URL for each font-family.
+	 *    2. Caches each URL, if not already cached.
+	 *    3. Does a remote request to the Google Fonts API service to fetch the styles.
+	 *    4. Generates the `@font-face` for all its webfonts.
+	 *
+	 * @return string The `@font-face` CSS.
+	 */
+	public function get_css() {
+		$css  = '';
+		$urls = $this->build_collection_api_urls();
+
+		foreach ( $urls as $url ) {
+			$css .= $this->get_cached_remote_styles( 'jetpack_google_fonts_' . md5( $url ), $url );
+		}
+
+		return $css;
+	}
+
+	/**
+	 * Builds the Google Fonts URL for a collection of webfonts.
+	 *
+	 * For example, if given the following webfonts:
+	 * ```
+	 * array(
+	 *      array(
+	 *          'font-family' => 'Source Serif Pro',
+	 *          'font-style'  => 'normal',
+	 *          'font-weight' => '200 400',
+	 *      ),
+	 *      array(
+	 *          'font-family' => 'Source Serif Pro',
+	 *          'font-style'  => 'italic',
+	 *          'font-weight' => '400 600',
+	 *      ),
+	 * )
+	 * ```
+	 * then the returned collection would be:
+	 * ```
+	 * array(
+	 *      'https://fonts.googleapis.com/css2?family=Source+Serif+Pro:ital,wght@0,200;0,300;0,400;1,400;1,500;1,600&display=fallback'
+	 * )
+	 * ```
+	 *
+	 * @return array Collection of font-family urls.
+	 */
+	private function build_collection_api_urls() {
+		$font_families_urls = array();
+
+		/*
+		* Iterate over each font-family group to build the Google Fonts API URL
+		* for that specific family. Each is added to the collection of URLs to be
+		* returned to the `get_css()` method for making the remote request.
+		*/
+		foreach ( $this->organize_webfonts() as $font_display => $font_families ) {
+			$url_parts = array();
+			foreach ( $font_families as $font_family => $webfonts ) {
+				list( $normal_weights, $italic_weights ) = $this->collect_font_weights( $webfonts );
+
+				// Build the font-style with its font-weights.
+				$url_part = rawurlencode( $font_family );
+				if ( empty( $italic_weights ) && ! empty( $normal_weights ) ) {
+					$url_part .= ':wght@' . implode( ';', $normal_weights );
+				} elseif ( ! empty( $italic_weights ) && empty( $normal_weights ) ) {
+					$url_part .= ':ital,wght@1,' . implode( ';', $normal_weights );
+				} elseif ( ! empty( $italic_weights ) && ! empty( $normal_weights ) ) {
+					$url_part .= ':ital,wght@0,' . implode( ';0,', $normal_weights ) . ';1,' . implode( ';1,', $italic_weights );
+				}
+
+				// Add it to the collection.
+				$url_parts[] = $url_part;
+			}
+
+			// Build the URL for this font-family and add it to the collection.
+			$font_families_urls[] = $this->root_url . '?family=' . implode( '&family=', $url_parts ) . '&display=' . $font_display;
+		}
+
+		return $font_families_urls;
+	}
+
+	/**
+	 * Organizes the webfonts by font-display and then font-family.
+	 *
+	 * To optimizing building the URL for the Google Fonts API request,
+	 * this method organizes the webfonts first by font-display and then
+	 * by font-family.
+	 *
+	 * For example, if given the following webfonts:
+	 * ```
+	 * array(
+	 *      array(
+	 *          'font-family' => 'Source Serif Pro',
+	 *          'font-style'  => 'normal',
+	 *          'font-weight' => '200 400',
+	 *      ),
+	 *      array(
+	 *          'font-family' => 'Source Serif Pro',
+	 *          'font-style'  => 'italic',
+	 *          'font-weight' => '400 600',
+	 *      ),
+	 * )
+	 * ```
+	 * then the returned collection would be:
+	 * ```
+	 * array(
+	 *      'fallback' => array(
+	 *          'Source Serif Pro' => array(
+	 *              array(
+	 *                  'font-family' => 'Source Serif Pro',
+	 *                  'font-style'  => 'normal',
+	 *                  'font-weight' => '200 400',
+	 *              ),
+	 *              array(
+	 *                  'font-family' => 'Source Serif Pro',
+	 *                  'font-style'  => 'italic',
+	 *                  'font-weight' => '400 600',
+	 *              ),
+	 *         ),
+	 *      ),
+	 * )
+	 *
+	 * @return array[][] Webfonts organized by font-display and then font-family.
+	 */
+	private function organize_webfonts() {
+		$font_display_groups = array();
+
+		/*
+		* Group by font-display.
+		* Each font-display will need to be a separate request.
+		*/
+		foreach ( $this->webfonts as $webfont ) {
+			if ( ! isset( $font_display_groups[ $webfont['font-display'] ] ) ) {
+				$font_display_groups[ $webfont['font-display'] ] = array();
+			}
+			$font_display_groups[ $webfont['font-display'] ][] = $webfont;
+		}
+
+		/*
+		* Iterate over each font-display group and group by font-family.
+		* Multiple font-families can be combined in the same request,
+		* but their params need to be grouped.
+		*/
+		foreach ( $font_display_groups as $font_display => $font_display_group ) {
+			$font_families = array();
+
+			foreach ( $font_display_group as $webfont ) {
+				if ( ! isset( $font_families[ $webfont['font-family'] ] ) ) {
+					$font_families[ $webfont['font-family'] ] = array();
+				}
+				$font_families[ $webfont['font-family'] ][] = $webfont;
+			}
+
+			$font_display_groups[ $font_display ] = $font_families;
+		}
+
+		return $font_display_groups;
+	}
+
+	/**
+	 * Collects all font-weights grouped by 'normal' and 'italic' font-style.
+	 *
+	 * For example, if given the following webfonts:
+	 * ```
+	 * array(
+	 *      array(
+	 *          'font-family' => 'Source Serif Pro',
+	 *          'font-style'  => 'normal',
+	 *          'font-weight' => '200 400',
+	 *      ),
+	 *      array(
+	 *          'font-family' => 'Source Serif Pro',
+	 *          'font-style'  => 'italic',
+	 *          'font-weight' => '400 600',
+	 *      ),
+	 * )
+	 * ```
+	 * Then the returned collection would be:
+	 * ```
+	 * array(
+	 *      array( 200, 300, 400 ),
+	 *      array( 400, 500, 600 ),
+	 * )
+	 * ```
+	 *
+	 * @param array $webfonts Webfonts to process.
+	 * @return array[] {
+	 *    The font-weights grouped by font-style.
+	 *
+	 *    @type array $normal_weights  Individual font-weight values for 'normal' font-style.
+	 *    @type array $italic_weights  Individual font-weight values for 'italic' font-style.
+	 * }
+	 */
+	private function collect_font_weights( array $webfonts ) {
+		$normal_weights = array();
+		$italic_weights = array();
+
+		foreach ( $webfonts as $webfont ) {
+			$font_weights = $this->get_font_weights( $webfont['font-weight'] );
+			// Skip this webfont if it does not have a font-weight defined.
+			if ( empty( $font_weights ) ) {
+				continue;
+			}
+
+			// Add the individual font-weights to the end of font-style array.
+			if ( 'italic' === $webfont['font-style'] ) {
+				array_push( $italic_weights, ...$font_weights );
+			} else {
+				array_push( $normal_weights, ...$font_weights );
+			}
+		}
+
+		// Remove duplicates.
+		$normal_weights = array_unique( $normal_weights );
+		$italic_weights = array_unique( $italic_weights );
+
+		return array( $normal_weights, $italic_weights );
+	}
+
+	/**
+	 * Converts the given string of font-weight into an array of individual weight values.
+	 *
+	 * When given a single font-weight, the value is wrapped into an array.
+	 *
+	 * A range of font-weights is specified as '400 600' with the lightest value first,
+	 * a space, and then the heaviest value last.
+	 *
+	 * When given a range of font-weight values, the range is converted into individual
+	 * font-weight values. For example, a range of '400 600' is converted into
+	 * `array( 400, 500, 600 )`.
+	 *
+	 * @param string $font_weights The font-weights string.
+	 * @return array The font-weights array.
+	 */
+	private function get_font_weights( $font_weights ) {
+		$font_weights = trim( $font_weights );
+
+		// A single font-weight.
+		if ( false === strpos( $font_weights, ' ' ) ) {
+			return array( $font_weights );
+		}
+
+		// Process a range of font-weight values that are delimited by ' '.
+		$font_weights = explode( ' ', $font_weights );
+
+		// If there are 2 values, treat them as a range.
+		if ( 2 === count( $font_weights ) ) {
+			$font_weights = range( (int) $font_weights[0], (int) $font_weights[1], 100 );
+		}
+
+		return $font_weights;
+	}
+}

blockbase/vendor/automattic/jetpack-google-fonts-provider/src/class-utils.php

@@ -0,0 +1,57 @@
+<?php
+/**
+ * Google Fonts package Utils class file.
+ *
+ * @package automattic/jetpack-google-fonts-provider
+ */
+
+namespace Automattic\Jetpack\Fonts;
+
+/**
+ * Provides utility methods for the Google Fonts Provider package.
+ */
+class Utils {
+	/**
+	 * Adds a preconnect link for improving performance when downloading Google Font files.
+	 * Only do so if the site supports the Webfonts API.
+	 *
+	 * @param array  $urls          Array of resources and their attributes, or URLs to print for resource hints.
+	 * @param string $relation_type The relation type the URLs are printed for, e.g. 'preconnect' or 'prerender'.
+	 */
+	public static function font_source_resource_hint( $urls, $relation_type ) {
+		if (
+			'preconnect' === $relation_type
+			&& class_exists( 'WP_Webfonts_Provider' )
+		) {
+			$urls[] = array(
+				'href' => 'https://fonts.gstatic.com',
+				'crossorigin',
+			);
+		}
+
+		return $urls;
+	}
+
+	/**
+	 * Check if a font family is registered (verifying that it can be enqueued).
+	 *
+	 * This function will not be needed if/when WP_Webfonts provides this functionality.
+	 *
+	 * @link https://github.com/WordPress/gutenberg/pull/39988
+	 * @link https://github.com/WordPress/gutenberg/blob/e94fffae0684aa5a6dc370ce3eba262cb77071d9/lib/experimental/class-wp-webfonts.php#L217
+	 *
+	 * @param string $font_family_name Name of font family.
+	 * @return boolean|void Whether the font family is registered, or void if WP_Webfonts is not available.
+	 */
+	public static function is_font_family_registered( $font_family_name ) {
+		if ( ! function_exists( 'wp_webfonts' ) || ! method_exists( 'WP_Webfonts', 'get_font_slug' ) ) {
+			return;
+		}
+
+		$wp_webfonts = wp_webfonts();
+
+		$slug = \WP_Webfonts::get_font_slug( $font_family_name );
+
+		return isset( $wp_webfonts->get_registered_webfonts()[ $slug ] );
+	}
+}

blockbase/vendor/automattic/jetpack-google-fonts-provider/src/introspectors/class-blocks.php

@@ -0,0 +1,37 @@
+<?php
+/**
+ * Google Fonts package Blocks fonts introspector class file.
+ *
+ * @package automattic/jetpack-google-fonts-provider
+ */
+
+namespace Automattic\Jetpack\Fonts\Introspectors;
+
+use Automattic\Jetpack\Fonts\Utils;
+
+/**
+ * Blocks fonts introspector.
+ */
+class Blocks {
+	/**
+	 * Enqueue fonts used for block typography settings.
+	 *
+	 * @filter pre_render_block
+	 *
+	 * @param string|null $content The pre-rendered content. Default null.
+	 * @param array       $parsed_block The block being rendered.
+	 */
+	public static function enqueue_block_fonts( $content, $parsed_block ) {
+		if ( ! is_admin() && isset( $parsed_block['attrs']['fontFamily'] ) ) {
+
+			$block_font_family  = $parsed_block['attrs']['fontFamily'];
+			$font_is_registered = Utils::is_font_family_registered( $block_font_family );
+
+			if ( $font_is_registered ) {
+				wp_enqueue_webfont( $block_font_family );
+			}
+		}
+
+		return $content;
+	}
+}

blockbase/vendor/automattic/jetpack-google-fonts-provider/src/introspectors/class-global-styles.php

@@ -0,0 +1,115 @@
+<?php
+/**
+ * Google Fonts package Global Styles fonts introspector class file.
+ *
+ * @package automattic/jetpack-google-fonts-provider
+ */
+
+namespace Automattic\Jetpack\Fonts\Introspectors;
+
+use Automattic\Jetpack\Fonts\Utils;
+
+/**
+ * Global Styles fonts introspector.
+ */
+class Global_Styles {
+	/**
+	 * Enqueue fonts used in global styles settings.
+	 *
+	 * @return void
+	 */
+	public static function enqueue_global_styles_fonts() {
+		if ( is_admin() || ! function_exists( 'wp_enqueue_webfont' ) ) {
+			return;
+		}
+
+		$global_styles_fonts = self::collect_fonts_from_global_styles();
+
+		foreach ( $global_styles_fonts as $font ) {
+			$font_is_registered = Utils::is_font_family_registered( $font );
+
+			if ( $font_is_registered ) {
+				wp_enqueue_webfont( $font );
+			}
+		}
+	}
+
+	/**
+	 * Collect fonts set in Global Styles settings.
+	 *
+	 * @return array Font faces from Global Styles settings.
+	 */
+	public static function collect_fonts_from_global_styles() {
+		if ( ! function_exists( 'gutenberg_get_global_styles' ) ) {
+			return array();
+		}
+
+		$global_styles = gutenberg_get_global_styles();
+
+		$found_webfonts = array();
+
+		// Look for fonts in block presets...
+		if ( isset( $global_styles['blocks'] ) ) {
+			foreach ( $global_styles['blocks'] as $setting ) {
+				$font_slug = self::extract_font_slug_from_setting( $setting );
+
+				if ( $font_slug ) {
+					$found_webfonts[] = $font_slug;
+				}
+			}
+		}
+
+		// Look for fonts in HTML element presets...
+		if ( isset( $global_styles['elements'] ) ) {
+			foreach ( $global_styles['elements'] as $setting ) {
+				$font_slug = self::extract_font_slug_from_setting( $setting );
+
+				if ( $font_slug ) {
+					$found_webfonts[] = $font_slug;
+				}
+			}
+		}
+
+		// Check if a global typography setting was defined.
+		$font_slug = self::extract_font_slug_from_setting( $global_styles );
+
+		if ( $font_slug ) {
+			$found_webfonts[] = $font_slug;
+		}
+
+		return $found_webfonts;
+	}
+
+	/**
+	 * Extract the font family slug from a settings array.
+	 *
+	 * @param array $setting The settings object.
+	 *
+	 * @return string|null
+	 */
+	protected static function extract_font_slug_from_setting( $setting ) {
+		if ( ! isset( $setting['typography']['fontFamily'] ) ) {
+			return null;
+		}
+
+		$font_family = $setting['typography']['fontFamily'];
+
+		// Full string: var(--wp--preset--font-family--slug).
+		// We do not care about the origin of the font, only its slug.
+		preg_match( '/font-family--(?P<slug>.+)\)$/', $font_family, $matches );
+
+		if ( isset( $matches['slug'] ) ) {
+			return $matches['slug'];
+		}
+
+		// Full string: var:preset|font-family|slug
+		// We do not care about the origin of the font, only its slug.
+		preg_match( '/font-family\|(?P<slug>.+)$/', $font_family, $matches );
+
+		if ( isset( $matches['slug'] ) ) {
+			return $matches['slug'];
+		}
+
+		return $font_family;
+	}
+}

blockbase/vendor/composer/ClassLoader.php

@@ -0,0 +1,572 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Autoload;
+
+/**
+ * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
+ *
+ *     $loader = new \Composer\Autoload\ClassLoader();
+ *
+ *     // register classes with namespaces
+ *     $loader->add('Symfony\Component', __DIR__.'/component');
+ *     $loader->add('Symfony',           __DIR__.'/framework');
+ *
+ *     // activate the autoloader
+ *     $loader->register();
+ *
+ *     // to enable searching the include path (eg. for PEAR packages)
+ *     $loader->setUseIncludePath(true);
+ *
+ * In this example, if you try to use a class in the Symfony\Component
+ * namespace or one of its children (Symfony\Component\Console for instance),
+ * the autoloader will first look for the class under the component/
+ * directory, and it will then fallback to the framework/ directory if not
+ * found before giving up.
+ *
+ * This class is loosely based on the Symfony UniversalClassLoader.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @see    https://www.php-fig.org/psr/psr-0/
+ * @see    https://www.php-fig.org/psr/psr-4/
+ */
+class ClassLoader
+{
+    /** @var ?string */
+    private $vendorDir;
+
+    // PSR-4
+    /**
+     * @var array[]
+     * @psalm-var array<string, array<string, int>>
+     */
+    private $prefixLengthsPsr4 = array();
+    /**
+     * @var array[]
+     * @psalm-var array<string, array<int, string>>
+     */
+    private $prefixDirsPsr4 = array();
+    /**
+     * @var array[]
+     * @psalm-var array<string, string>
+     */
+    private $fallbackDirsPsr4 = array();
+
+    // PSR-0
+    /**
+     * @var array[]
+     * @psalm-var array<string, array<string, string[]>>
+     */
+    private $prefixesPsr0 = array();
+    /**
+     * @var array[]
+     * @psalm-var array<string, string>
+     */
+    private $fallbackDirsPsr0 = array();
+
+    /** @var bool */
+    private $useIncludePath = false;
+
+    /**
+     * @var string[]
+     * @psalm-var array<string, string>
+     */
+    private $classMap = array();
+
+    /** @var bool */
+    private $classMapAuthoritative = false;
+
+    /**
+     * @var bool[]
+     * @psalm-var array<string, bool>
+     */
+    private $missingClasses = array();
+
+    /** @var ?string */
+    private $apcuPrefix;
+
+    /**
+     * @var self[]
+     */
+    private static $registeredLoaders = array();
+
+    /**
+     * @param ?string $vendorDir
+     */
+    public function __construct($vendorDir = null)
+    {
+        $this->vendorDir = $vendorDir;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getPrefixes()
+    {
+        if (!empty($this->prefixesPsr0)) {
+            return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
+        }
+
+        return array();
+    }
+
+    /**
+     * @return array[]
+     * @psalm-return array<string, array<int, string>>
+     */
+    public function getPrefixesPsr4()
+    {
+        return $this->prefixDirsPsr4;
+    }
+
+    /**
+     * @return array[]
+     * @psalm-return array<string, string>
+     */
+    public function getFallbackDirs()
+    {
+        return $this->fallbackDirsPsr0;
+    }
+
+    /**
+     * @return array[]
+     * @psalm-return array<string, string>
+     */
+    public function getFallbackDirsPsr4()
+    {
+        return $this->fallbackDirsPsr4;
+    }
+
+    /**
+     * @return string[] Array of classname => path
+     * @psalm-return array<string, string>
+     */
+    public function getClassMap()
+    {
+        return $this->classMap;
+    }
+
+    /**
+     * @param string[] $classMap Class to filename map
+     * @psalm-param array<string, string> $classMap
+     *
+     * @return void
+     */
+    public function addClassMap(array $classMap)
+    {
+        if ($this->classMap) {
+            $this->classMap = array_merge($this->classMap, $classMap);
+        } else {
+            $this->classMap = $classMap;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix, either
+     * appending or prepending to the ones previously set for this prefix.
+     *
+     * @param string          $prefix  The prefix
+     * @param string[]|string $paths   The PSR-0 root directories
+     * @param bool            $prepend Whether to prepend the directories
+     *
+     * @return void
+     */
+    public function add($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            if ($prepend) {
+                $this->fallbackDirsPsr0 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr0
+                );
+            } else {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $this->fallbackDirsPsr0,
+                    (array) $paths
+                );
+            }
+
+            return;
+        }
+
+        $first = $prefix[0];
+        if (!isset($this->prefixesPsr0[$first][$prefix])) {
+            $this->prefixesPsr0[$first][$prefix] = (array) $paths;
+
+            return;
+        }
+        if ($prepend) {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixesPsr0[$first][$prefix]
+            );
+        } else {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $this->prefixesPsr0[$first][$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace, either
+     * appending or prepending to the ones previously set for this namespace.
+     *
+     * @param string          $prefix  The prefix/namespace, with trailing '\\'
+     * @param string[]|string $paths   The PSR-4 base directories
+     * @param bool            $prepend Whether to prepend the directories
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public function addPsr4($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            // Register directories for the root namespace.
+            if ($prepend) {
+                $this->fallbackDirsPsr4 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr4
+                );
+            } else {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $this->fallbackDirsPsr4,
+                    (array) $paths
+                );
+            }
+        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
+            // Register directories for a new namespace.
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        } elseif ($prepend) {
+            // Prepend directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixDirsPsr4[$prefix]
+            );
+        } else {
+            // Append directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $this->prefixDirsPsr4[$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix,
+     * replacing any others previously set for this prefix.
+     *
+     * @param string          $prefix The prefix
+     * @param string[]|string $paths  The PSR-0 base directories
+     *
+     * @return void
+     */
+    public function set($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr0 = (array) $paths;
+        } else {
+            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace,
+     * replacing any others previously set for this namespace.
+     *
+     * @param string          $prefix The prefix/namespace, with trailing '\\'
+     * @param string[]|string $paths  The PSR-4 base directories
+     *
+     * @throws \InvalidArgumentException
+     *
+     * @return void
+     */
+    public function setPsr4($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr4 = (array) $paths;
+        } else {
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Turns on searching the include path for class files.
+     *
+     * @param bool $useIncludePath
+     *
+     * @return void
+     */
+    public function setUseIncludePath($useIncludePath)
+    {
+        $this->useIncludePath = $useIncludePath;
+    }
+
+    /**
+     * Can be used to check if the autoloader uses the include path to check
+     * for classes.
+     *
+     * @return bool
+     */
+    public function getUseIncludePath()
+    {
+        return $this->useIncludePath;
+    }
+
+    /**
+     * Turns off searching the prefix and fallback directories for classes
+     * that have not been registered with the class map.
+     *
+     * @param bool $classMapAuthoritative
+     *
+     * @return void
+     */
+    public function setClassMapAuthoritative($classMapAuthoritative)
+    {
+        $this->classMapAuthoritative = $classMapAuthoritative;
+    }
+
+    /**
+     * Should class lookup fail if not found in the current class map?
+     *
+     * @return bool
+     */
+    public function isClassMapAuthoritative()
+    {
+        return $this->classMapAuthoritative;
+    }
+
+    /**
+     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+     *
+     * @param string|null $apcuPrefix
+     *
+     * @return void
+     */
+    public function setApcuPrefix($apcuPrefix)
+    {
+        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
+    }
+
+    /**
+     * The APCu prefix in use, or null if APCu caching is not enabled.
+     *
+     * @return string|null
+     */
+    public function getApcuPrefix()
+    {
+        return $this->apcuPrefix;
+    }
+
+    /**
+     * Registers this instance as an autoloader.
+     *
+     * @param bool $prepend Whether to prepend the autoloader or not
+     *
+     * @return void
+     */
+    public function register($prepend = false)
+    {
+        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
+
+        if (null === $this->vendorDir) {
+            return;
+        }
+
+        if ($prepend) {
+            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
+        } else {
+            unset(self::$registeredLoaders[$this->vendorDir]);
+            self::$registeredLoaders[$this->vendorDir] = $this;
+        }
+    }
+
+    /**
+     * Unregisters this instance as an autoloader.
+     *
+     * @return void
+     */
+    public function unregister()
+    {
+        spl_autoload_unregister(array($this, 'loadClass'));
+
+        if (null !== $this->vendorDir) {
+            unset(self::$registeredLoaders[$this->vendorDir]);
+        }
+    }
+
+    /**
+     * Loads the given class or interface.
+     *
+     * @param  string    $class The name of the class
+     * @return true|null True if loaded, null otherwise
+     */
+    public function loadClass($class)
+    {
+        if ($file = $this->findFile($class)) {
+            includeFile($file);
+
+            return true;
+        }
+
+        return null;
+    }
+
+    /**
+     * Finds the path to the file where the class is defined.
+     *
+     * @param string $class The name of the class
+     *
+     * @return string|false The path if found, false otherwise
+     */
+    public function findFile($class)
+    {
+        // class map lookup
+        if (isset($this->classMap[$class])) {
+            return $this->classMap[$class];
+        }
+        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
+            return false;
+        }
+        if (null !== $this->apcuPrefix) {
+            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
+            if ($hit) {
+                return $file;
+            }
+        }
+
+        $file = $this->findFileWithExtension($class, '.php');
+
+        // Search for Hack files if we are running on HHVM
+        if (false === $file && defined('HHVM_VERSION')) {
+            $file = $this->findFileWithExtension($class, '.hh');
+        }
+
+        if (null !== $this->apcuPrefix) {
+            apcu_add($this->apcuPrefix.$class, $file);
+        }
+
+        if (false === $file) {
+            // Remember that this class does not exist.
+            $this->missingClasses[$class] = true;
+        }
+
+        return $file;
+    }
+
+    /**
+     * Returns the currently registered loaders indexed by their corresponding vendor directories.
+     *
+     * @return self[]
+     */
+    public static function getRegisteredLoaders()
+    {
+        return self::$registeredLoaders;
+    }
+
+    /**
+     * @param  string       $class
+     * @param  string       $ext
+     * @return string|false
+     */
+    private function findFileWithExtension($class, $ext)
+    {
+        // PSR-4 lookup
+        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
+
+        $first = $class[0];
+        if (isset($this->prefixLengthsPsr4[$first])) {
+            $subPath = $class;
+            while (false !== $lastPos = strrpos($subPath, '\\')) {
+                $subPath = substr($subPath, 0, $lastPos);
+                $search = $subPath . '\\';
+                if (isset($this->prefixDirsPsr4[$search])) {
+                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
+                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
+                        if (file_exists($file = $dir . $pathEnd)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-4 fallback dirs
+        foreach ($this->fallbackDirsPsr4 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 lookup
+        if (false !== $pos = strrpos($class, '\\')) {
+            // namespaced class name
+            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
+                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
+        } else {
+            // PEAR-like class name
+            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
+        }
+
+        if (isset($this->prefixesPsr0[$first])) {
+            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
+                if (0 === strpos($class, $prefix)) {
+                    foreach ($dirs as $dir) {
+                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-0 fallback dirs
+        foreach ($this->fallbackDirsPsr0 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 include paths.
+        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
+            return $file;
+        }
+
+        return false;
+    }
+}
+
+/**
+ * Scope isolated include.
+ *
+ * Prevents access to $this/self from included files.
+ *
+ * @param  string $file
+ * @return void
+ * @private
+ */
+function includeFile($file)
+{
+    include $file;
+}

blockbase/vendor/composer/InstalledVersions.php

@@ -0,0 +1,350 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer;
+
+use Composer\Autoload\ClassLoader;
+use Composer\Semver\VersionParser;
+
+/**
+ * This class is copied in every Composer installed project and available to all
+ *
+ * See also https://getcomposer.org/doc/07-runtime.md#installed-versions
+ *
+ * To require its presence, you can require `composer-runtime-api ^2.0`
+ */
+class InstalledVersions
+{
+    /**
+     * @var mixed[]|null
+     * @psalm-var array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}|array{}|null
+     */
+    private static $installed;
+
+    /**
+     * @var bool|null
+     */
+    private static $canGetVendors;
+
+    /**
+     * @var array[]
+     * @psalm-var array<string, array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}>
+     */
+    private static $installedByVendor = array();
+
+    /**
+     * Returns a list of all package names which are present, either by being installed, replaced or provided
+     *
+     * @return string[]
+     * @psalm-return list<string>
+     */
+    public static function getInstalledPackages()
+    {
+        $packages = array();
+        foreach (self::getInstalled() as $installed) {
+            $packages[] = array_keys($installed['versions']);
+        }
+
+        if (1 === \count($packages)) {
+            return $packages[0];
+        }
+
+        return array_keys(array_flip(\call_user_func_array('array_merge', $packages)));
+    }
+
+    /**
+     * Returns a list of all package names with a specific type e.g. 'library'
+     *
+     * @param  string   $type
+     * @return string[]
+     * @psalm-return list<string>
+     */
+    public static function getInstalledPackagesByType($type)
+    {
+        $packagesByType = array();
+
+        foreach (self::getInstalled() as $installed) {
+            foreach ($installed['versions'] as $name => $package) {
+                if (isset($package['type']) && $package['type'] === $type) {
+                    $packagesByType[] = $name;
+                }
+            }
+        }
+
+        return $packagesByType;
+    }
+
+    /**
+     * Checks whether the given package is installed
+     *
+     * This also returns true if the package name is provided or replaced by another package
+     *
+     * @param  string $packageName
+     * @param  bool   $includeDevRequirements
+     * @return bool
+     */
+    public static function isInstalled($packageName, $includeDevRequirements = true)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (isset($installed['versions'][$packageName])) {
+                return $includeDevRequirements || empty($installed['versions'][$packageName]['dev_requirement']);
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks whether the given package satisfies a version constraint
+     *
+     * e.g. If you want to know whether version 2.3+ of package foo/bar is installed, you would call:
+     *
+     *   Composer\InstalledVersions::satisfies(new VersionParser, 'foo/bar', '^2.3')
+     *
+     * @param  VersionParser $parser      Install composer/semver to have access to this class and functionality
+     * @param  string        $packageName
+     * @param  string|null   $constraint  A version constraint to check for, if you pass one you have to make sure composer/semver is required by your package
+     * @return bool
+     */
+    public static function satisfies(VersionParser $parser, $packageName, $constraint)
+    {
+        $constraint = $parser->parseConstraints($constraint);
+        $provided = $parser->parseConstraints(self::getVersionRanges($packageName));
+
+        return $provided->matches($constraint);
+    }
+
+    /**
+     * Returns a version constraint representing all the range(s) which are installed for a given package
+     *
+     * It is easier to use this via isInstalled() with the $constraint argument if you need to check
+     * whether a given version of a package is installed, and not just whether it exists
+     *
+     * @param  string $packageName
+     * @return string Version constraint usable with composer/semver
+     */
+    public static function getVersionRanges($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            $ranges = array();
+            if (isset($installed['versions'][$packageName]['pretty_version'])) {
+                $ranges[] = $installed['versions'][$packageName]['pretty_version'];
+            }
+            if (array_key_exists('aliases', $installed['versions'][$packageName])) {
+                $ranges = array_merge($ranges, $installed['versions'][$packageName]['aliases']);
+            }
+            if (array_key_exists('replaced', $installed['versions'][$packageName])) {
+                $ranges = array_merge($ranges, $installed['versions'][$packageName]['replaced']);
+            }
+            if (array_key_exists('provided', $installed['versions'][$packageName])) {
+                $ranges = array_merge($ranges, $installed['versions'][$packageName]['provided']);
+            }
+
+            return implode(' || ', $ranges);
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
+     */
+    public static function getVersion($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            if (!isset($installed['versions'][$packageName]['version'])) {
+                return null;
+            }
+
+            return $installed['versions'][$packageName]['version'];
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
+     */
+    public static function getPrettyVersion($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            if (!isset($installed['versions'][$packageName]['pretty_version'])) {
+                return null;
+            }
+
+            return $installed['versions'][$packageName]['pretty_version'];
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as reference
+     */
+    public static function getReference($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            if (!isset($installed['versions'][$packageName]['reference'])) {
+                return null;
+            }
+
+            return $installed['versions'][$packageName]['reference'];
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @param  string      $packageName
+     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as install path. Packages of type metapackages also have a null install path.
+     */
+    public static function getInstallPath($packageName)
+    {
+        foreach (self::getInstalled() as $installed) {
+            if (!isset($installed['versions'][$packageName])) {
+                continue;
+            }
+
+            return isset($installed['versions'][$packageName]['install_path']) ? $installed['versions'][$packageName]['install_path'] : null;
+        }
+
+        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+    }
+
+    /**
+     * @return array
+     * @psalm-return array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}
+     */
+    public static function getRootPackage()
+    {
+        $installed = self::getInstalled();
+
+        return $installed[0]['root'];
+    }
+
+    /**
+     * Returns the raw installed.php data for custom implementations
+     *
+     * @deprecated Use getAllRawData() instead which returns all datasets for all autoloaders present in the process. getRawData only returns the first dataset loaded, which may not be what you expect.
+     * @return array[]
+     * @psalm-return array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}
+     */
+    public static function getRawData()
+    {
+        @trigger_error('getRawData only returns the first dataset loaded, which may not be what you expect. Use getAllRawData() instead which returns all datasets for all autoloaders present in the process.', E_USER_DEPRECATED);
+
+        if (null === self::$installed) {
+            // only require the installed.php file if this file is loaded from its dumped location,
+            // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
+            if (substr(__DIR__, -8, 1) !== 'C') {
+                self::$installed = include __DIR__ . '/installed.php';
+            } else {
+                self::$installed = array();
+            }
+        }
+
+        return self::$installed;
+    }
+
+    /**
+     * Returns the raw data of all installed.php which are currently loaded for custom implementations
+     *
+     * @return array[]
+     * @psalm-return list<array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}>
+     */
+    public static function getAllRawData()
+    {
+        return self::getInstalled();
+    }
+
+    /**
+     * Lets you reload the static array from another file
+     *
+     * This is only useful for complex integrations in which a project needs to use
+     * this class but then also needs to execute another project's autoloader in process,
+     * and wants to ensure both projects have access to their version of installed.php.
+     *
+     * A typical case would be PHPUnit, where it would need to make sure it reads all
+     * the data it needs from this class, then call reload() with
+     * `require $CWD/vendor/composer/installed.php` (or similar) as input to make sure
+     * the project in which it runs can then also use this class safely, without
+     * interference between PHPUnit's dependencies and the project's dependencies.
+     *
+     * @param  array[] $data A vendor/composer/installed.php data set
+     * @return void
+     *
+     * @psalm-param array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>} $data
+     */
+    public static function reload($data)
+    {
+        self::$installed = $data;
+        self::$installedByVendor = array();
+    }
+
+    /**
+     * @return array[]
+     * @psalm-return list<array{root: array{name: string, version: string, reference: string, pretty_version: string, aliases: string[], dev: bool, install_path: string, type: string}, versions: array<string, array{dev_requirement: bool, pretty_version?: string, version?: string, aliases?: string[], reference?: string, replaced?: string[], provided?: string[], install_path?: string, type?: string}>}>
+     */
+    private static function getInstalled()
+    {
+        if (null === self::$canGetVendors) {
+            self::$canGetVendors = method_exists('Composer\Autoload\ClassLoader', 'getRegisteredLoaders');
+        }
+
+        $installed = array();
+
+        if (self::$canGetVendors) {
+            foreach (ClassLoader::getRegisteredLoaders() as $vendorDir => $loader) {
+                if (isset(self::$installedByVendor[$vendorDir])) {
+                    $installed[] = self::$installedByVendor[$vendorDir];
+                } elseif (is_file($vendorDir.'/composer/installed.php')) {
+                    $installed[] = self::$installedByVendor[$vendorDir] = require $vendorDir.'/composer/installed.php';
+                    if (null === self::$installed && strtr($vendorDir.'/composer', '\\', '/') === strtr(__DIR__, '\\', '/')) {
+                        self::$installed = $installed[count($installed) - 1];
+                    }
+                }
+            }
+        }
+
+        if (null === self::$installed) {
+            // only require the installed.php file if this file is loaded from its dumped location,
+            // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
+            if (substr(__DIR__, -8, 1) !== 'C') {
+                self::$installed = require __DIR__ . '/installed.php';
+            } else {
+                self::$installed = array();
+            }
+        }
+        $installed[] = self::$installed;
+
+        return $installed;
+    }
+}

blockbase/vendor/composer/LICENSE

@@ -0,0 +1,21 @@
+
+Copyright (c) Nils Adermann, Jordi Boggiano
+
+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.
+

blockbase/vendor/composer/autoload_classmap.php

@@ -0,0 +1,14 @@
+<?php
+
+// autoload_classmap.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'Automattic\\Jetpack\\Fonts\\Google_Fonts_Provider' => $vendorDir . '/automattic/jetpack-google-fonts-provider/src/class-google-fonts-provider.php',
+    'Automattic\\Jetpack\\Fonts\\Introspectors\\Blocks' => $vendorDir . '/automattic/jetpack-google-fonts-provider/src/introspectors/class-blocks.php',
+    'Automattic\\Jetpack\\Fonts\\Introspectors\\Global_Styles' => $vendorDir . '/automattic/jetpack-google-fonts-provider/src/introspectors/class-global-styles.php',
+    'Automattic\\Jetpack\\Fonts\\Utils' => $vendorDir . '/automattic/jetpack-google-fonts-provider/src/class-utils.php',
+    'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
+);

blockbase/vendor/composer/autoload_namespaces.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

blockbase/vendor/composer/autoload_psr4.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

blockbase/vendor/composer/autoload_real.php

@@ -0,0 +1,55 @@
+<?php
+
+// autoload_real.php @generated by Composer
+
+class ComposerAutoloaderInit0777abd23b9615aca0bf30e3e2b460bb
+{
+    private static $loader;
+
+    public static function loadClassLoader($class)
+    {
+        if ('Composer\Autoload\ClassLoader' === $class) {
+            require __DIR__ . '/ClassLoader.php';
+        }
+    }
+
+    /**
+     * @return \Composer\Autoload\ClassLoader
+     */
+    public static function getLoader()
+    {
+        if (null !== self::$loader) {
+            return self::$loader;
+        }
+
+        spl_autoload_register(array('ComposerAutoloaderInit0777abd23b9615aca0bf30e3e2b460bb', 'loadClassLoader'), true, true);
+        self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(\dirname(__FILE__)));
+        spl_autoload_unregister(array('ComposerAutoloaderInit0777abd23b9615aca0bf30e3e2b460bb', 'loadClassLoader'));
+
+        $useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
+        if ($useStaticLoader) {
+            require __DIR__ . '/autoload_static.php';
+
+            call_user_func(\Composer\Autoload\ComposerStaticInit0777abd23b9615aca0bf30e3e2b460bb::getInitializer($loader));
+        } else {
+            $map = require __DIR__ . '/autoload_namespaces.php';
+            foreach ($map as $namespace => $path) {
+                $loader->set($namespace, $path);
+            }
+
+            $map = require __DIR__ . '/autoload_psr4.php';
+            foreach ($map as $namespace => $path) {
+                $loader->setPsr4($namespace, $path);
+            }
+
+            $classMap = require __DIR__ . '/autoload_classmap.php';
+            if ($classMap) {
+                $loader->addClassMap($classMap);
+            }
+        }
+
+        $loader->register(true);
+
+        return $loader;
+    }
+}

blockbase/vendor/composer/autoload_static.php

@@ -0,0 +1,24 @@
+<?php
+
+// autoload_static.php @generated by Composer
+
+namespace Composer\Autoload;
+
+class ComposerStaticInit0777abd23b9615aca0bf30e3e2b460bb
+{
+    public static $classMap = array (
+        'Automattic\\Jetpack\\Fonts\\Google_Fonts_Provider' => __DIR__ . '/..' . '/automattic/jetpack-google-fonts-provider/src/class-google-fonts-provider.php',
+        'Automattic\\Jetpack\\Fonts\\Introspectors\\Blocks' => __DIR__ . '/..' . '/automattic/jetpack-google-fonts-provider/src/introspectors/class-blocks.php',
+        'Automattic\\Jetpack\\Fonts\\Introspectors\\Global_Styles' => __DIR__ . '/..' . '/automattic/jetpack-google-fonts-provider/src/introspectors/class-global-styles.php',
+        'Automattic\\Jetpack\\Fonts\\Utils' => __DIR__ . '/..' . '/automattic/jetpack-google-fonts-provider/src/class-utils.php',
+        'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php',
+    );
+
+    public static function getInitializer(ClassLoader $loader)
+    {
+        return \Closure::bind(function () use ($loader) {
+            $loader->classMap = ComposerStaticInit0777abd23b9615aca0bf30e3e2b460bb::$classMap;
+
+        }, null, ClassLoader::class);
+    }
+}

blockbase/vendor/composer/installed.json

@@ -0,0 +1,55 @@
+{
+    "packages": [
+        {
+            "name": "automattic/jetpack-google-fonts-provider",
+            "version": "v0.3.0",
+            "version_normalized": "0.3.0.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/Automattic/jetpack-google-fonts-provider.git",
+                "reference": "cc26c71d0156bcdce80552cb7f084c23b5fe7be4"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/Automattic/jetpack-google-fonts-provider/zipball/cc26c71d0156bcdce80552cb7f084c23b5fe7be4",
+                "reference": "cc26c71d0156bcdce80552cb7f084c23b5fe7be4",
+                "shasum": ""
+            },
+            "require-dev": {
+                "automattic/jetpack-changelogger": "^3.1",
+                "brain/monkey": "2.6.1",
+                "yoast/phpunit-polyfills": "1.0.3"
+            },
+            "time": "2022-04-26T14:33:32+00:00",
+            "type": "jetpack-library",
+            "extra": {
+                "autotagger": true,
+                "mirror-repo": "Automattic/jetpack-google-fonts-provider",
+                "changelogger": {
+                    "link-template": "https://github.com/Automattic/jetpack-google-fonts-provider/compare/v${old}...v${new}"
+                },
+                "branch-alias": {
+                    "dev-master": "0.3.x-dev"
+                },
+                "textdomain": "jetpack-google-fonts-provider"
+            },
+            "installation-source": "dist",
+            "autoload": {
+                "classmap": [
+                    "src/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "GPL-2.0-or-later"
+            ],
+            "description": "WordPress Webfonts provider for Google Fonts",
+            "support": {
+                "source": "https://github.com/Automattic/jetpack-google-fonts-provider/tree/v0.3.0"
+            },
+            "install-path": "../automattic/jetpack-google-fonts-provider"
+        }
+    ],
+    "dev": true,
+    "dev-package-names": []
+}

blockbase/vendor/composer/installed.php

@@ -0,0 +1,32 @@
+<?php return array(
+    'root' => array(
+        'pretty_version' => 'dev-trunk',
+        'version' => 'dev-trunk',
+        'type' => 'project',
+        'install_path' => __DIR__ . '/../../',
+        'aliases' => array(),
+        'reference' => '090426a9c2af3d685443c079e5e3368550a4d51c',
+        'name' => 'automattic/blockbase',
+        'dev' => true,
+    ),
+    'versions' => array(
+        'automattic/blockbase' => array(
+            'pretty_version' => 'dev-trunk',
+            'version' => 'dev-trunk',
+            'type' => 'project',
+            'install_path' => __DIR__ . '/../../',
+            'aliases' => array(),
+            'reference' => '090426a9c2af3d685443c079e5e3368550a4d51c',
+            'dev_requirement' => false,
+        ),
+        'automattic/jetpack-google-fonts-provider' => array(
+            'pretty_version' => 'v0.3.0',
+            'version' => '0.3.0.0',
+            'type' => 'jetpack-library',
+            'install_path' => __DIR__ . '/../automattic/jetpack-google-fonts-provider',
+            'aliases' => array(),
+            'reference' => 'cc26c71d0156bcdce80552cb7f084c23b5fe7be4',
+            'dev_requirement' => false,
+        ),
+    ),
+);