ccgauge 1.1.1 → 1.1.2

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/get-fallback-font-override-metrics.js

@@ -1,62 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFallbackFontOverrideMetrics = getFallbackFontOverrideMetrics;
-// @ts-ignore
-const font_utils_1 = require("next/dist/server/font-utils");
-// @ts-ignore
-const Log = __importStar(require("next/dist/build/output/log"));
-/**
- * Get precalculated fallback font metrics for the Google Fonts family.
- *
- * TODO:
- * We might want to calculate these values with fontkit instead (like in next/font/local).
- * That way we don't have to update the precalculated values every time a new font is added to Google Fonts.
- */
-function getFallbackFontOverrideMetrics(fontFamily) {
-    try {
-        const { ascent, descent, lineGap, fallbackFont, sizeAdjust } = (0, font_utils_1.calculateSizeAdjustValues)(fontFamily);
-        return {
-            fallbackFont,
-            ascentOverride: `${ascent}%`,
-            descentOverride: `${descent}%`,
-            lineGapOverride: `${lineGap}%`,
-            sizeAdjust: `${sizeAdjust}%`,
-        };
-    }
-    catch {
-        Log.error(`Failed to find font override values for font \`${fontFamily}\``);
-    }
-}

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/get-font-axes.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFontAxes = getFontAxes;
-const format_available_values_1 = require("../format-available-values");
-const next_font_error_1 = require("../next-font-error");
-const google_fonts_metadata_1 = require("./google-fonts-metadata");
-/**
- * Validates and gets the data for each font axis required to generate the Google Fonts URL.
- */
-function getFontAxes(fontFamily, weights, styles, selectedVariableAxes) {
-    const hasItalic = styles.includes('italic');
-    const hasNormal = styles.includes('normal');
-    // Make sure the order is correct, otherwise Google Fonts will return an error
-    // If only normal is set, we can skip returning the ital axis as normal is the default
-    const ital = hasItalic ? [...(hasNormal ? ['0'] : []), '1'] : undefined;
-    // Weights will always contain one element if it's a variable font
-    if (weights[0] === 'variable') {
-        // Get all the available axes for the current font from the metadata file
-        const allAxes = google_fonts_metadata_1.googleFontsMetadata[fontFamily].axes;
-        if (!allAxes) {
-            throw new Error('invariant variable font without axes');
-        }
-        if (selectedVariableAxes) {
-            // The axes other than weight and style that can be defined for the current variable font
-            const defineAbleAxes = allAxes
-                .map(({ tag }) => tag)
-                .filter((tag) => tag !== 'wght');
-            if (defineAbleAxes.length === 0) {
-                (0, next_font_error_1.nextFontError)(`Font \`${fontFamily}\` has no definable \`axes\``);
-            }
-            if (!Array.isArray(selectedVariableAxes)) {
-                (0, next_font_error_1.nextFontError)(`Invalid axes value for font \`${fontFamily}\`, expected an array of axes.\nAvailable axes: ${(0, format_available_values_1.formatAvailableValues)(defineAbleAxes)}`);
-            }
-            selectedVariableAxes.forEach((key) => {
-                if (!defineAbleAxes.some((tag) => tag === key)) {
-                    (0, next_font_error_1.nextFontError)(`Invalid axes value \`${key}\` for font \`${fontFamily}\`.\nAvailable axes: ${(0, format_available_values_1.formatAvailableValues)(defineAbleAxes)}`);
-                }
-            });
-        }
-        let weightAxis;
-        let variableAxes;
-        for (const { tag, min, max } of allAxes) {
-            if (tag === 'wght') {
-                // In variable fonts the weight is a range
-                weightAxis = `${min}..${max}`;
-            }
-            else if (selectedVariableAxes === null || selectedVariableAxes === void 0 ? void 0 : selectedVariableAxes.includes(tag)) {
-                if (!variableAxes) {
-                    variableAxes = [];
-                }
-                variableAxes.push([tag, `${min}..${max}`]);
-            }
-        }
-        return {
-            wght: weightAxis ? [weightAxis] : undefined,
-            ital,
-            variableAxes,
-        };
-    }
-    else {
-        return {
-            ital,
-            wght: weights,
-        };
-    }
-}

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/get-google-fonts-url.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGoogleFontsUrl = getGoogleFontsUrl;
-const sort_fonts_variant_values_1 = require("./sort-fonts-variant-values");
-/**
- * Generate the Google Fonts URL given the requested weight(s), style(s) and additional variable axes
- */
-function getGoogleFontsUrl(fontFamily, axes, display) {
-    var _a, _b;
-    // Variants are all combinations of weight and style, each variant will result in a separate font file
-    const variants = [];
-    if (axes.wght) {
-        for (const wght of axes.wght) {
-            if (!axes.ital) {
-                variants.push([['wght', wght], ...((_a = axes.variableAxes) !== null && _a !== void 0 ? _a : [])]);
-            }
-            else {
-                for (const ital of axes.ital) {
-                    variants.push([
-                        ['ital', ital],
-                        ['wght', wght],
-                        ...((_b = axes.variableAxes) !== null && _b !== void 0 ? _b : []),
-                    ]);
-                }
-            }
-        }
-    }
-    else if (axes.variableAxes) {
-        // Variable fonts might not have a range of weights, just add optional variable axes in that case
-        variants.push([...axes.variableAxes]);
-    }
-    // Google api requires the axes to be sorted, starting with lowercase words
-    if (axes.variableAxes) {
-        variants.forEach((variant) => {
-            variant.sort(([a], [b]) => {
-                const aIsLowercase = a.charCodeAt(0) > 96;
-                const bIsLowercase = b.charCodeAt(0) > 96;
-                if (aIsLowercase && !bIsLowercase)
-                    return -1;
-                if (bIsLowercase && !aIsLowercase)
-                    return 1;
-                return a > b ? 1 : -1;
-            });
-        });
-    }
-    let url = `https://fonts.googleapis.com/css2?family=${fontFamily.replace(/ /g, '+')}`;
-    if (variants.length > 0) {
-        url = `${url}:${variants[0].map(([key]) => key).join(',')}@${variants
-            .map((variant) => variant.map(([, val]) => val).join(','))
-            .sort(sort_fonts_variant_values_1.sortFontsVariantValues)
-            .join(';')}`;
-    }
-    url = `${url}&display=${display}`;
-    return url;
-}

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/get-proxy-agent.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProxyAgent = getProxyAgent;
-// @ts-ignore
-const https_proxy_agent_1 = __importDefault(require("next/dist/compiled/https-proxy-agent"));
-// @ts-ignore
-const http_proxy_agent_1 = __importDefault(require("next/dist/compiled/http-proxy-agent"));
-/**
- * If the http(s)_proxy environment variables is set, return a proxy agent.
- */
-function getProxyAgent() {
-    const httpsProxy = process.env['https_proxy'] || process.env['HTTPS_PROXY'];
-    if (httpsProxy) {
-        return new https_proxy_agent_1.default(httpsProxy);
-    }
-    const httpProxy = process.env['http_proxy'] || process.env['HTTP_PROXY'];
-    if (httpProxy) {
-        return new http_proxy_agent_1.default(httpProxy);
-    }
-}

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/google-fonts-metadata.js

@@ -1,8 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.googleFontsMetadata = void 0;
-const font_data_json_1 = __importDefault(require("./font-data.json"));
-exports.googleFontsMetadata = font_data_json_1.default;

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/loader.js

@@ -1,175 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-ignore
-const Log = __importStar(require("next/dist/build/output/log"));
-const validate_google_font_function_call_1 = require("./validate-google-font-function-call");
-const get_font_axes_1 = require("./get-font-axes");
-const get_google_fonts_url_1 = require("./get-google-fonts-url");
-const next_font_error_1 = require("../next-font-error");
-const find_font_files_in_css_1 = require("./find-font-files-in-css");
-const get_fallback_font_override_metrics_1 = require("./get-fallback-font-override-metrics");
-const fetch_css_from_google_fonts_1 = require("./fetch-css-from-google-fonts");
-const fetch_font_file_1 = require("./fetch-font-file");
-const cssCache = new Map();
-const fontCache = new Map();
-// regexp is based on https://github.com/sindresorhus/escape-string-regexp
-const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
-const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
-function escapeStringRegexp(str) {
-    // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
-    if (reHasRegExp.test(str)) {
-        return str.replace(reReplaceRegExp, '\\$&');
-    }
-    return str;
-}
-const nextFontGoogleFontLoader = async ({ functionName, data, emitFontFile, isDev, isServer, }) => {
-    var _a;
-    const { fontFamily, weights, styles, display, preload, selectedVariableAxes, fallback, adjustFontFallback, variable, subsets, } = (0, validate_google_font_function_call_1.validateGoogleFontFunctionCall)(functionName, data[0]);
-    // Validate and get the font axes required to generated the URL
-    const fontAxes = (0, get_font_axes_1.getFontAxes)(fontFamily, weights, styles, selectedVariableAxes);
-    // Generate the Google Fonts URL from the font family, axes and display value
-    const url = (0, get_google_fonts_url_1.getGoogleFontsUrl)(fontFamily, fontAxes, display);
-    // Get precalculated fallback font metrics, used to generate the fallback font CSS
-    const adjustFontFallbackMetrics = adjustFontFallback ? (0, get_fallback_font_override_metrics_1.getFallbackFontOverrideMetrics)(fontFamily) : undefined;
-    const result = {
-        fallbackFonts: fallback,
-        weight: weights.length === 1 && weights[0] !== 'variable'
-            ? weights[0]
-            : undefined,
-        style: styles.length === 1 ? styles[0] : undefined,
-        variable,
-        adjustFontFallback: adjustFontFallbackMetrics,
-    };
-    try {
-        /**
-         * Hacky way to make sure the fetch is only done once.
-         * Otherwise both the client and server compiler would fetch the CSS.
-         * The reason we need to return the actual CSS from both the server and client is because a hash is generated based on the CSS content.
-         */
-        const hasCachedCSS = cssCache.has(url);
-        // Fetch CSS from Google Fonts or get it from the cache
-        let fontFaceDeclarations = hasCachedCSS
-            ? cssCache.get(url)
-            : await (0, fetch_css_from_google_fonts_1.fetchCSSFromGoogleFonts)(url, fontFamily, isDev).catch((err) => {
-                console.error(err);
-                return null;
-            });
-        if (!hasCachedCSS) {
-            cssCache.set(url, fontFaceDeclarations !== null && fontFaceDeclarations !== void 0 ? fontFaceDeclarations : null);
-        }
-        else {
-            cssCache.delete(url);
-        }
-        if (fontFaceDeclarations == null) {
-            (0, next_font_error_1.nextFontError)(`Failed to fetch \`${fontFamily}\` from Google Fonts.`);
-        }
-        // CSS Variables may be set on a body tag, ignore them to keep the CSS module pure
-        fontFaceDeclarations = fontFaceDeclarations.split('body {', 1)[0];
-        // Find font files to download, provide the array of subsets we want to preload if preloading is enabled
-        const fontFiles = (0, find_font_files_in_css_1.findFontFilesInCss)(fontFaceDeclarations, preload ? subsets : undefined);
-        // Download the font files extracted from the CSS
-        const downloadedFiles = await Promise.all(fontFiles.map(async ({ googleFontFileUrl, preloadFontFile }) => {
-            const hasCachedFont = fontCache.has(googleFontFileUrl);
-            // Download the font file or get it from cache
-            const fontFileBuffer = hasCachedFont
-                ? fontCache.get(googleFontFileUrl)
-                : await (0, fetch_font_file_1.fetchFontFile)(googleFontFileUrl, isDev).catch((err) => {
-                    console.error(err);
-                    return null;
-                });
-            if (!hasCachedFont) {
-                fontCache.set(googleFontFileUrl, fontFileBuffer !== null && fontFileBuffer !== void 0 ? fontFileBuffer : null);
-            }
-            else {
-                fontCache.delete(googleFontFileUrl);
-            }
-            if (fontFileBuffer == null) {
-                (0, next_font_error_1.nextFontError)(`Failed to fetch \`${fontFamily}\` from Google Fonts.`);
-            }
-            const ext = /\.(woff|woff2|eot|ttf|otf)$/.exec(googleFontFileUrl)[1];
-            // Emit font file to .next/static/media
-            const selfHostedFileUrl = emitFontFile(fontFileBuffer, ext, preloadFontFile, !!adjustFontFallbackMetrics);
-            return {
-                googleFontFileUrl,
-                selfHostedFileUrl,
-            };
-        }));
-        /**
-         * Replace the @font-face sources with the self-hosted files we just downloaded to .next/static/media
-         *
-         * E.g.
-         * @font-face {
-         *   font-family: 'Inter';
-         *   src: url(https://fonts.gstatic.com/...) -> url(/_next/static/media/_.woff2)
-         * }
-         */
-        let updatedCssResponse = fontFaceDeclarations;
-        for (const { googleFontFileUrl, selfHostedFileUrl } of downloadedFiles) {
-            updatedCssResponse = updatedCssResponse.replace(new RegExp(escapeStringRegexp(googleFontFileUrl), 'g'), selfHostedFileUrl);
-        }
-        return {
-            ...result,
-            css: updatedCssResponse,
-        };
-    }
-    catch (err) {
-        if (isDev) {
-            if (isServer) {
-                Log.error(`Failed to download \`${fontFamily}\` from Google Fonts. Using fallback font instead.\n\n${err.message}}`);
-            }
-            // In dev we should return the fallback font instead of throwing an error
-            let css = `@font-face {
-  font-family: '${fontFamily} Fallback';
-  src: local("${(_a = adjustFontFallbackMetrics === null || adjustFontFallbackMetrics === void 0 ? void 0 : adjustFontFallbackMetrics.fallbackFont) !== null && _a !== void 0 ? _a : 'Arial'}");`;
-            if (adjustFontFallbackMetrics) {
-                css += `
-  ascent-override:${adjustFontFallbackMetrics.ascentOverride};
-  descent-override:${adjustFontFallbackMetrics.descentOverride};
-  line-gap-override:${adjustFontFallbackMetrics.lineGapOverride};
-  size-adjust:${adjustFontFallbackMetrics.sizeAdjust};`;
-            }
-            css += '\n}';
-            return {
-                ...result,
-                css,
-            };
-        }
-        else {
-            throw err;
-        }
-    }
-};
-exports.default = nextFontGoogleFontLoader;

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/retry.js

@@ -1,18 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retry = retry;
-// eslint-disable-next-line import/no-extraneous-dependencies
-// @ts-expect-error File exists
-const async_retry_1 = __importDefault(require("next/dist/compiled/async-retry"));
-async function retry(fn, retries) {
-    return await (0, async_retry_1.default)(fn, {
-        retries,
-        onRetry(e, attempt) {
-            console.error(e.message + `\n\nRetrying ${attempt}/${retries}...`);
-        },
-        minTimeout: 100,
-    });
-}

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/sort-fonts-variant-values.js

@@ -1,26 +0,0 @@
-"use strict";
-/**
- * Callback function for sorting font variant values.
- * Used as a parameter in `Array.prototype.sort` function to ensure correct sorting.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortFontsVariantValues = sortFontsVariantValues;
-function sortFontsVariantValues(valA, valB) {
-    // If both values contain commas, it indicates they are in "ital,wght" format
-    if (valA.includes(',') && valB.includes(',')) {
-        // Split the values into prefix and suffix
-        const [aPrefix, aSuffix] = valA.split(',', 2);
-        const [bPrefix, bSuffix] = valB.split(',', 2);
-        // Compare the prefixes (ital values)
-        if (aPrefix === bPrefix) {
-            // If prefixes are equal, then compare the suffixes (wght values)
-            return parseInt(aSuffix) - parseInt(bSuffix);
-        }
-        else {
-            // If prefixes are different, then compare the prefixes directly
-            return parseInt(aPrefix) - parseInt(bPrefix);
-        }
-    }
-    // If values are not in "ital,wght" format, then directly compare them as integers
-    return parseInt(valA) - parseInt(valB);
-}

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/google/validate-google-font-function-call.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateGoogleFontFunctionCall = validateGoogleFontFunctionCall;
-const constants_1 = require("../constants");
-const format_available_values_1 = require("../format-available-values");
-const next_font_error_1 = require("../next-font-error");
-const google_fonts_metadata_1 = require("./google-fonts-metadata");
-/**
- * Validate the data received from next-swc next-transform-font on next/font/google calls
- */
-function validateGoogleFontFunctionCall(functionName, fontFunctionArgument) {
-    let { weight, style, preload = true, display = 'swap', axes, fallback, adjustFontFallback = true, variable, subsets, } = fontFunctionArgument || {};
-    if (functionName === '') {
-        (0, next_font_error_1.nextFontError)(`next/font/google has no default export`);
-    }
-    const fontFamily = functionName.replace(/_/g, ' ');
-    // Get the Google font metadata, we'll use this to validate the font arguments and to print better error messages
-    const fontFamilyData = google_fonts_metadata_1.googleFontsMetadata[fontFamily];
-    if (!fontFamilyData) {
-        (0, next_font_error_1.nextFontError)(`Unknown font \`${fontFamily}\``);
-    }
-    const availableSubsets = fontFamilyData.subsets;
-    if (availableSubsets.length === 0) {
-        // If the font doesn't have any preloadeable subsets, disable preload
-        preload = false;
-    }
-    else if (preload) {
-        if (!subsets) {
-            (0, next_font_error_1.nextFontError)(`Preload is enabled but no subsets were specified for font \`${fontFamily}\`. Please specify subsets or disable preloading if your intended subset can't be preloaded.\nAvailable subsets: ${(0, format_available_values_1.formatAvailableValues)(availableSubsets)}\n\nRead more: https://nextjs.org/docs/messages/google-fonts-missing-subsets`);
-        }
-        subsets.forEach((subset) => {
-            if (!availableSubsets.includes(subset)) {
-                (0, next_font_error_1.nextFontError)(`Unknown subset \`${subset}\` for font \`${fontFamily}\`.\nAvailable subsets: ${(0, format_available_values_1.formatAvailableValues)(availableSubsets)}`);
-            }
-        });
-    }
-    const fontWeights = fontFamilyData.weights;
-    const fontStyles = fontFamilyData.styles;
-    // Get the unique weights and styles from the function call
-    const weights = !weight
-        ? []
-        : [...new Set(Array.isArray(weight) ? weight : [weight])];
-    const styles = !style
-        ? []
-        : [...new Set(Array.isArray(style) ? style : [style])];
-    if (weights.length === 0) {
-        // Set variable as default, throw if not available
-        if (fontWeights.includes('variable')) {
-            weights.push('variable');
-        }
-        else {
-            (0, next_font_error_1.nextFontError)(`Missing weight for font \`${fontFamily}\`.\nAvailable weights: ${(0, format_available_values_1.formatAvailableValues)(fontWeights)}`);
-        }
-    }
-    if (weights.length > 1 && weights.includes('variable')) {
-        (0, next_font_error_1.nextFontError)(`Unexpected \`variable\` in weight array for font \`${fontFamily}\`. You only need \`variable\`, it includes all available weights.`);
-    }
-    weights.forEach((selectedWeight) => {
-        if (!fontWeights.includes(selectedWeight)) {
-            (0, next_font_error_1.nextFontError)(`Unknown weight \`${selectedWeight}\` for font \`${fontFamily}\`.\nAvailable weights: ${(0, format_available_values_1.formatAvailableValues)(fontWeights)}`);
-        }
-    });
-    if (styles.length === 0) {
-        if (fontStyles.length === 1) {
-            // Handle default style for fonts that only have italic
-            styles.push(fontStyles[0]);
-        }
-        else {
-            // Otherwise set default style to normal
-            styles.push('normal');
-        }
-    }
-    styles.forEach((selectedStyle) => {
-        if (!fontStyles.includes(selectedStyle)) {
-            (0, next_font_error_1.nextFontError)(`Unknown style \`${selectedStyle}\` for font \`${fontFamily}\`.\nAvailable styles: ${(0, format_available_values_1.formatAvailableValues)(fontStyles)}`);
-        }
-    });
-    if (!constants_1.allowedDisplayValues.includes(display)) {
-        (0, next_font_error_1.nextFontError)(`Invalid display value \`${display}\` for font \`${fontFamily}\`.\nAvailable display values: ${(0, format_available_values_1.formatAvailableValues)(constants_1.allowedDisplayValues)}`);
-    }
-    if (axes) {
-        if (!fontWeights.includes('variable')) {
-            (0, next_font_error_1.nextFontError)('Axes can only be defined for variable fonts.');
-        }
-        if (weights[0] !== 'variable') {
-            (0, next_font_error_1.nextFontError)('Axes can only be defined for variable fonts when the weight property is nonexistent or set to `variable`.');
-        }
-    }
-    return {
-        fontFamily,
-        weights,
-        styles,
-        display,
-        preload,
-        selectedVariableAxes: axes,
-        fallback,
-        adjustFontFallback,
-        variable,
-        subsets,
-    };
-}

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/local/get-fallback-metrics-from-font-file.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFallbackMetricsFromFontFile = getFallbackMetricsFromFontFile;
-// The font metadata of the fallback fonts, retrieved with fontkit on system font files
-// The average width is calculated with the calcAverageWidth function below
-const DEFAULT_SANS_SERIF_FONT = {
-    name: 'Arial',
-    azAvgWidth: 934.5116279069767,
-    unitsPerEm: 2048,
-};
-const DEFAULT_SERIF_FONT = {
-    name: 'Times New Roman',
-    azAvgWidth: 854.3953488372093,
-    unitsPerEm: 2048,
-};
-/**
- * Calculate the average character width of a font file.
- * Used to calculate the size-adjust property by comparing the fallback average with the loaded font average.
- */
-function calcAverageWidth(font) {
-    try {
-        /**
-         * Finding the right characters to use when calculating the average width is tricky.
-         * We can't just use the average width of all characters, because we have to take letter frequency into account.
-         * We also have to take word length into account, because the font's space width usually differ a lot from other characters.
-         * The goal is to find a string that'll give you a good average width, given most texts in most languages.
-         *
-         * TODO: Currently only works for the latin alphabet. Support more languages by finding the right characters for additional languages.
-         *
-         * The used characters were decided through trial and error with letter frequency and word length tables as a guideline.
-         * E.g. https://en.wikipedia.org/wiki/Letter_frequency
-         */
-        const avgCharacters = 'aaabcdeeeefghiijklmnnoopqrrssttuvwxyz      ';
-        // Check if the font file has all the characters we need to calculate the average width
-        const hasAllChars = font
-            .glyphsForString(avgCharacters)
-            .flatMap((glyph) => glyph.codePoints)
-            .every((codePoint) => font.hasGlyphForCodePoint(codePoint));
-        if (!hasAllChars)
-            return undefined;
-        const widths = font
-            .glyphsForString(avgCharacters)
-            .map((glyph) => glyph.advanceWidth);
-        const totalWidth = widths.reduce((sum, width) => sum + width, 0);
-        return totalWidth / widths.length;
-    }
-    catch {
-        // Could not calculate average width from the font file, skip size-adjust
-        return undefined;
-    }
-}
-function formatOverrideValue(val) {
-    return Math.abs(val * 100).toFixed(2) + '%';
-}
-/**
- * Given a font file and category, calculate the fallback font override values.
- * The returned values can be used to generate a CSS @font-face declaration.
- *
- * For example:
- * @font-face {
- *   font-family: local-font;
- *   src: local(Arial);
- *   size-adjust: 90%;
- * }
- *
- * Read more about this technique in these texts by the Google Aurora team:
- * https://developer.chrome.com/blog/font-fallbacks/
- * https://docs.google.com/document/d/e/2PACX-1vRsazeNirATC7lIj2aErSHpK26hZ6dA9GsQ069GEbq5fyzXEhXbvByoftSfhG82aJXmrQ_sJCPBqcx_/pub
- */
-function getFallbackMetricsFromFontFile(font, category = 'serif') {
-    const fallbackFont = category === 'serif' ? DEFAULT_SERIF_FONT : DEFAULT_SANS_SERIF_FONT;
-    const azAvgWidth = calcAverageWidth(font);
-    const { ascent, descent, lineGap, unitsPerEm } = font;
-    const fallbackFontAvgWidth = fallbackFont.azAvgWidth / fallbackFont.unitsPerEm;
-    let sizeAdjust = azAvgWidth
-        ? azAvgWidth / unitsPerEm / fallbackFontAvgWidth
-        : 1;
-    return {
-        ascentOverride: formatOverrideValue(ascent / (unitsPerEm * sizeAdjust)),
-        descentOverride: formatOverrideValue(descent / (unitsPerEm * sizeAdjust)),
-        lineGapOverride: formatOverrideValue(lineGap / (unitsPerEm * sizeAdjust)),
-        fallbackFont: fallbackFont.name,
-        sizeAdjust: formatOverrideValue(sizeAdjust),
-    };
-}