Ubuntu
(() => {
// src/Utils.js
var BeaconUtils = class {
static getScreenWidth() {
return window.innerWidth || document.documentElement.clientWidth;
}
static getScreenHeight() {
return window.innerHeight || document.documentElement.clientHeight;
}
static isNotValidScreensize(is_mobile, threshold) {
const screenWidth = this.getScreenWidth();
const screenHeight = this.getScreenHeight();
const isNotValidForMobile = is_mobile && (screenWidth > threshold.width || screenHeight > threshold.height);
const isNotValidForDesktop = !is_mobile && (screenWidth < threshold.width || screenHeight < threshold.height);
return isNotValidForMobile || isNotValidForDesktop;
}
static isPageCached() {
const signature = document.documentElement.nextSibling && document.documentElement.nextSibling.data ? document.documentElement.nextSibling.data : "";
return signature && signature.includes("Debug: cached");
}
static isIntersecting(rect) {
return rect.bottom >= 0 && rect.right >= 0 && rect.top <= (window.innerHeight || document.documentElement.clientHeight) && rect.left <= (window.innerWidth || document.documentElement.clientWidth);
}
static isPageScrolled() {
return window.pageYOffset > 0 || document.documentElement.scrollTop > 0;
}
/**
* Checks if an element is visible in the viewport.
*
* This method checks if the provided element is visible in the viewport by
* considering its display, visibility, opacity, width, and height properties.
* It also excludes elements with transparent text properties.
* It returns true if the element is visible, and false otherwise.
*
* @param {Element} element - The element to check for visibility.
* @returns {boolean} True if the element is visible, false otherwise.
*/
static isElementVisible(element) {
const style = window.getComputedStyle(element);
const rect = element.getBoundingClientRect();
if (!style) {
return false;
}
if (this.hasTransparentText(element)) {
return false;
}
return !(style.display === "none" || style.visibility === "hidden" || style.opacity === "0" || rect.width === 0 || rect.height === 0);
}
/**
* Checks if an element has transparent text properties.
*
* This method checks for specific CSS properties that make text invisible,
* such as `color: transparent`, `color: rgba(..., 0)`, `color: hsla(..., 0)`,
* `color: #...00` (8-digit hex with alpha = 0), and `filter: opacity(0)`.
*
* @param {Element} element - The element to check.
* @returns {boolean} True if the element has transparent text properties, false otherwise.
*/
static hasTransparentText(element) {
const style = window.getComputedStyle(element);
if (!style) {
return false;
}
const color = style.color || "";
const filter = style.filter || "";
if (color === "transparent") {
return true;
}
const rgbaMatch = color.match(/rgba\(\d+,\s*\d+,\s*\d+,\s*0\)/);
if (rgbaMatch) {
return true;
}
const hslaMatch = color.match(/hsla\(\d+,\s*\d+%,\s*\d+%,\s*0\)/);
if (hslaMatch) {
return true;
}
const hexMatch = color.match(/#[0-9a-fA-F]{6}00/);
if (hexMatch) {
return true;
}
if (filter.includes("opacity(0)")) {
return true;
}
return false;
}
};
var Utils_default = BeaconUtils;
// src/BeaconLcp.js
var BeaconLcp = class {
constructor(config, logger) {
this.config = config;
this.performanceImages = [];
this.logger = logger;
}
async run() {
try {
const above_the_fold_images = this._generateLcpCandidates(Infinity);
if (above_the_fold_images) {
this._initWithFirstElementWithInfo(above_the_fold_images);
this._fillATFWithoutDuplications(above_the_fold_images);
}
} catch (err) {
this.errorCode = "script_error";
this.logger.logMessage("Script Error: " + err);
}
}
_generateLcpCandidates(count) {
const lcpElements = document.querySelectorAll(this.config.elements);
if (lcpElements.length <= 0) {
return [];
}
const potentialCandidates = Array.from(lcpElements);
const topCandidates = potentialCandidates.map((element) => {
if ("img" === element.nodeName.toLowerCase() && "picture" === element.parentElement.nodeName.toLowerCase()) {
return null;
}
let rect;
if ("picture" === element.nodeName.toLowerCase()) {
const imgElement = element.querySelector("img");
if (imgElement) {
rect = imgElement.getBoundingClientRect();
} else {
return null;
}
} else {
rect = element.getBoundingClientRect();
}
return {
element,
rect
};
}).filter((item) => item !== null).filter((item) => {
return item.rect.width > 0 && item.rect.height > 0 && Utils_default.isIntersecting(item.rect) && Utils_default.isElementVisible(item.element);
}).map((item) => ({
item,
area: this._getElementArea(item.rect),
elementInfo: this._getElementInfo(item.element)
})).sort((a, b) => b.area - a.area).slice(0, count);
return topCandidates.map((candidate) => ({
element: candidate.item.element,
elementInfo: candidate.elementInfo
}));
}
_getElementArea(rect) {
const visibleWidth = Math.min(rect.width, (window.innerWidth || document.documentElement.clientWidth) - rect.left);
const visibleHeight = Math.min(rect.height, (window.innerHeight || document.documentElement.clientHeight) - rect.top);
return visibleWidth * visibleHeight;
}
_getElementInfo(element) {
const nodeName = element.nodeName.toLowerCase();
const element_info = {
type: "",
src: "",
srcset: "",
sizes: "",
sources: [],
bg_set: [],
current_src: ""
};
const css_bg_url_rgx = /url\(\s*?['"]?\s*?(.+?)\s*?["']?\s*?\)/ig;
if (nodeName === "img" && element.srcset) {
element_info.type = "img-srcset";
element_info.src = element.src;
element_info.srcset = element.srcset;
element_info.sizes = element.sizes;
element_info.current_src = element.currentSrc;
} else if (nodeName === "img") {
element_info.type = "img";
element_info.src = element.src;
element_info.current_src = element.currentSrc;
} else if (nodeName === "video") {
element_info.type = "img";
const source = element.querySelector("source");
element_info.src = element.poster || (source ? source.src : "");
element_info.current_src = element_info.src;
} else if (nodeName === "svg") {
const imageElement = element.querySelector("image");
if (imageElement) {
element_info.type = "img";
element_info.src = imageElement.getAttribute("href") || "";
element_info.current_src = element_info.src;
}
} else if (nodeName === "picture") {
element_info.type = "picture";
const img = element.querySelector("img");
element_info.src = img ? img.src : "";
element_info.sources = Array.from(element.querySelectorAll("source")).map((source) => ({
srcset: source.srcset || "",
media: source.media || "",
type: source.type || "",
sizes: source.sizes || ""
}));
} else {
const computed_style = window.getComputedStyle(element, null);
const bg_props = [
computed_style.getPropertyValue("background-image"),
getComputedStyle(element, ":after").getPropertyValue("background-image"),
getComputedStyle(element, ":before").getPropertyValue("background-image")
].filter((prop) => prop !== "none");
if (bg_props.length === 0) {
return null;
}
const full_bg_prop = bg_props[0];
element_info.type = "bg-img";
if (full_bg_prop.includes("image-set(")) {
element_info.type = "bg-img-set";
}
if (!full_bg_prop || full_bg_prop === "" || full_bg_prop.includes("data:image")) {
return null;
}
const matches = [...full_bg_prop.matchAll(css_bg_url_rgx)];
element_info.bg_set = matches.map((m) => m[1] ? { src: m[1].trim() + (m[2] ? " " + m[2].trim() : "") } : {});
if (element_info.bg_set.every((item) => item.src === "")) {
element_info.bg_set = matches.map((m) => m[1] ? { src: m[1].trim() } : {});
}
if (element_info.bg_set.length <= 0) {
return null;
}
if (element_info.bg_set.length > 0) {
element_info.src = element_info.bg_set[0].src;
if (element_info.type === "bg-img-set") {
element_info.src = element_info.bg_set;
}
}
}
return element_info;
}
_initWithFirstElementWithInfo(elements) {
const firstElementWithInfo = elements.find((item) => {
return item.elementInfo !== null && (item.elementInfo.src || item.elementInfo.srcset);
});
if (!firstElementWithInfo) {
this.logger.logMessage("No LCP candidate found.");
this.performanceImages = [];
return;
}
this.performanceImages = [{
...firstElementWithInfo.elementInfo,
label: "lcp"
}];
}
_fillATFWithoutDuplications(elements) {
elements.forEach(({ element, elementInfo }) => {
if (this._isDuplicateImage(element) || !elementInfo) {
return;
}
this.performanceImages.push({ ...elementInfo, label: "above-the-fold" });
});
}
_isDuplicateImage(image) {
const elementInfo = this._getElementInfo(image);
if (elementInfo === null) {
return false;
}
const isImageOrVideo = elementInfo.type === "img" || elementInfo.type === "img-srcset" || elementInfo.type === "video";
const isBgImageOrPicture = elementInfo.type === "bg-img" || elementInfo.type === "bg-img-set" || elementInfo.type === "picture";
return (isImageOrVideo || isBgImageOrPicture) && this.performanceImages.some((item) => item.src === elementInfo.src);
}
getResults() {
return this.performanceImages;
}
};
var BeaconLcp_default = BeaconLcp;
// src/BeaconLrc.js
var BeaconLrc = class {
constructor(config, logger) {
this.config = config;
this.logger = logger;
this.lazyRenderElements = [];
}
async run() {
try {
const elementsInView = this._getLazyRenderElements();
if (elementsInView) {
this._processElements(elementsInView);
}
} catch (err) {
this.errorCode = "script_error";
this.logger.logMessage("Script Error: " + err);
}
}
_getLazyRenderElements() {
const elements = document.querySelectorAll("[data-rocket-location-hash]");
const svgUseTargets = this._getSvgUseTargets();
if (elements.length <= 0) {
return [];
}
const validElements = Array.from(elements).filter((element) => {
if (this._skipElement(element)) {
return false;
}
if (svgUseTargets.includes(element)) {
this.logger.logColoredMessage(`Element skipped because of SVG: ${element.tagName}`, "orange");
return false;
}
return true;
});
return validElements.map((element) => ({
element,
depth: this._getElementDepth(element),
distance: this._getElementDistance(element),
hash: this._getLocationHash(element)
}));
}
_getElementDepth(element) {
let depth = 0;
let parent = element.parentElement;
while (parent) {
depth++;
parent = parent.parentElement;
}
return depth;
}
_getElementDistance(element) {
const rect = element.getBoundingClientRect();
const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
return Math.max(0, rect.top + scrollTop - Utils_default.getScreenHeight());
}
_skipElement(element) {
const skipStrings = this.config.skipStrings || ["memex"];
if (!element || !element.id) return false;
return skipStrings.some((str) => element.id.toLowerCase().includes(str.toLowerCase()));
}
_shouldSkipElement(element, exclusions) {
if (!element) return false;
for (let i = 0; i < exclusions.length; i++) {
const [attribute, pattern] = exclusions[i];
const attributeValue = element.getAttribute(attribute);
if (attributeValue && new RegExp(pattern, "i").test(attributeValue)) {
return true;
}
}
return false;
}
_checkLcrConflict(element) {
const conflictingElements = [];
const computedStyle = window.getComputedStyle(element);
const validMargins = ["marginTop", "marginRight", "marginBottom", "marginLeft"];
const negativeMargins = validMargins.some((margin) => parseFloat(computedStyle[margin]) < 0);
const currentElementConflicts = negativeMargins || computedStyle.contentVisibility === "auto" || computedStyle.contentVisibility === "hidden";
if (currentElementConflicts) {
conflictingElements.push({
element,
conflicts: [
negativeMargins && "negative margin",
computedStyle.contentVisibility === "auto" && "content-visibility:auto",
computedStyle.contentVisibility === "hidden" && "content-visibility:hidden"
].filter(Boolean)
});
}
Array.from(element.children).forEach((child) => {
const childStyle = window.getComputedStyle(child);
const validMargins2 = ["marginTop", "marginRight", "marginBottom", "marginLeft"];
const childNegativeMargins = validMargins2.some((margin) => parseFloat(childStyle[margin]) < 0);
const childConflicts = childNegativeMargins || childStyle.position === "absolute" || childStyle.position === "fixed";
if (childConflicts) {
conflictingElements.push({
element: child,
conflicts: [
childNegativeMargins && "negative margin",
childStyle.position === "absolute" && "position:absolute",
childStyle.position === "fixed" && "position:fixed"
].filter(Boolean)
});
}
});
return conflictingElements;
}
_processElements(elements) {
elements.forEach(({ element, depth, distance, hash }) => {
if (this._shouldSkipElement(element, this.config.exclusions || [])) {
return;
}
if ("No hash detected" === hash) {
return;
}
const conflicts = this._checkLcrConflict(element);
if (conflicts.length > 0) {
this.logger.logMessage("Skipping element due to conflicts:", conflicts);
return;
}
const can_push_hash = element.parentElement && this._getElementDistance(element.parentElement) < this.config.lrc_threshold && distance >= this.config.lrc_threshold;
const color = can_push_hash ? "green" : distance === 0 ? "red" : "";
this.logger.logColoredMessage(`${" ".repeat(depth)}${element.tagName} (Depth: ${depth}, Distance from viewport bottom: ${distance}px)`, color);
this.logger.logColoredMessage(`${" ".repeat(depth)}Location hash: ${hash}`, color);
this.logger.logColoredMessage(`${" ".repeat(depth)}Dimensions Client Height: ${element.clientHeight}`, color);
if (can_push_hash) {
this.lazyRenderElements.push(hash);
this.logger.logMessage(`Element pushed with hash: ${hash}`);
}
});
}
_getXPath(element) {
if (element && element.id !== "") {
return `//*[@id="${element.id}"]`;
}
return this._getElementXPath(element);
}
_getElementXPath(element) {
if (element === document.body) {
return "/html/body";
}
const position = this._getElementPosition(element);
return `${this._getElementXPath(element.parentNode)}/${element.nodeName.toLowerCase()}[${position}]`;
}
_getElementPosition(element) {
let pos = 1;
let sibling = element.previousElementSibling;
while (sibling) {
if (sibling.nodeName === element.nodeName) {
pos++;
}
sibling = sibling.previousElementSibling;
}
return pos;
}
_getLocationHash(element) {
return element.hasAttribute("data-rocket-location-hash") ? element.getAttribute("data-rocket-location-hash") : "No hash detected";
}
_getSvgUseTargets() {
const useElements = document.querySelectorAll("use");
const targets = /* @__PURE__ */ new Set();
useElements.forEach((use) => {
let parent = use.parentElement;
while (parent && parent !== document.body) {
targets.add(parent);
parent = parent.parentElement;
}
});
return Array.from(targets);
}
getResults() {
return this.lazyRenderElements;
}
};
var BeaconLrc_default = BeaconLrc;
// src/BeaconPreloadFonts.js
var BeaconPreloadFonts = class {
constructor(config, logger) {
this.config = config;
this.logger = logger;
this.aboveTheFoldFonts = [];
const extensions = (Array.isArray(this.config.processed_extensions) && this.config.processed_extensions.length > 0 ? this.config.processed_extensions : ["woff", "woff2", "ttf"]).map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
this.FONT_FILE_REGEX = new RegExp(`\\.(${extensions})(\\?.*)?$`, "i");
this.EXCLUDED_TAG_NAMES = /* @__PURE__ */ new Set([
// Metadata/document head
"BASE",
"HEAD",
"LINK",
"META",
"STYLE",
"TITLE",
"SCRIPT",
// Media
"IMG",
"VIDEO",
"AUDIO",
"EMBED",
"OBJECT",
"IFRAME",
// Templating, wrappers, components, fallback
"NOSCRIPT",
"TEMPLATE",
"SLOT",
"CANVAS",
// Resources
"SOURCE",
"TRACK",
"PARAM",
// SVG references
"USE",
"SYMBOL",
// Layout work
"BR",
"HR",
"WBR",
// Obsolete/deprecated
"APPLET",
"ACRONYM",
"BGSOUND",
"BIG",
"BLINK",
"CENTER",
"FONT",
"FRAME",
"FRAMESET",
"MARQUEE",
"NOFRAMES",
"STRIKE",
"TT",
"U",
"XMP"
]);
}
/**
* Checks if a URL should be excluded from external font processing based on domain exclusions.
*
* @param {string} url - The URL to check.
* @returns {boolean} True if the URL should be excluded, false otherwise.
*/
isUrlExcludedFromExternalProcessing(url) {
if (!url) return false;
const externalFontExclusions = this.config.external_font_exclusions || [];
const preloadFontsExclusions = this.config.preload_fonts_exclusions || [];
const allExclusions = [...externalFontExclusions, ...preloadFontsExclusions];
return allExclusions.some((exclusion) => url.includes(exclusion));
}
/**
* Checks if a font family or URL should be excluded from preloading.
*
* This method determines if the provided font family or any of its URLs
* match any exclusion patterns defined in the configuration. It checks for
* exact matches and substring matches for both the font family and URLs.
*
* @param {string} fontFamily - The font family to check.
* @param {string[]} urls - Array of font file URLs to check.
* @returns {boolean} True if the font should be excluded, false otherwise.
*/
isExcluded(fontFamily, urls) {
const exclusions = this.config.preload_fonts_exclusions;
const exclusionsSet = new Set(exclusions);
if (exclusionsSet.has(fontFamily)) {
return true;
}
if (exclusions.some((exclusion) => fontFamily.includes(exclusion))) {
return true;
}
if (Array.isArray(urls) && urls.length > 0) {
if (urls.some((url) => exclusionsSet.has(url))) {
return true;
}
if (urls.some(
(url) => exclusions.some((exclusion) => url.includes(exclusion))
)) {
return true;
}
}
return false;
}
/**
* Checks if an element can be styled with font-family.
*
* This method determines if the provided element's tag name is not in the list
* of excluded tag names that cannot be styled with font-family CSS property.
*
* @param {Element} element - The element to check.
* @returns {boolean} True if the element can be styled with font-family, false otherwise.
*/
canElementBeStyledWithFontFamily(element) {
return !this.EXCLUDED_TAG_NAMES.has(element.tagName);
}
/**
* Checks if an element is visible in the viewport.
*
* This method delegates to BeaconUtils.isElementVisible() for consistent
* visibility checking across all beacons.
*
* @param {Element} element - The element to check for visibility.
* @returns {boolean} True if the element is visible, false otherwise.
*/
isElementVisible(element) {
return Utils_default.isElementVisible(element);
}
/**
* Cleans a URL by removing query parameters and fragments.
*
* This method takes a URL as input, removes any query parameters and fragments,
* and returns the cleaned URL.
*
* @param {string} url - The URL to clean.
* @returns {string} The cleaned URL.
*/
cleanUrl(url) {
try {
url = url.split("?")[0].split("#")[0];
return new URL(url, window.location.href).href;
} catch (e) {
return url;
}
}
/**
* Fetches external stylesheet links from known font providers, retrieves their CSS,
* parses them into in-memory CSSStyleSheet objects, and extracts font-family/font-face
* information into a structured object.
*
* @async
* @function externalStylesheetsDoc
* @returns {Promise<{styleSheets: CSSStyleSheet[], fontPairs: Object}>} An object containing:
* - styleSheets: Array of parsed CSSStyleSheet objects (not attached to the DOM).
* - fontPairs: An object mapping font URLs to arrays of font variation objects
* ({family, weight, style}).
*
* @example
* const { styleSheets, fontPairs } = await externalStylesheetsDoc();
* this.logger.logMessage(fontPairs);
*/
async externalStylesheetsDoc() {
function generateFontPairsFromStyleSheets(styleSheetsArray) {
const fontPairs = {};
function _extractFirstUrlFromSrc(srcValue) {
if (!srcValue) return null;
const urlMatch = srcValue.match(/url\s*\(\s*(['"]?)(.+?)\1\s*\)/);
return urlMatch ? urlMatch[2] : null;
}
function _cleanFontFamilyName(fontFamilyValue) {
if (!fontFamilyValue) return "";
return fontFamilyValue.replace(/^['"]+|['"]+$/g, "").trim();
}
if (!styleSheetsArray || !Array.isArray(styleSheetsArray)) {
console.warn(
"generateFontPairsFromStyleSheets: Input is not a valid array. Received:",
styleSheetsArray
);
return fontPairs;
}
if (styleSheetsArray.length === 0) {
return fontPairs;
}
styleSheetsArray.forEach((sheet) => {
if (sheet && sheet.cssRules) {
try {
for (const rule of sheet.cssRules) {
if (rule.type === CSSRule.FONT_FACE_RULE) {
const cssFontFaceRule = rule;
const fontFamily = _cleanFontFamilyName(
cssFontFaceRule.style.getPropertyValue("font-family")
);
const fontWeight = cssFontFaceRule.style.getPropertyValue("font-weight") || "normal";
const fontStyle = cssFontFaceRule.style.getPropertyValue("font-style") || "normal";
const src = cssFontFaceRule.style.getPropertyValue("src");
const fontUrl = _extractFirstUrlFromSrc(src);
if (fontFamily && fontUrl) {
const variation = {
family: fontFamily,
weight: fontWeight,
style: fontStyle
};
if (!fontPairs[fontUrl]) fontPairs[fontUrl] = [];
const variationExists = fontPairs[fontUrl].some(
(v) => v.family === variation.family && v.weight === variation.weight && v.style === variation.style
);
if (!variationExists) fontPairs[fontUrl].push(variation);
}
}
}
} catch (e) {
console.warn(
"Error processing CSS rules from a stylesheet:",
e,
sheet
);
}
} else if (sheet && !sheet.cssRules) {
console.warn(
"Skipping a stylesheet as its cssRules are not accessible or it is empty:",
sheet
);
}
});
return fontPairs;
}
const links = [
...document.querySelectorAll('link[rel="stylesheet"]')
].filter((link) => {
try {
const linkUrl = new URL(link.href);
const currentUrl = new URL(window.location.href);
if (linkUrl.origin === currentUrl.origin) {
return false;
}
return !this.isUrlExcludedFromExternalProcessing(link.href);
} catch (e) {
return false;
}
});
if (links.length === 0) {
this.logger.logMessage("No external CSS links found to process.");
return {
// Consistent return structure
styleSheets: [],
// The retrievable CSSStyleSheet objects
fontPairs: {}
// Processed data from these sheets
};
}
const fetchedCssPromises = links.map(
(linkElement) => fetch(linkElement.href, { mode: "cors" }).then((response) => {
if (response.ok) {
return response.text();
}
console.warn(
`Failed to fetch external CSS from ${linkElement.href}: ${response.status} ${response.statusText}`
);
return null;
}).catch((error) => {
console.error(
`Network error fetching external CSS from ${linkElement.href}:`,
error
);
return null;
})
);
const cssTexts = await Promise.all(fetchedCssPromises);
const temporaryStyleSheets = [];
cssTexts.forEach((txt) => {
if (txt && txt.trim() !== "") {
try {
const sheet = new CSSStyleSheet();
sheet.replaceSync(txt);
temporaryStyleSheets.push(sheet);
} catch (error) {
console.error(
"Could not parse fetched CSS into a stylesheet:",
error,
`
CSS (first 200 chars): ${txt.substring(0, 200)}...`
);
}
}
});
if (temporaryStyleSheets.length > 0) {
this.logger.logMessage(
`[Beacon] ${temporaryStyleSheets.length} stylesheet(s) fetched and parsed into CSSStyleSheet objects.`
);
} else {
this.logger.logMessage(
"[Beacon] No stylesheets were successfully parsed from the fetched CSS."
);
}
const processedFontPairs = generateFontPairsFromStyleSheets(temporaryStyleSheets);
return {
styleSheets: temporaryStyleSheets,
fontPairs: processedFontPairs
};
}
/**
* Asynchronously initializes and parses external font stylesheets.
*
* Fetches external font stylesheets and font pairs using `externalStylesheetsDoc`,
* then stores the parsed results in `externalParsedSheets` and `externalParsedPairs`.
* Logs the process and handles errors by resetting `externalParsedSheets` to an empty array.
*
* @async
* @returns {Promise} Resolves when external font stylesheets have been initialized.
*/
async _initializeExternalFontSheets() {
this.logger.logMessage("Initializing external font stylesheets...");
try {
const result = await this.externalStylesheetsDoc();
this.externalParsedSheets = result.styleSheets || [];
this.externalParsedPairs = result.fontPairs || [];
this.logger.logMessage(
`Successfully parsed ${this.externalParsedSheets.length} external font stylesheets.`
);
} catch (error) {
this.logger.logMessage(
"Error initializing external font stylesheets:",
error
);
this.externalParsedSheets = [];
}
}
/**
* Retrieves a map of network-loaded fonts.
*
* This method uses the Performance API to get all resource entries, filters out
* the ones that match the font file regex, and maps them to their cleaned URLs.
*
* @returns {Map} A map where each key is a cleaned URL of a font file and
* each value is the original URL of the font file.
*/
getNetworkLoadedFonts() {
return new Map(
window.performance.getEntriesByType("resource").filter((resource) => this.FONT_FILE_REGEX.test(resource.name)).map((resource) => [this.cleanUrl(resource.name), resource.name])
);
}
/**
* Retrieves font-face rules from stylesheets.
*
* This method scans all stylesheets loaded on the page and collects
* font-face rules, including their source URLs, font families, weights,
* and styles. It returns an object containing the collected font data.
*
* @returns {Promise