db-json-cli 2.0.1 → 2.0.2

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+// eslint-disable-next-line import/no-extraneous-dependencies
+let fontFromBuffer;
+try {
+    const mod = require('../fontkit').default;
+    fontFromBuffer = mod.default || mod;
+}
+catch { }
+const util_1 = require("util");
+const pick_font_file_for_fallback_generation_1 = require("./pick-font-file-for-fallback-generation");
+const get_fallback_metrics_from_font_file_1 = require("./get-fallback-metrics-from-font-file");
+const validate_local_font_function_call_1 = require("./validate-local-font-function-call");
+const nextFontLocalFontLoader = async ({ functionName, variableName, data, emitFontFile, resolve, loaderContext, }) => {
+    const { src, display, fallback, preload, variable, adjustFontFallback, declarations, weight: defaultWeight, style: defaultStyle, } = (0, validate_local_font_function_call_1.validateLocalFontFunctionCall)(functionName, data[0]);
+    // Load all font files and emit them to the .next output directory
+    // Also generate a @font-face CSS for each font file
+    const fontFiles = await Promise.all(src.map(async ({ path, style, weight, ext, format }) => {
+        const resolved = await resolve(path);
+        const fileBuffer = await (0, util_1.promisify)(loaderContext.fs.readFile)(resolved);
+        const fontUrl = emitFontFile(fileBuffer, ext, preload, typeof adjustFontFallback === 'undefined' || !!adjustFontFallback);
+        // Try to load font metadata from the font file using fontkit.
+        // The data is used to calculate the fallback font override values.
+        let fontMetadata;
+        try {
+            fontMetadata = fontFromBuffer === null || fontFromBuffer === void 0 ? void 0 : fontFromBuffer(fileBuffer);
+        }
+        catch (e) {
+            console.error(`Failed to load font file: ${resolved}\n${e}`);
+        }
+        // Get all values that should be added to the @font-face declaration
+        const fontFaceProperties = [
+            ...(declarations
+                ? declarations.map(({ prop, value }) => [prop, value])
+                : []),
+            ['font-family', variableName],
+            ['src', `url(${fontUrl}) format('${format}')`],
+            ['font-display', display],
+            ...((weight !== null && weight !== void 0 ? weight : defaultWeight)
+                ? [['font-weight', weight !== null && weight !== void 0 ? weight : defaultWeight]]
+                : []),
+            ...((style !== null && style !== void 0 ? style : defaultStyle)
+                ? [['font-style', style !== null && style !== void 0 ? style : defaultStyle]]
+                : []),
+        ];
+        // Generate the @font-face CSS from the font-face properties
+        const css = `@font-face {\n${fontFaceProperties
+            .map(([property, value]) => `${property}: ${value};`)
+            .join('\n')}\n}\n`;
+        return {
+            css,
+            fontMetadata,
+            weight,
+            style,
+        };
+    }));
+    // Calculate the fallback font override values using the font file metadata
+    let adjustFontFallbackMetrics;
+    if (adjustFontFallback !== false) {
+        const fallbackFontFile = (0, pick_font_file_for_fallback_generation_1.pickFontFileForFallbackGeneration)(fontFiles);
+        if (fallbackFontFile.fontMetadata) {
+            adjustFontFallbackMetrics = (0, get_fallback_metrics_from_font_file_1.getFallbackMetricsFromFontFile)(fallbackFontFile.fontMetadata, adjustFontFallback === 'Times New Roman' ? 'serif' : 'sans-serif');
+        }
+    }
+    return {
+        css: fontFiles.map(({ css }) => css).join('\n'),
+        fallbackFonts: fallback,
+        weight: src.length === 1 ? src[0].weight : undefined,
+        style: src.length === 1 ? src[0].style : undefined,
+        variable,
+        adjustFontFallback: adjustFontFallbackMetrics,
+    };
+};
+exports.default = nextFontLocalFontLoader;

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/local/pick-font-file-for-fallback-generation.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickFontFileForFallbackGeneration = void 0;
+const next_font_error_1 = require("../next-font-error");
+const NORMAL_WEIGHT = 400;
+const BOLD_WEIGHT = 700;
+/**
+ * Convert the weight string to a number so it can be used for comparison.
+ * Weights can be defined as a number, 'normal' or 'bold'. https://developer.mozilla.org/docs/Web/CSS/@font-face/font-weight
+ */
+function getWeightNumber(weight) {
+    return weight === 'normal'
+        ? NORMAL_WEIGHT
+        : weight === 'bold'
+            ? BOLD_WEIGHT
+            : Number(weight);
+}
+/**
+ * Get the distance from normal (400) weight for the provided weight.
+ * If it's not a variable font we can just return the distance.
+ * If it's a variable font we need to compare its weight range to 400.
+ */
+function getDistanceFromNormalWeight(weight) {
+    if (!weight)
+        return 0;
+    // If it's a variable font the weight is defined with two numbers "100 900", rather than just one "400"
+    const [firstWeight, secondWeight] = weight
+        .trim()
+        .split(/ +/)
+        .map(getWeightNumber);
+    if (Number.isNaN(firstWeight) || Number.isNaN(secondWeight)) {
+        (0, next_font_error_1.nextFontError)(`Invalid weight value in src array: \`${weight}\`.\nExpected \`normal\`, \`bold\` or a number.`);
+    }
+    // If the weight doesn't have have a second value, it's not a variable font
+    // If that's the case, just return the distance from normal weight
+    if (!secondWeight) {
+        return firstWeight - NORMAL_WEIGHT;
+    }
+    // Normal weight is within variable font range
+    if (firstWeight <= NORMAL_WEIGHT && secondWeight >= NORMAL_WEIGHT) {
+        return 0;
+    }
+    // Normal weight is outside variable font range
+    // Return the distance of normal weight to the variable font range
+    const firstWeightDistance = firstWeight - NORMAL_WEIGHT;
+    const secondWeightDistance = secondWeight - NORMAL_WEIGHT;
+    if (Math.abs(firstWeightDistance) < Math.abs(secondWeightDistance)) {
+        return firstWeightDistance;
+    }
+    return secondWeightDistance;
+}
+/**
+ * If multiple font files are provided for a font family, we need to pick one to use for the automatic fallback generation.
+ * This function returns the font file that is most likely to be used for the bulk of the text on a page.
+ *
+ * There are some assumptions here about the text on a page when picking the font file:
+ * - Most of the text will have normal weight, use the one closest to 400
+ * - Most of the text will have normal style, prefer normal over italic
+ * - If two font files have the same distance from normal weight, the thinner one will most likely be the bulk of the text
+ */
+function pickFontFileForFallbackGeneration(fontFiles) {
+    return fontFiles.reduce((usedFontFile, currentFontFile) => {
+        if (!usedFontFile)
+            return currentFontFile;
+        const usedFontDistance = getDistanceFromNormalWeight(usedFontFile.weight);
+        const currentFontDistance = getDistanceFromNormalWeight(currentFontFile.weight);
+        // Prefer normal style if they have the same weight
+        if (usedFontDistance === currentFontDistance &&
+            (typeof currentFontFile.style === 'undefined' ||
+                currentFontFile.style === 'normal')) {
+            return currentFontFile;
+        }
+        const absUsedDistance = Math.abs(usedFontDistance);
+        const absCurrentDistance = Math.abs(currentFontDistance);
+        // Use closest absolute distance to normal weight
+        if (absCurrentDistance < absUsedDistance)
+            return currentFontFile;
+        // Prefer the thinner font if both have the same absolute distance from normal weight
+        if (absUsedDistance === absCurrentDistance &&
+            currentFontDistance < usedFontDistance) {
+            return currentFontFile;
+        }
+        return usedFontFile;
+    });
+}
+exports.pickFontFileForFallbackGeneration = pickFontFileForFallbackGeneration;

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLocalFontFunctionCall = void 0;
+const constants_1 = require("../constants");
+const format_available_values_1 = require("../format-available-values");
+const next_font_error_1 = require("../next-font-error");
+const extToFormat = {
+    woff: 'woff',
+    woff2: 'woff2',
+    ttf: 'truetype',
+    otf: 'opentype',
+    eot: 'embedded-opentype',
+};
+/**
+ * Validate the data recieved from next-swc next-transform-font on next/font/local calls
+ */
+function validateLocalFontFunctionCall(functionName, fontData) {
+    if (functionName) {
+        (0, next_font_error_1.nextFontError)(`next/font/local has no named exports`);
+    }
+    let { src, display = 'swap', weight, style, fallback, preload = true, variable, adjustFontFallback, declarations, } = fontData || {};
+    if (!constants_1.allowedDisplayValues.includes(display)) {
+        (0, next_font_error_1.nextFontError)(`Invalid display value \`${display}\`.\nAvailable display values: ${(0, format_available_values_1.formatAvailableValues)(constants_1.allowedDisplayValues)}`);
+    }
+    if (!src) {
+        (0, next_font_error_1.nextFontError)('Missing required `src` property');
+    }
+    if (!Array.isArray(src)) {
+        src = [{ path: src, weight, style }];
+    }
+    else {
+        if (src.length === 0) {
+            (0, next_font_error_1.nextFontError)('Unexpected empty `src` array.');
+        }
+    }
+    src = src.map((fontFile) => {
+        var _a;
+        const ext = (_a = /\.(woff|woff2|eot|ttf|otf)$/.exec(fontFile.path)) === null || _a === void 0 ? void 0 : _a[1];
+        if (!ext) {
+            (0, next_font_error_1.nextFontError)(`Unexpected file \`${fontFile.path}\``);
+        }
+        return {
+            ...fontFile,
+            ext,
+            format: extToFormat[ext],
+        };
+    });
+    if (Array.isArray(declarations)) {
+        declarations.forEach((declaration) => {
+            if ([
+                'font-family',
+                'src',
+                'font-display',
+                'font-weight',
+                'font-style',
+            ].includes(declaration === null || declaration === void 0 ? void 0 : declaration.prop)) {
+                (0, next_font_error_1.nextFontError)(`Invalid declaration prop: \`${declaration.prop}\``);
+            }
+        });
+    }
+    return {
+        src,
+        display,
+        weight,
+        style,
+        fallback,
+        preload,
+        variable,
+        adjustFontFallback,
+        declarations,
+    };
+}
+exports.validateLocalFontFunctionCall = validateLocalFontFunctionCall;

package/.next/standalone/node_modules/next/dist/compiled/@next/font/dist/next-font-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextFontError = void 0;
+/**
+ * Throw NextFontError error. Used by the WellKnownErrorsPlugin to format errors thrown by next/font.
+ */
+function nextFontError(message) {
+    const err = new Error(message);
+    err.name = 'NextFontError';
+    throw err;
+}
+exports.nextFontError = nextFontError;

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

@@ -0,0 +1 @@
+module.exports = require('../dist/google/loader')

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

@@ -0,0 +1 @@
+module.exports = require('../dist/local/loader')

package/.next/standalone/node_modules/next/dist/compiled/@next/font/package.json

@@ -0,0 +1 @@
+{"name":"@next/font","license":"MIT","types":"dist/types.d.ts"}

package/.next/standalone/node_modules/next/dist/compiled/@next/react-refresh-utils/dist/ReactRefreshWebpackPlugin.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Shared between webpack 4 and 5:
+function injectRefreshFunctions(compilation, Template) {
+    const hookVars = compilation.mainTemplate.hooks.localVars;
+    hookVars.tap('ReactFreshWebpackPlugin', (source) => Template.asString([
+        source,
+        '',
+        '// noop fns to prevent runtime errors during initialization',
+        'if (typeof self !== "undefined") {',
+        Template.indent('self.$RefreshReg$ = function () {};'),
+        Template.indent('self.$RefreshSig$ = function () {'),
+        Template.indent(Template.indent('return function (type) {')),
+        Template.indent(Template.indent(Template.indent('return type;'))),
+        Template.indent(Template.indent('};')),
+        Template.indent('};'),
+        '}',
+    ]));
+}
+function webpack4(compiler) {
+    const { Template } = this;
+    // Webpack 4 does not have a method to handle interception of module
+    // execution.
+    // The closest thing we have to emulating this is mimicking the behavior of
+    // `strictModuleExceptionHandling` in `MainTemplate`:
+    // https://github.com/webpack/webpack/blob/4c644bf1f7cb067c748a52614500e0e2182b2700/lib/MainTemplate.js#L200
+    compiler.hooks.compilation.tap('ReactFreshWebpackPlugin', (compilation) => {
+        injectRefreshFunctions(compilation, Template);
+        const hookRequire = compilation.mainTemplate.hooks.require;
+        // @ts-ignore webpack 5 types compat
+        hookRequire.tap('ReactFreshWebpackPlugin', (source) => {
+            // Webpack 4 evaluates module code on the following line:
+            // ```
+            // modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
+            // ```
+            // https://github.com/webpack/webpack/blob/4c644bf1f7cb067c748a52614500e0e2182b2700/lib/MainTemplate.js#L200
+            const lines = source.split('\n');
+            // @ts-ignore webpack 5 types compat
+            const evalIndex = lines.findIndex((l) => l.includes('modules[moduleId].call('));
+            // Unable to find the module execution, that's OK:
+            if (evalIndex === -1) {
+                return source;
+            }
+            // Legacy CSS implementations will `eval` browser code in a Node.js
+            // context to extract CSS. For backwards compatibility, we need to check
+            // we're in a browser context before continuing.
+            return Template.asString([
+                ...lines.slice(0, evalIndex),
+                `
+        var hasRefresh = typeof self !== "undefined" && !!self.$RefreshInterceptModuleExecution$;
+        var cleanup = hasRefresh
+          ? self.$RefreshInterceptModuleExecution$(moduleId)
+          : function() {};
+        try {
+        `,
+                lines[evalIndex],
+                `
+        } finally {
+          cleanup();
+        }
+        `,
+                ...lines.slice(evalIndex + 1),
+            ]);
+        });
+    });
+}
+function webpack5(compiler) {
+    const { RuntimeGlobals, RuntimeModule, Template } = this;
+    class ReactRefreshRuntimeModule extends RuntimeModule {
+        constructor() {
+            super('react refresh', 5);
+        }
+        generate() {
+            const { runtimeTemplate } = this.compilation;
+            return Template.asString([
+                `if (${RuntimeGlobals.interceptModuleExecution}) {`,
+                `${RuntimeGlobals.interceptModuleExecution}.push(${runtimeTemplate.basicFunction('options', [
+                    `${runtimeTemplate.supportsConst() ? 'const' : 'var'} originalFactory = options.factory;`,
+                    `options.factory = ${runtimeTemplate.basicFunction('moduleObject, moduleExports, webpackRequire', [
+                        // Legacy CSS implementations will `eval` browser code in a Node.js
+                        // context to extract CSS. For backwards compatibility, we need to check
+                        // we're in a browser context before continuing.
+                        `${runtimeTemplate.supportsConst() ? 'const' : 'var'} hasRefresh = typeof self !== "undefined" && !!self.$RefreshInterceptModuleExecution$;`,
+                        `${runtimeTemplate.supportsConst() ? 'const' : 'var'} cleanup = hasRefresh ? self.$RefreshInterceptModuleExecution$(moduleObject.id) : ${runtimeTemplate.supportsArrowFunction()
+                            ? '() => {}'
+                            : 'function() {}'};`,
+                        'try {',
+                        Template.indent('originalFactory.call(this, moduleObject, moduleExports, webpackRequire);'),
+                        '} finally {',
+                        Template.indent(`cleanup();`),
+                        '}',
+                    ])}`,
+                ])})`,
+                '}',
+            ]);
+        }
+    }
+    // @ts-ignore webpack 5 types compat
+    compiler.hooks.compilation.tap('ReactFreshWebpackPlugin', (compilation) => {
+        injectRefreshFunctions(compilation, Template);
+        compilation.hooks.additionalTreeRuntimeRequirements.tap('ReactFreshWebpackPlugin', (chunk) => {
+            compilation.addRuntimeModule(chunk, new ReactRefreshRuntimeModule());
+        });
+    });
+}
+class ReactFreshWebpackPlugin {
+    constructor({ version, RuntimeGlobals, RuntimeModule, Template } = require('webpack')) {
+        this.webpackMajorVersion = parseInt(version !== null && version !== void 0 ? version : '', 10);
+        this.RuntimeGlobals = RuntimeGlobals;
+        this.RuntimeModule = RuntimeModule;
+        this.Template = Template;
+    }
+    apply(compiler) {
+        switch (this.webpackMajorVersion) {
+            case 4: {
+                webpack4.call(this, compiler);
+                break;
+            }
+            case 5: {
+                webpack5.call(this, compiler);
+                break;
+            }
+            default: {
+                throw new Error(`ReactFreshWebpackPlugin does not support webpack v${this.webpackMajorVersion}.`);
+            }
+        }
+    }
+}
+exports.default = ReactFreshWebpackPlugin;
+//# sourceMappingURL=ReactRefreshWebpackPlugin.js.map

package/.next/standalone/node_modules/next/dist/compiled/@next/react-refresh-utils/dist/internal/ReactRefreshModule.runtime.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// This function gets unwrapped into global scope, which is why we don't invert
+// if-blocks. Also, you cannot use `return`.
+function default_1() {
+    // Wrapped in an IIFE to avoid polluting the global scope
+    ;
+    (function () {
+        var _a, _b;
+        // Legacy CSS implementations will `eval` browser code in a Node.js context
+        // to extract CSS. For backwards compatibility, we need to check we're in a
+        // browser context before continuing.
+        if (typeof self !== 'undefined' &&
+            // AMP / No-JS mode does not inject these helpers:
+            '$RefreshHelpers$' in self) {
+            // @ts-ignore __webpack_module__ is global
+            var currentExports = __webpack_module__.exports;
+            // @ts-ignore __webpack_module__ is global
+            var prevSignature = (_b = (_a = __webpack_module__.hot.data) === null || _a === void 0 ? void 0 : _a.prevSignature) !== null && _b !== void 0 ? _b : null;
+            // This cannot happen in MainTemplate because the exports mismatch between
+            // templating and execution.
+            self.$RefreshHelpers$.registerExportsForReactRefresh(currentExports, __webpack_module__.id);
+            // A module can be accepted automatically based on its exports, e.g. when
+            // it is a Refresh Boundary.
+            if (self.$RefreshHelpers$.isReactRefreshBoundary(currentExports)) {
+                // Save the previous exports signature on update so we can compare the boundary
+                // signatures. We avoid saving exports themselves since it causes memory leaks (https://github.com/vercel/next.js/pull/53797)
+                __webpack_module__.hot.dispose(function (data) {
+                    data.prevSignature =
+                        self.$RefreshHelpers$.getRefreshBoundarySignature(currentExports);
+                });
+                // Unconditionally accept an update to this module, we'll check if it's
+                // still a Refresh Boundary later.
+                // @ts-ignore importMeta is replaced in the loader
+                global.importMeta.webpackHot.accept();
+                // This field is set when the previous version of this module was a
+                // Refresh Boundary, letting us know we need to check for invalidation or
+                // enqueue an update.
+                if (prevSignature !== null) {
+                    // A boundary can become ineligible if its exports are incompatible
+                    // with the previous exports.
+                    //
+                    // For example, if you add/remove/change exports, we'll want to
+                    // re-execute the importing modules, and force those components to
+                    // re-render. Similarly, if you convert a class component to a
+                    // function, we want to invalidate the boundary.
+                    if (self.$RefreshHelpers$.shouldInvalidateReactRefreshBoundary(prevSignature, self.$RefreshHelpers$.getRefreshBoundarySignature(currentExports))) {
+                        __webpack_module__.hot.invalidate();
+                    }
+                    else {
+                        self.$RefreshHelpers$.scheduleUpdate();
+                    }
+                }
+            }
+            else {
+                // Since we just executed the code for the module, it's possible that the
+                // new exports made it ineligible for being a boundary.
+                // We only care about the case when we were _previously_ a boundary,
+                // because we already accepted this update (accidental side effect).
+                var isNoLongerABoundary = prevSignature !== null;
+                if (isNoLongerABoundary) {
+                    __webpack_module__.hot.invalidate();
+                }
+            }
+        }
+    })();
+}
+exports.default = default_1;
+//# sourceMappingURL=ReactRefreshModule.runtime.js.map

package/.next/standalone/node_modules/next/dist/compiled/@next/react-refresh-utils/dist/internal/helpers.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * MIT License
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// This file is copied from the Metro JavaScript bundler, with minor tweaks for
+// webpack 4 compatibility.
+//
+// https://github.com/facebook/metro/blob/d6b9685c730d0d63577db40f41369157f28dfa3a/packages/metro/src/lib/polyfills/require.js
+const runtime_1 = __importDefault(require("next/dist/compiled/react-refresh/runtime"));
+function isSafeExport(key) {
+    return (key === '__esModule' ||
+        key === '__N_SSG' ||
+        key === '__N_SSP' ||
+        // TODO: remove this key from page config instead of allow listing it
+        key === 'config');
+}
+function registerExportsForReactRefresh(moduleExports, moduleID) {
+    runtime_1.default.register(moduleExports, moduleID + ' %exports%');
+    if (moduleExports == null || typeof moduleExports !== 'object') {
+        // Exit if we can't iterate over exports.
+        // (This is important for legacy environments.)
+        return;
+    }
+    for (var key in moduleExports) {
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        }
+        catch (_a) {
+            // This might fail due to circular dependencies
+            continue;
+        }
+        var typeID = moduleID + ' %exports% ' + key;
+        runtime_1.default.register(exportValue, typeID);
+    }
+}
+function getRefreshBoundarySignature(moduleExports) {
+    var signature = [];
+    signature.push(runtime_1.default.getFamilyByType(moduleExports));
+    if (moduleExports == null || typeof moduleExports !== 'object') {
+        // Exit if we can't iterate over exports.
+        // (This is important for legacy environments.)
+        return signature;
+    }
+    for (var key in moduleExports) {
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        }
+        catch (_a) {
+            // This might fail due to circular dependencies
+            continue;
+        }
+        signature.push(key);
+        signature.push(runtime_1.default.getFamilyByType(exportValue));
+    }
+    return signature;
+}
+function isReactRefreshBoundary(moduleExports) {
+    if (runtime_1.default.isLikelyComponentType(moduleExports)) {
+        return true;
+    }
+    if (moduleExports == null || typeof moduleExports !== 'object') {
+        // Exit if we can't iterate over exports.
+        return false;
+    }
+    var hasExports = false;
+    var areAllExportsComponents = true;
+    for (var key in moduleExports) {
+        hasExports = true;
+        if (isSafeExport(key)) {
+            continue;
+        }
+        try {
+            var exportValue = moduleExports[key];
+        }
+        catch (_a) {
+            // This might fail due to circular dependencies
+            return false;
+        }
+        if (!runtime_1.default.isLikelyComponentType(exportValue)) {
+            areAllExportsComponents = false;
+        }
+    }
+    return hasExports && areAllExportsComponents;
+}
+function shouldInvalidateReactRefreshBoundary(prevSignature, nextSignature) {
+    if (prevSignature.length !== nextSignature.length) {
+        return true;
+    }
+    for (var i = 0; i < nextSignature.length; i++) {
+        if (prevSignature[i] !== nextSignature[i]) {
+            return true;
+        }
+    }
+    return false;
+}
+var isUpdateScheduled = false;
+// This function aggregates updates from multiple modules into a single React Refresh call.
+function scheduleUpdate() {
+    if (isUpdateScheduled) {
+        return;
+    }
+    isUpdateScheduled = true;
+    function canApplyUpdate(status) {
+        return status === 'idle';
+    }
+    function applyUpdate() {
+        isUpdateScheduled = false;
+        try {
+            runtime_1.default.performReactRefresh();
+        }
+        catch (err) {
+            console.warn('Warning: Failed to re-render. We will retry on the next Fast Refresh event.\n' +
+                err);
+        }
+    }
+    if (canApplyUpdate(module.hot.status())) {
+        // Apply update on the next tick.
+        Promise.resolve().then(() => {
+            applyUpdate();
+        });
+        return;
+    }
+    const statusHandler = (status) => {
+        if (canApplyUpdate(status)) {
+            module.hot.removeStatusHandler(statusHandler);
+            applyUpdate();
+        }
+    };
+    // Apply update once the HMR runtime's status is idle.
+    module.hot.addStatusHandler(statusHandler);
+}
+// Needs to be compatible with IE11
+exports.default = {
+    registerExportsForReactRefresh: registerExportsForReactRefresh,
+    isReactRefreshBoundary: isReactRefreshBoundary,
+    shouldInvalidateReactRefreshBoundary: shouldInvalidateReactRefreshBoundary,
+    getRefreshBoundarySignature: getRefreshBoundarySignature,
+    scheduleUpdate: scheduleUpdate,
+};
+//# sourceMappingURL=helpers.js.map

package/.next/standalone/node_modules/next/dist/compiled/@next/react-refresh-utils/dist/loader.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ReactRefreshModule_runtime_1 = __importDefault(require("./internal/ReactRefreshModule.runtime"));
+let refreshModuleRuntime = ReactRefreshModule_runtime_1.default.toString();
+refreshModuleRuntime = refreshModuleRuntime
+    .slice(refreshModuleRuntime.indexOf('{') + 1, refreshModuleRuntime.lastIndexOf('}'))
+    // Given that the import above executes the module we need to make sure it does not crash on `import.meta` not being allowed.
+    .replace('global.importMeta', 'import.meta');
+let commonJsrefreshModuleRuntime = refreshModuleRuntime.replace('import.meta.webpackHot', 'module.hot');
+const ReactRefreshLoader = function ReactRefreshLoader(source, inputSourceMap) {
+    this.callback(null, `${source}\n\n;${
+    // Account for commonjs not supporting `import.meta
+    this.resourcePath.endsWith('.cjs')
+        ? commonJsrefreshModuleRuntime
+        : refreshModuleRuntime}`, inputSourceMap);
+};
+exports.default = ReactRefreshLoader;
+//# sourceMappingURL=loader.js.map