npm - @percepta/kaizen - Versions diffs - 0.8.0 → 0.9.0 - Mend

@percepta/kaizen 0.8.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2295) hide show

package/dashboard/.next/standalone/node_modules/.pnpm/next@16.1.6_@opentelemetry+api@1.9.0_@playwright+test@1.58.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/next/dist/compiled/@next/font/dist/google/get-fallback-font-override-metrics.js DELETED Viewed

@@ -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}\``);
-    }
-}

@@ -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,
-        };
-    }
-}

@@ -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;
-}

@@ -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);
-    }
-}

@@ -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;

@@ -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;

@@ -1,17 +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;
-// @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,
-    });
-}

@@ -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/dashboard/.next/standalone/node_modules/.pnpm/next@16.1.6_@opentelemetry+api@1.9.0_@playwright+test@1.58.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/next/dist/compiled/@next/font/dist/google/validate-google-font-function-call.js DELETED Viewed

@@ -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/dashboard/.next/standalone/node_modules/.pnpm/next@16.1.6_@opentelemetry+api@1.9.0_@playwright+test@1.58.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/next/dist/compiled/@next/font/dist/local/get-fallback-metrics-from-font-file.js DELETED Viewed

@@ -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),
-    };
-}