Initial boiler plate project

node_modules/next/dist/shared/lib/amp-context.shared-runtime.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const AmpStateContext: React.Context<any>;

node_modules/next/dist/shared/lib/amp-context.shared-runtime.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AmpStateContext", {
+    enumerable: true,
+    get: function() {
+        return AmpStateContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const AmpStateContext = _react.default.createContext({});
+if (process.env.NODE_ENV !== "production") {
+    AmpStateContext.displayName = "AmpStateContext";
+}
+
+//# sourceMappingURL=amp-context.shared-runtime.js.map

node_modules/next/dist/shared/lib/amp-context.shared-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/amp-context.shared-runtime.ts"],"names":["AmpStateContext","React","createContext","process","env","NODE_ENV","displayName"],"mappings":";;;;+BAEaA;;;eAAAA;;;;gEAFK;AAEX,MAAMA,kBAAsCC,cAAK,CAACC,aAAa,CAAC,CAAC;AAExE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCL,gBAAgBM,WAAW,GAAG;AAChC"}

node_modules/next/dist/shared/lib/amp-mode.d.ts

@@ -0,0 +1,5 @@
+export declare function isInAmpMode({ ampFirst, hybrid, hasQuery, }?: {
+    ampFirst?: boolean | undefined;
+    hybrid?: boolean | undefined;
+    hasQuery?: boolean | undefined;
+}): boolean;

node_modules/next/dist/shared/lib/amp-mode.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isInAmpMode", {
+    enumerable: true,
+    get: function() {
+        return isInAmpMode;
+    }
+});
+function isInAmpMode(param) {
+    let { ampFirst = false, hybrid = false, hasQuery = false } = param === void 0 ? {} : param;
+    return ampFirst || hybrid && hasQuery;
+}
+
+//# sourceMappingURL=amp-mode.js.map

node_modules/next/dist/shared/lib/amp-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/amp-mode.ts"],"names":["isInAmpMode","ampFirst","hybrid","hasQuery"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,YAAY;IAAA,IAAA,EAC1BC,WAAW,KAAK,EAChBC,SAAS,KAAK,EACdC,WAAW,KAAK,EACjB,GAJ2B,mBAIxB,CAAC,IAJuB;IAK1B,OAAOF,YAAaC,UAAUC;AAChC"}

node_modules/next/dist/shared/lib/amp.d.ts

@@ -0,0 +1 @@
+export declare function useAmp(): boolean;

node_modules/next/dist/shared/lib/amp.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useAmp", {
+    enumerable: true,
+    get: function() {
+        return useAmp;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _ampcontextsharedruntime = require("./amp-context.shared-runtime");
+const _ampmode = require("./amp-mode");
+function useAmp() {
+    // Don't assign the context value to a variable to save bytes
+    return (0, _ampmode.isInAmpMode)(_react.default.useContext(_ampcontextsharedruntime.AmpStateContext));
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=amp.js.map

node_modules/next/dist/shared/lib/amp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/amp.ts"],"names":["useAmp","isInAmpMode","React","useContext","AmpStateContext"],"mappings":";;;;+BAIgBA;;;eAAAA;;;;gEAJE;yCACc;yBACJ;AAErB,SAASA;IACd,6DAA6D;IAC7D,OAAOC,IAAAA,oBAAW,EAACC,cAAK,CAACC,UAAU,CAACC,wCAAe;AACrD"}

node_modules/next/dist/shared/lib/app-dynamic.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { LoadableGeneratedOptions, DynamicOptionsLoadingProps, Loader, LoaderComponent } from './lazy-dynamic/types';
+export { type LoadableGeneratedOptions, type DynamicOptionsLoadingProps, type Loader, type LoaderComponent, };
+export type DynamicOptions<P = {}> = LoadableGeneratedOptions & {
+    loading?: (loadingProps: DynamicOptionsLoadingProps) => JSX.Element | null;
+    loader?: Loader<P>;
+    loadableGenerated?: LoadableGeneratedOptions;
+    modules?: string[];
+    ssr?: boolean;
+};
+export type LoadableOptions<P = {}> = DynamicOptions<P>;
+export type LoadableFn<P = {}> = (opts: LoadableOptions<P>) => React.ComponentType<P>;
+export type LoadableComponent<P = {}> = React.ComponentType<P>;
+export default function dynamic<P = {}>(dynamicOptions: DynamicOptions<P> | Loader<P>, options?: DynamicOptions<P>): React.ComponentType<P>;

node_modules/next/dist/shared/lib/app-dynamic.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return dynamic;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _loadable = /*#__PURE__*/ _interop_require_default._(require("./lazy-dynamic/loadable"));
+function dynamic(dynamicOptions, options) {
+    var _mergedOptions_loadableGenerated;
+    let loadableOptions = {
+        // A loading component is not required, so we default it
+        loading: (param)=>{
+            let { error, isLoading, pastDelay } = param;
+            if (!pastDelay) return null;
+            if (process.env.NODE_ENV !== "production") {
+                if (isLoading) {
+                    return null;
+                }
+                if (error) {
+                    return /*#__PURE__*/ (0, _jsxruntime.jsxs)("p", {
+                        children: [
+                            error.message,
+                            /*#__PURE__*/ (0, _jsxruntime.jsx)("br", {}),
+                            error.stack
+                        ]
+                    });
+                }
+            }
+            return null;
+        }
+    };
+    if (typeof dynamicOptions === "function") {
+        loadableOptions.loader = dynamicOptions;
+    }
+    const mergedOptions = {
+        ...loadableOptions,
+        ...options
+    };
+    return (0, _loadable.default)({
+        ...mergedOptions,
+        modules: (_mergedOptions_loadableGenerated = mergedOptions.loadableGenerated) == null ? void 0 : _mergedOptions_loadableGenerated.modules
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=app-dynamic.js.map

node_modules/next/dist/shared/lib/app-dynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/app-dynamic.tsx"],"names":["dynamic","dynamicOptions","options","mergedOptions","loadableOptions","loading","error","isLoading","pastDelay","process","env","NODE_ENV","p","message","br","stack","loader","Loadable","modules","loadableGenerated"],"mappings":";;;;+BAiCA;;;eAAwBA;;;;;gEAjCN;mEACG;AAgCN,SAASA,QACtBC,cAA6C,EAC7CC,OAA2B;QAmChBC;IAjCX,IAAIC,kBAAsC;QACxC,wDAAwD;QACxDC,SAAS;gBAAC,EAAEC,KAAK,EAAEC,SAAS,EAAEC,SAAS,EAAE;YACvC,IAAI,CAACA,WAAW,OAAO;YACvB,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,IAAIJ,WAAW;oBACb,OAAO;gBACT;gBACA,IAAID,OAAO;oBACT,qBACE,sBAACM;;4BACEN,MAAMO,OAAO;0CACd,qBAACC;4BACAR,MAAMS,KAAK;;;gBAGlB;YACF;YACA,OAAO;QACT;IACF;IAEA,IAAI,OAAOd,mBAAmB,YAAY;QACxCG,gBAAgBY,MAAM,GAAGf;IAC3B;IAEA,MAAME,gBAAgB;QACpB,GAAGC,eAAe;QAClB,GAAGF,OAAO;IACZ;IAEA,OAAOe,IAAAA,iBAAQ,EAAC;QACd,GAAGd,aAAa;QAChBe,OAAO,GAAEf,mCAAAA,cAAcgB,iBAAiB,qBAA/BhB,iCAAiCe,OAAO;IACnD;AACF"}

node_modules/next/dist/shared/lib/app-router-context.shared-runtime.d.ts

@@ -0,0 +1,139 @@
+import type { FocusAndScrollRef, PrefetchKind, RouterChangeByServerResponse } from '../../client/components/router-reducer/router-reducer-types';
+import type { FetchServerResponseResult } from '../../client/components/router-reducer/fetch-server-response';
+import type { FlightRouterState } from '../../server/app-render/types';
+import React from 'react';
+export type ChildSegmentMap = Map<string, CacheNode>;
+/**
+ * Cache node used in app-router / layout-router.
+ */
+export type CacheNode = ReadyCacheNode | LazyCacheNode;
+export type LoadingModuleData = [React.JSX.Element, React.ReactNode, React.ReactNode] | null;
+export type LazyCacheNode = {
+    /**
+     * Whether the lazy cache node data promise has been resolved.
+     * This value is only true after we've called `use` on the promise (and applied the data to the tree).
+     */
+    lazyDataResolved: boolean;
+    /**
+     * When rsc is null, this is a lazily-initialized cache node.
+     *
+     * If the app attempts to render it, it triggers a lazy data fetch,
+     * postpones the render, and schedules an update to a new tree.
+     *
+     * TODO: This mechanism should not be used when PPR is enabled, though it
+     * currently is in some cases until we've implemented partial
+     * segment fetching.
+     */
+    rsc: null;
+    /**
+     * A prefetched version of the segment data. See explanation in corresponding
+     * field of ReadyCacheNode (below).
+     *
+     * Since LazyCacheNode mostly only exists in the non-PPR implementation, this
+     * will usually be null, but it could have been cloned from a previous
+     * CacheNode that was created by the PPR implementation. Eventually we want
+     * to migrate everything away from LazyCacheNode entirely.
+     */
+    prefetchRsc: React.ReactNode;
+    /**
+     * A pending response for the lazy data fetch. If this is not present
+     * during render, it is lazily created.
+     */
+    lazyData: Promise<FetchServerResponseResult> | null;
+    prefetchHead: React.ReactNode;
+    head: React.ReactNode;
+    loading: LoadingModuleData;
+    /**
+     * Child parallel routes.
+     */
+    parallelRoutes: Map<string, ChildSegmentMap>;
+};
+export type ReadyCacheNode = {
+    /**
+     * Whether the lazy cache node data promise has been resolved.
+     * This value is only true after we've called `use` on the promise (and applied the data to the tree).
+     */
+    lazyDataResolved: boolean;
+    /**
+     * When rsc is not null, it represents the RSC data for the
+     * corresponding segment.
+     *
+     * `null` is a valid React Node but because segment data is always a
+     * <LayoutRouter> component, we can use `null` to represent empty.
+     *
+     * TODO: For additional type safety, update this type to
+     * Exclude<React.ReactNode, null>. Need to update createEmptyCacheNode to
+     * accept rsc as an argument, or just inline the callers.
+     */
+    rsc: React.ReactNode;
+    /**
+     * Represents a static version of the segment that can be shown immediately,
+     * and may or may not contain dynamic holes. It's prefetched before a
+     * navigation occurs.
+     *
+     * During rendering, we will choose whether to render `rsc` or `prefetchRsc`
+     * with `useDeferredValue`. As with the `rsc` field, a value of `null` means
+     * no value was provided. In this case, the LayoutRouter will go straight to
+     * rendering the `rsc` value; if that one is also missing, it will suspend and
+     * trigger a lazy fetch.
+     */
+    prefetchRsc: React.ReactNode;
+    /**
+     * There should never be a lazy data request in this case.
+     */
+    lazyData: null;
+    prefetchHead: React.ReactNode;
+    head: React.ReactNode;
+    loading: LoadingModuleData;
+    parallelRoutes: Map<string, ChildSegmentMap>;
+};
+export interface NavigateOptions {
+    scroll?: boolean;
+}
+export interface PrefetchOptions {
+    kind: PrefetchKind;
+}
+export interface AppRouterInstance {
+    /**
+     * Navigate to the previous history entry.
+     */
+    back(): void;
+    /**
+     * Navigate to the next history entry.
+     */
+    forward(): void;
+    /**
+     * Refresh the current page.
+     */
+    refresh(): void;
+    /**
+     * Navigate to the provided href.
+     * Pushes a new history entry.
+     */
+    push(href: string, options?: NavigateOptions): void;
+    /**
+     * Navigate to the provided href.
+     * Replaces the current history entry.
+     */
+    replace(href: string, options?: NavigateOptions): void;
+    /**
+     * Prefetch the provided href.
+     */
+    prefetch(href: string, options?: PrefetchOptions): void;
+}
+export declare const AppRouterContext: React.Context<AppRouterInstance | null>;
+export declare const LayoutRouterContext: React.Context<{
+    childNodes: CacheNode['parallelRoutes'];
+    tree: FlightRouterState;
+    url: string;
+    loading: LoadingModuleData;
+} | null>;
+export declare const GlobalLayoutRouterContext: React.Context<{
+    buildId: string;
+    tree: FlightRouterState;
+    changeByServerResponse: RouterChangeByServerResponse;
+    focusAndScrollRef: FocusAndScrollRef;
+    nextUrl: string | null;
+}>;
+export declare const TemplateContext: React.Context<React.ReactNode>;
+export declare const MissingSlotContext: React.Context<Set<string>>;

node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js

@@ -0,0 +1,51 @@
+"use client";
+
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AppRouterContext: null,
+    GlobalLayoutRouterContext: null,
+    LayoutRouterContext: null,
+    MissingSlotContext: null,
+    TemplateContext: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AppRouterContext: function() {
+        return AppRouterContext;
+    },
+    GlobalLayoutRouterContext: function() {
+        return GlobalLayoutRouterContext;
+    },
+    LayoutRouterContext: function() {
+        return LayoutRouterContext;
+    },
+    MissingSlotContext: function() {
+        return MissingSlotContext;
+    },
+    TemplateContext: function() {
+        return TemplateContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const AppRouterContext = _react.default.createContext(null);
+const LayoutRouterContext = _react.default.createContext(null);
+const GlobalLayoutRouterContext = _react.default.createContext(null);
+const TemplateContext = _react.default.createContext(null);
+if (process.env.NODE_ENV !== "production") {
+    AppRouterContext.displayName = "AppRouterContext";
+    LayoutRouterContext.displayName = "LayoutRouterContext";
+    GlobalLayoutRouterContext.displayName = "GlobalLayoutRouterContext";
+    TemplateContext.displayName = "TemplateContext";
+}
+const MissingSlotContext = _react.default.createContext(new Set());
+
+//# sourceMappingURL=app-router-context.shared-runtime.js.map

node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/app-router-context.shared-runtime.ts"],"names":["AppRouterContext","GlobalLayoutRouterContext","LayoutRouterContext","MissingSlotContext","TemplateContext","React","createContext","process","env","NODE_ENV","displayName","Set"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;IA0JaA,gBAAgB;eAAhBA;;IAUAC,yBAAyB;eAAzBA;;IAPAC,mBAAmB;eAAnBA;;IAwBAC,kBAAkB;eAAlBA;;IATAC,eAAe;eAAfA;;;;gEAnKK;AAiJX,MAAMJ,mBAAmBK,cAAK,CAACC,aAAa,CACjD;AAEK,MAAMJ,sBAAsBG,cAAK,CAACC,aAAa,CAK5C;AAEH,MAAML,4BAA4BI,cAAK,CAACC,aAAa,CAMzD;AAEI,MAAMF,kBAAkBC,cAAK,CAACC,aAAa,CAAkB;AAEpE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCT,iBAAiBU,WAAW,GAAG;IAC/BR,oBAAoBQ,WAAW,GAAG;IAClCT,0BAA0BS,WAAW,GAAG;IACxCN,gBAAgBM,WAAW,GAAG;AAChC;AAEO,MAAMP,qBAAqBE,cAAK,CAACC,aAAa,CAAc,IAAIK"}

node_modules/next/dist/shared/lib/bloom-filter.d.ts

@@ -0,0 +1,20 @@
+export declare class BloomFilter {
+    numItems: number;
+    errorRate: number;
+    numBits: number;
+    numHashes: number;
+    bitArray: number[];
+    constructor(numItems: number, errorRate?: number);
+    static from(items: string[], errorRate?: number): BloomFilter;
+    export(): {
+        numItems: number;
+        errorRate: number;
+        numBits: number;
+        numHashes: number;
+        bitArray: number[];
+    };
+    import(data: ReturnType<(typeof this)['export']>): void;
+    add(item: string): void;
+    contains(item: string): boolean;
+    getHashValues(item: string): number[];
+}

node_modules/next/dist/shared/lib/bloom-filter.js

@@ -0,0 +1,86 @@
+// minimal implementation MurmurHash2 hash function
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BloomFilter", {
+    enumerable: true,
+    get: function() {
+        return BloomFilter;
+    }
+});
+function murmurhash2(str) {
+    let h = 0;
+    for(let i = 0; i < str.length; i++){
+        const c = str.charCodeAt(i);
+        h = Math.imul(h ^ c, 0x5bd1e995);
+        h ^= h >>> 13;
+        h = Math.imul(h, 0x5bd1e995);
+    }
+    return h >>> 0;
+}
+// default to 0.01% error rate as the filter compresses very well
+const DEFAULT_ERROR_RATE = 0.0001;
+class BloomFilter {
+    static from(items, errorRate) {
+        if (errorRate === void 0) errorRate = DEFAULT_ERROR_RATE;
+        const filter = new BloomFilter(items.length, errorRate);
+        for (const item of items){
+            filter.add(item);
+        }
+        return filter;
+    }
+    export() {
+        const data = {
+            numItems: this.numItems,
+            errorRate: this.errorRate,
+            numBits: this.numBits,
+            numHashes: this.numHashes,
+            bitArray: this.bitArray
+        };
+        if (process.env.NEXT_RUNTIME === "nodejs") {
+            if (this.errorRate < DEFAULT_ERROR_RATE) {
+                const filterData = JSON.stringify(data);
+                const gzipSize = require("next/dist/compiled/gzip-size").sync(filterData);
+                if (gzipSize > 1024) {
+                    console.warn("Creating filter with error rate less than 0.1% (0.001) can increase the size dramatically proceed with caution. Received error rate " + this.errorRate + " resulted in size " + filterData.length + " bytes, " + gzipSize + " bytes (gzip)");
+                }
+            }
+        }
+        return data;
+    }
+    import(data) {
+        this.numItems = data.numItems;
+        this.errorRate = data.errorRate;
+        this.numBits = data.numBits;
+        this.numHashes = data.numHashes;
+        this.bitArray = data.bitArray;
+    }
+    add(item) {
+        const hashValues = this.getHashValues(item);
+        hashValues.forEach((hash)=>{
+            this.bitArray[hash] = 1;
+        });
+    }
+    contains(item) {
+        const hashValues = this.getHashValues(item);
+        return hashValues.every((hash)=>this.bitArray[hash]);
+    }
+    getHashValues(item) {
+        const hashValues = [];
+        for(let i = 1; i <= this.numHashes; i++){
+            const hash = murmurhash2("" + item + i) % this.numBits;
+            hashValues.push(hash);
+        }
+        return hashValues;
+    }
+    constructor(numItems, errorRate = DEFAULT_ERROR_RATE){
+        this.numItems = numItems;
+        this.errorRate = errorRate;
+        this.numBits = Math.ceil(-(numItems * Math.log(errorRate)) / (Math.log(2) * Math.log(2)));
+        this.numHashes = Math.ceil(this.numBits / numItems * Math.log(2));
+        this.bitArray = new Array(this.numBits).fill(0);
+    }
+}
+
+//# sourceMappingURL=bloom-filter.js.map

node_modules/next/dist/shared/lib/bloom-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/bloom-filter.ts"],"names":["BloomFilter","murmurhash2","str","h","i","length","c","charCodeAt","Math","imul","DEFAULT_ERROR_RATE","from","items","errorRate","filter","item","add","export","data","numItems","numBits","numHashes","bitArray","process","env","NEXT_RUNTIME","filterData","JSON","stringify","gzipSize","require","sync","console","warn","import","hashValues","getHashValues","forEach","hash","contains","every","push","constructor","ceil","log","Array","fill"],"mappings":"AAAA,mDAAmD;;;;;+BAetCA;;;eAAAA;;;AAdb,SAASC,YAAYC,GAAW;IAC9B,IAAIC,IAAI;IACR,IAAK,IAAIC,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnC,MAAME,IAAIJ,IAAIK,UAAU,CAACH;QACzBD,IAAIK,KAAKC,IAAI,CAACN,IAAIG,GAAG;QACrBH,KAAKA,MAAM;QACXA,IAAIK,KAAKC,IAAI,CAACN,GAAG;IACnB;IACA,OAAOA,MAAM;AACf;AAEA,iEAAiE;AACjE,MAAMO,qBAAqB;AAEpB,MAAMV;IAiBX,OAAOW,KAAKC,KAAe,EAAEC,SAA8B,EAAE;QAAhCA,IAAAA,sBAAAA,YAAYH;QACvC,MAAMI,SAAS,IAAId,YAAYY,MAAMP,MAAM,EAAEQ;QAE7C,KAAK,MAAME,QAAQH,MAAO;YACxBE,OAAOE,GAAG,CAACD;QACb;QACA,OAAOD;IACT;IAEAG,SAAS;QACP,MAAMC,OAAO;YACXC,UAAU,IAAI,CAACA,QAAQ;YACvBN,WAAW,IAAI,CAACA,SAAS;YACzBO,SAAS,IAAI,CAACA,OAAO;YACrBC,WAAW,IAAI,CAACA,SAAS;YACzBC,UAAU,IAAI,CAACA,QAAQ;QACzB;QAEA,IAAIC,QAAQC,GAAG,CAACC,YAAY,KAAK,UAAU;YACzC,IAAI,IAAI,CAACZ,SAAS,GAAGH,oBAAoB;gBACvC,MAAMgB,aAAaC,KAAKC,SAAS,CAACV;gBAClC,MAAMW,WAAWC,QAAQ,gCAAgCC,IAAI,CAC3DL;gBAGF,IAAIG,WAAW,MAAM;oBACnBG,QAAQC,IAAI,CACV,AAAC,yIAAsI,IAAI,CAACpB,SAAS,GAAC,uBAAoBa,WAAWrB,MAAM,GAAC,aAAUwB,WAAS;gBAEnN;YACF;QACF;QAEA,OAAOX;IACT;IAEAgB,OAAOhB,IAAyC,EAAE;QAChD,IAAI,CAACC,QAAQ,GAAGD,KAAKC,QAAQ;QAC7B,IAAI,CAACN,SAAS,GAAGK,KAAKL,SAAS;QAC/B,IAAI,CAACO,OAAO,GAAGF,KAAKE,OAAO;QAC3B,IAAI,CAACC,SAAS,GAAGH,KAAKG,SAAS;QAC/B,IAAI,CAACC,QAAQ,GAAGJ,KAAKI,QAAQ;IAC/B;IAEAN,IAAID,IAAY,EAAE;QAChB,MAAMoB,aAAa,IAAI,CAACC,aAAa,CAACrB;QACtCoB,WAAWE,OAAO,CAAC,CAACC;YAClB,IAAI,CAAChB,QAAQ,CAACgB,KAAK,GAAG;QACxB;IACF;IAEAC,SAASxB,IAAY,EAAE;QACrB,MAAMoB,aAAa,IAAI,CAACC,aAAa,CAACrB;QACtC,OAAOoB,WAAWK,KAAK,CAAC,CAACF,OAAS,IAAI,CAAChB,QAAQ,CAACgB,KAAK;IACvD;IAEAF,cAAcrB,IAAY,EAAE;QAC1B,MAAMoB,aAAa,EAAE;QACrB,IAAK,IAAI/B,IAAI,GAAGA,KAAK,IAAI,CAACiB,SAAS,EAAEjB,IAAK;YACxC,MAAMkC,OAAOrC,YAAY,AAAC,KAAEc,OAAOX,KAAO,IAAI,CAACgB,OAAO;YACtDe,WAAWM,IAAI,CAACH;QAClB;QACA,OAAOH;IACT;IAzEAO,YAAYvB,QAAgB,EAAEN,YAAoBH,kBAAkB,CAAE;QACpE,IAAI,CAACS,QAAQ,GAAGA;QAChB,IAAI,CAACN,SAAS,GAAGA;QACjB,IAAI,CAACO,OAAO,GAAGZ,KAAKmC,IAAI,CACtB,CAAExB,CAAAA,WAAWX,KAAKoC,GAAG,CAAC/B,UAAS,IAAML,CAAAA,KAAKoC,GAAG,CAAC,KAAKpC,KAAKoC,GAAG,CAAC,EAAC;QAE/D,IAAI,CAACvB,SAAS,GAAGb,KAAKmC,IAAI,CAAC,AAAC,IAAI,CAACvB,OAAO,GAAGD,WAAYX,KAAKoC,GAAG,CAAC;QAChE,IAAI,CAACtB,QAAQ,GAAG,IAAIuB,MAAM,IAAI,CAACzB,OAAO,EAAE0B,IAAI,CAAC;IAC/C;AAkEF"}

node_modules/next/dist/shared/lib/constants.d.ts

@@ -0,0 +1,91 @@
+import MODERN_BROWSERSLIST_TARGET from './modern-browserslist-target';
+export { MODERN_BROWSERSLIST_TARGET };
+export type ValueOf<T> = Required<T>[keyof T];
+export declare const COMPILER_NAMES: {
+    readonly client: "client";
+    readonly server: "server";
+    readonly edgeServer: "edge-server";
+};
+export type CompilerNameValues = ValueOf<typeof COMPILER_NAMES>;
+export declare const COMPILER_INDEXES: {
+    [compilerKey in CompilerNameValues]: number;
+};
+export declare const UNDERSCORE_NOT_FOUND_ROUTE = "/_not-found";
+export declare const UNDERSCORE_NOT_FOUND_ROUTE_ENTRY = "/_not-found/page";
+export declare const PHASE_EXPORT = "phase-export";
+export declare const PHASE_PRODUCTION_BUILD = "phase-production-build";
+export declare const PHASE_PRODUCTION_SERVER = "phase-production-server";
+export declare const PHASE_DEVELOPMENT_SERVER = "phase-development-server";
+export declare const PHASE_TEST = "phase-test";
+export declare const PHASE_INFO = "phase-info";
+export declare const PAGES_MANIFEST = "pages-manifest.json";
+export declare const APP_PATHS_MANIFEST = "app-paths-manifest.json";
+export declare const APP_PATH_ROUTES_MANIFEST = "app-path-routes-manifest.json";
+export declare const BUILD_MANIFEST = "build-manifest.json";
+export declare const APP_BUILD_MANIFEST = "app-build-manifest.json";
+export declare const FUNCTIONS_CONFIG_MANIFEST = "functions-config-manifest.json";
+export declare const SUBRESOURCE_INTEGRITY_MANIFEST = "subresource-integrity-manifest";
+export declare const NEXT_FONT_MANIFEST = "next-font-manifest";
+export declare const EXPORT_MARKER = "export-marker.json";
+export declare const EXPORT_DETAIL = "export-detail.json";
+export declare const PRERENDER_MANIFEST = "prerender-manifest.json";
+export declare const ROUTES_MANIFEST = "routes-manifest.json";
+export declare const IMAGES_MANIFEST = "images-manifest.json";
+export declare const SERVER_FILES_MANIFEST = "required-server-files.json";
+export declare const DEV_CLIENT_PAGES_MANIFEST = "_devPagesManifest.json";
+export declare const MIDDLEWARE_MANIFEST = "middleware-manifest.json";
+export declare const DEV_MIDDLEWARE_MANIFEST = "_devMiddlewareManifest.json";
+export declare const REACT_LOADABLE_MANIFEST = "react-loadable-manifest.json";
+export declare const AUTOMATIC_FONT_OPTIMIZATION_MANIFEST = "font-manifest.json";
+export declare const SERVER_DIRECTORY = "server";
+export declare const CONFIG_FILES: string[];
+export declare const BUILD_ID_FILE = "BUILD_ID";
+export declare const BLOCKED_PAGES: string[];
+export declare const CLIENT_PUBLIC_FILES_PATH = "public";
+export declare const CLIENT_STATIC_FILES_PATH = "static";
+export declare const STRING_LITERAL_DROP_BUNDLE = "__NEXT_DROP_CLIENT_FILE__";
+export declare const NEXT_BUILTIN_DOCUMENT = "__NEXT_BUILTIN_DOCUMENT__";
+export declare const BARREL_OPTIMIZATION_PREFIX = "__barrel_optimize__";
+export declare const CLIENT_REFERENCE_MANIFEST = "client-reference-manifest";
+export declare const SERVER_REFERENCE_MANIFEST = "server-reference-manifest";
+export declare const MIDDLEWARE_BUILD_MANIFEST = "middleware-build-manifest";
+export declare const MIDDLEWARE_REACT_LOADABLE_MANIFEST = "middleware-react-loadable-manifest";
+export declare const INTERCEPTION_ROUTE_REWRITE_MANIFEST = "interception-route-rewrite-manifest";
+export declare const CLIENT_STATIC_FILES_RUNTIME_MAIN = "main";
+export declare const CLIENT_STATIC_FILES_RUNTIME_MAIN_APP = "main-app";
+export declare const APP_CLIENT_INTERNALS = "app-pages-internals";
+export declare const CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH = "react-refresh";
+export declare const CLIENT_STATIC_FILES_RUNTIME_AMP = "amp";
+export declare const CLIENT_STATIC_FILES_RUNTIME_WEBPACK = "webpack";
+export declare const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS = "polyfills";
+export declare const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL: unique symbol;
+export declare const DEFAULT_RUNTIME_WEBPACK = "webpack-runtime";
+export declare const EDGE_RUNTIME_WEBPACK = "edge-runtime-webpack";
+export declare const STATIC_PROPS_ID = "__N_SSG";
+export declare const SERVER_PROPS_ID = "__N_SSP";
+export declare const GOOGLE_FONT_PROVIDER = "https://fonts.googleapis.com/";
+export declare const OPTIMIZED_FONT_PROVIDERS: {
+    url: string;
+    preconnect: string;
+}[];
+export declare const DEFAULT_SERIF_FONT: {
+    name: string;
+    xAvgCharWidth: number;
+    azAvgWidth: number;
+    unitsPerEm: number;
+};
+export declare const DEFAULT_SANS_SERIF_FONT: {
+    name: string;
+    xAvgCharWidth: number;
+    azAvgWidth: number;
+    unitsPerEm: number;
+};
+export declare const STATIC_STATUS_PAGES: string[];
+export declare const TRACE_OUTPUT_VERSION = 1;
+export declare const TURBO_TRACE_DEFAULT_MEMORY_LIMIT = 6000;
+export declare const RSC_MODULE_TYPES: {
+    readonly client: "client";
+    readonly server: "server";
+};
+export declare const EDGE_UNSUPPORTED_NODE_APIS: string[];
+export declare const SYSTEM_ENTRYPOINTS: Set<string>;

node_modules/next/dist/shared/lib/constants.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    APP_BUILD_MANIFEST: null,
+    APP_CLIENT_INTERNALS: null,
+    APP_PATHS_MANIFEST: null,
+    APP_PATH_ROUTES_MANIFEST: null,
+    AUTOMATIC_FONT_OPTIMIZATION_MANIFEST: null,
+    BARREL_OPTIMIZATION_PREFIX: null,
+    BLOCKED_PAGES: null,
+    BUILD_ID_FILE: null,
+    BUILD_MANIFEST: null,
+    CLIENT_PUBLIC_FILES_PATH: null,
+    CLIENT_REFERENCE_MANIFEST: null,
+    CLIENT_STATIC_FILES_PATH: null,
+    CLIENT_STATIC_FILES_RUNTIME_AMP: null,
+    CLIENT_STATIC_FILES_RUNTIME_MAIN: null,
+    CLIENT_STATIC_FILES_RUNTIME_MAIN_APP: null,
+    CLIENT_STATIC_FILES_RUNTIME_POLYFILLS: null,
+    CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL: null,
+    CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH: null,
+    CLIENT_STATIC_FILES_RUNTIME_WEBPACK: null,
+    COMPILER_INDEXES: null,
+    COMPILER_NAMES: null,
+    CONFIG_FILES: null,
+    DEFAULT_RUNTIME_WEBPACK: null,
+    DEFAULT_SANS_SERIF_FONT: null,
+    DEFAULT_SERIF_FONT: null,
+    DEV_CLIENT_PAGES_MANIFEST: null,
+    DEV_MIDDLEWARE_MANIFEST: null,
+    EDGE_RUNTIME_WEBPACK: null,
+    EDGE_UNSUPPORTED_NODE_APIS: null,
+    EXPORT_DETAIL: null,
+    EXPORT_MARKER: null,
+    FUNCTIONS_CONFIG_MANIFEST: null,
+    GOOGLE_FONT_PROVIDER: null,
+    IMAGES_MANIFEST: null,
+    INTERCEPTION_ROUTE_REWRITE_MANIFEST: null,
+    MIDDLEWARE_BUILD_MANIFEST: null,
+    MIDDLEWARE_MANIFEST: null,
+    MIDDLEWARE_REACT_LOADABLE_MANIFEST: null,
+    MODERN_BROWSERSLIST_TARGET: null,
+    NEXT_BUILTIN_DOCUMENT: null,
+    NEXT_FONT_MANIFEST: null,
+    OPTIMIZED_FONT_PROVIDERS: null,
+    PAGES_MANIFEST: null,
+    PHASE_DEVELOPMENT_SERVER: null,
+    PHASE_EXPORT: null,
+    PHASE_INFO: null,
+    PHASE_PRODUCTION_BUILD: null,
+    PHASE_PRODUCTION_SERVER: null,
+    PHASE_TEST: null,
+    PRERENDER_MANIFEST: null,
+    REACT_LOADABLE_MANIFEST: null,
+    ROUTES_MANIFEST: null,
+    RSC_MODULE_TYPES: null,
+    SERVER_DIRECTORY: null,
+    SERVER_FILES_MANIFEST: null,
+    SERVER_PROPS_ID: null,
+    SERVER_REFERENCE_MANIFEST: null,
+    STATIC_PROPS_ID: null,
+    STATIC_STATUS_PAGES: null,
+    STRING_LITERAL_DROP_BUNDLE: null,
+    SUBRESOURCE_INTEGRITY_MANIFEST: null,
+    SYSTEM_ENTRYPOINTS: null,
+    TRACE_OUTPUT_VERSION: null,
+    TURBO_TRACE_DEFAULT_MEMORY_LIMIT: null,
+    UNDERSCORE_NOT_FOUND_ROUTE: null,
+    UNDERSCORE_NOT_FOUND_ROUTE_ENTRY: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    APP_BUILD_MANIFEST: function() {
+        return APP_BUILD_MANIFEST;
+    },
+    APP_CLIENT_INTERNALS: function() {
+        return APP_CLIENT_INTERNALS;
+    },
+    APP_PATHS_MANIFEST: function() {
+        return APP_PATHS_MANIFEST;
+    },
+    APP_PATH_ROUTES_MANIFEST: function() {
+        return APP_PATH_ROUTES_MANIFEST;
+    },
+    AUTOMATIC_FONT_OPTIMIZATION_MANIFEST: function() {
+        return AUTOMATIC_FONT_OPTIMIZATION_MANIFEST;
+    },
+    BARREL_OPTIMIZATION_PREFIX: function() {
+        return BARREL_OPTIMIZATION_PREFIX;
+    },
+    BLOCKED_PAGES: function() {
+        return BLOCKED_PAGES;
+    },
+    BUILD_ID_FILE: function() {
+        return BUILD_ID_FILE;
+    },
+    BUILD_MANIFEST: function() {
+        return BUILD_MANIFEST;
+    },
+    CLIENT_PUBLIC_FILES_PATH: function() {
+        return CLIENT_PUBLIC_FILES_PATH;
+    },
+    CLIENT_REFERENCE_MANIFEST: function() {
+        return CLIENT_REFERENCE_MANIFEST;
+    },
+    CLIENT_STATIC_FILES_PATH: function() {
+        return CLIENT_STATIC_FILES_PATH;
+    },
+    CLIENT_STATIC_FILES_RUNTIME_AMP: function() {
+        return CLIENT_STATIC_FILES_RUNTIME_AMP;
+    },
+    CLIENT_STATIC_FILES_RUNTIME_MAIN: function() {
+        return CLIENT_STATIC_FILES_RUNTIME_MAIN;
+    },
+    CLIENT_STATIC_FILES_RUNTIME_MAIN_APP: function() {
+        return CLIENT_STATIC_FILES_RUNTIME_MAIN_APP;
+    },
+    CLIENT_STATIC_FILES_RUNTIME_POLYFILLS: function() {
+        return CLIENT_STATIC_FILES_RUNTIME_POLYFILLS;
+    },
+    CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL: function() {
+        return CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL;
+    },
+    CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH: function() {
+        return CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH;
+    },
+    CLIENT_STATIC_FILES_RUNTIME_WEBPACK: function() {
+        return CLIENT_STATIC_FILES_RUNTIME_WEBPACK;
+    },
+    COMPILER_INDEXES: function() {
+        return COMPILER_INDEXES;
+    },
+    COMPILER_NAMES: function() {
+        return COMPILER_NAMES;
+    },
+    CONFIG_FILES: function() {
+        return CONFIG_FILES;
+    },
+    DEFAULT_RUNTIME_WEBPACK: function() {
+        return DEFAULT_RUNTIME_WEBPACK;
+    },
+    DEFAULT_SANS_SERIF_FONT: function() {
+        return DEFAULT_SANS_SERIF_FONT;
+    },
+    DEFAULT_SERIF_FONT: function() {
+        return DEFAULT_SERIF_FONT;
+    },
+    DEV_CLIENT_PAGES_MANIFEST: function() {
+        return DEV_CLIENT_PAGES_MANIFEST;
+    },
+    DEV_MIDDLEWARE_MANIFEST: function() {
+        return DEV_MIDDLEWARE_MANIFEST;
+    },
+    EDGE_RUNTIME_WEBPACK: function() {
+        return EDGE_RUNTIME_WEBPACK;
+    },
+    EDGE_UNSUPPORTED_NODE_APIS: function() {
+        return EDGE_UNSUPPORTED_NODE_APIS;
+    },
+    EXPORT_DETAIL: function() {
+        return EXPORT_DETAIL;
+    },
+    EXPORT_MARKER: function() {
+        return EXPORT_MARKER;
+    },
+    FUNCTIONS_CONFIG_MANIFEST: function() {
+        return FUNCTIONS_CONFIG_MANIFEST;
+    },
+    GOOGLE_FONT_PROVIDER: function() {
+        return GOOGLE_FONT_PROVIDER;
+    },
+    IMAGES_MANIFEST: function() {
+        return IMAGES_MANIFEST;
+    },
+    INTERCEPTION_ROUTE_REWRITE_MANIFEST: function() {
+        return INTERCEPTION_ROUTE_REWRITE_MANIFEST;
+    },
+    MIDDLEWARE_BUILD_MANIFEST: function() {
+        return MIDDLEWARE_BUILD_MANIFEST;
+    },
+    MIDDLEWARE_MANIFEST: function() {
+        return MIDDLEWARE_MANIFEST;
+    },
+    MIDDLEWARE_REACT_LOADABLE_MANIFEST: function() {
+        return MIDDLEWARE_REACT_LOADABLE_MANIFEST;
+    },
+    MODERN_BROWSERSLIST_TARGET: function() {
+        return _modernbrowserslisttarget.default;
+    },
+    NEXT_BUILTIN_DOCUMENT: function() {
+        return NEXT_BUILTIN_DOCUMENT;
+    },
+    NEXT_FONT_MANIFEST: function() {
+        return NEXT_FONT_MANIFEST;
+    },
+    OPTIMIZED_FONT_PROVIDERS: function() {
+        return OPTIMIZED_FONT_PROVIDERS;
+    },
+    PAGES_MANIFEST: function() {
+        return PAGES_MANIFEST;
+    },
+    PHASE_DEVELOPMENT_SERVER: function() {
+        return PHASE_DEVELOPMENT_SERVER;
+    },
+    PHASE_EXPORT: function() {
+        return PHASE_EXPORT;
+    },
+    PHASE_INFO: function() {
+        return PHASE_INFO;
+    },
+    PHASE_PRODUCTION_BUILD: function() {
+        return PHASE_PRODUCTION_BUILD;
+    },
+    PHASE_PRODUCTION_SERVER: function() {
+        return PHASE_PRODUCTION_SERVER;
+    },
+    PHASE_TEST: function() {
+        return PHASE_TEST;
+    },
+    PRERENDER_MANIFEST: function() {
+        return PRERENDER_MANIFEST;
+    },
+    REACT_LOADABLE_MANIFEST: function() {
+        return REACT_LOADABLE_MANIFEST;
+    },
+    ROUTES_MANIFEST: function() {
+        return ROUTES_MANIFEST;
+    },
+    RSC_MODULE_TYPES: function() {
+        return RSC_MODULE_TYPES;
+    },
+    SERVER_DIRECTORY: function() {
+        return SERVER_DIRECTORY;
+    },
+    SERVER_FILES_MANIFEST: function() {
+        return SERVER_FILES_MANIFEST;
+    },
+    SERVER_PROPS_ID: function() {
+        return SERVER_PROPS_ID;
+    },
+    SERVER_REFERENCE_MANIFEST: function() {
+        return SERVER_REFERENCE_MANIFEST;
+    },
+    STATIC_PROPS_ID: function() {
+        return STATIC_PROPS_ID;
+    },
+    STATIC_STATUS_PAGES: function() {
+        return STATIC_STATUS_PAGES;
+    },
+    STRING_LITERAL_DROP_BUNDLE: function() {
+        return STRING_LITERAL_DROP_BUNDLE;
+    },
+    SUBRESOURCE_INTEGRITY_MANIFEST: function() {
+        return SUBRESOURCE_INTEGRITY_MANIFEST;
+    },
+    SYSTEM_ENTRYPOINTS: function() {
+        return SYSTEM_ENTRYPOINTS;
+    },
+    TRACE_OUTPUT_VERSION: function() {
+        return TRACE_OUTPUT_VERSION;
+    },
+    TURBO_TRACE_DEFAULT_MEMORY_LIMIT: function() {
+        return TURBO_TRACE_DEFAULT_MEMORY_LIMIT;
+    },
+    UNDERSCORE_NOT_FOUND_ROUTE: function() {
+        return UNDERSCORE_NOT_FOUND_ROUTE;
+    },
+    UNDERSCORE_NOT_FOUND_ROUTE_ENTRY: function() {
+        return UNDERSCORE_NOT_FOUND_ROUTE_ENTRY;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _modernbrowserslisttarget = /*#__PURE__*/ _interop_require_default._(require("./modern-browserslist-target"));
+const COMPILER_NAMES = {
+    client: "client",
+    server: "server",
+    edgeServer: "edge-server"
+};
+const COMPILER_INDEXES = {
+    [COMPILER_NAMES.client]: 0,
+    [COMPILER_NAMES.server]: 1,
+    [COMPILER_NAMES.edgeServer]: 2
+};
+const UNDERSCORE_NOT_FOUND_ROUTE = "/_not-found";
+const UNDERSCORE_NOT_FOUND_ROUTE_ENTRY = "" + UNDERSCORE_NOT_FOUND_ROUTE + "/page";
+const PHASE_EXPORT = "phase-export";
+const PHASE_PRODUCTION_BUILD = "phase-production-build";
+const PHASE_PRODUCTION_SERVER = "phase-production-server";
+const PHASE_DEVELOPMENT_SERVER = "phase-development-server";
+const PHASE_TEST = "phase-test";
+const PHASE_INFO = "phase-info";
+const PAGES_MANIFEST = "pages-manifest.json";
+const APP_PATHS_MANIFEST = "app-paths-manifest.json";
+const APP_PATH_ROUTES_MANIFEST = "app-path-routes-manifest.json";
+const BUILD_MANIFEST = "build-manifest.json";
+const APP_BUILD_MANIFEST = "app-build-manifest.json";
+const FUNCTIONS_CONFIG_MANIFEST = "functions-config-manifest.json";
+const SUBRESOURCE_INTEGRITY_MANIFEST = "subresource-integrity-manifest";
+const NEXT_FONT_MANIFEST = "next-font-manifest";
+const EXPORT_MARKER = "export-marker.json";
+const EXPORT_DETAIL = "export-detail.json";
+const PRERENDER_MANIFEST = "prerender-manifest.json";
+const ROUTES_MANIFEST = "routes-manifest.json";
+const IMAGES_MANIFEST = "images-manifest.json";
+const SERVER_FILES_MANIFEST = "required-server-files.json";
+const DEV_CLIENT_PAGES_MANIFEST = "_devPagesManifest.json";
+const MIDDLEWARE_MANIFEST = "middleware-manifest.json";
+const DEV_MIDDLEWARE_MANIFEST = "_devMiddlewareManifest.json";
+const REACT_LOADABLE_MANIFEST = "react-loadable-manifest.json";
+const AUTOMATIC_FONT_OPTIMIZATION_MANIFEST = "font-manifest.json";
+const SERVER_DIRECTORY = "server";
+const CONFIG_FILES = [
+    "next.config.js",
+    "next.config.mjs"
+];
+const BUILD_ID_FILE = "BUILD_ID";
+const BLOCKED_PAGES = [
+    "/_document",
+    "/_app",
+    "/_error"
+];
+const CLIENT_PUBLIC_FILES_PATH = "public";
+const CLIENT_STATIC_FILES_PATH = "static";
+const STRING_LITERAL_DROP_BUNDLE = "__NEXT_DROP_CLIENT_FILE__";
+const NEXT_BUILTIN_DOCUMENT = "__NEXT_BUILTIN_DOCUMENT__";
+const BARREL_OPTIMIZATION_PREFIX = "__barrel_optimize__";
+const CLIENT_REFERENCE_MANIFEST = "client-reference-manifest";
+const SERVER_REFERENCE_MANIFEST = "server-reference-manifest";
+const MIDDLEWARE_BUILD_MANIFEST = "middleware-build-manifest";
+const MIDDLEWARE_REACT_LOADABLE_MANIFEST = "middleware-react-loadable-manifest";
+const INTERCEPTION_ROUTE_REWRITE_MANIFEST = "interception-route-rewrite-manifest";
+const CLIENT_STATIC_FILES_RUNTIME_MAIN = "main";
+const CLIENT_STATIC_FILES_RUNTIME_MAIN_APP = "" + CLIENT_STATIC_FILES_RUNTIME_MAIN + "-app";
+const APP_CLIENT_INTERNALS = "app-pages-internals";
+const CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH = "react-refresh";
+const CLIENT_STATIC_FILES_RUNTIME_AMP = "amp";
+const CLIENT_STATIC_FILES_RUNTIME_WEBPACK = "webpack";
+const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS = "polyfills";
+const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL = Symbol(CLIENT_STATIC_FILES_RUNTIME_POLYFILLS);
+const DEFAULT_RUNTIME_WEBPACK = "webpack-runtime";
+const EDGE_RUNTIME_WEBPACK = "edge-runtime-webpack";
+const STATIC_PROPS_ID = "__N_SSG";
+const SERVER_PROPS_ID = "__N_SSP";
+const GOOGLE_FONT_PROVIDER = "https://fonts.googleapis.com/";
+const OPTIMIZED_FONT_PROVIDERS = [
+    {
+        url: GOOGLE_FONT_PROVIDER,
+        preconnect: "https://fonts.gstatic.com"
+    },
+    {
+        url: "https://use.typekit.net",
+        preconnect: "https://use.typekit.net"
+    }
+];
+const DEFAULT_SERIF_FONT = {
+    name: "Times New Roman",
+    xAvgCharWidth: 821,
+    azAvgWidth: 854.3953488372093,
+    unitsPerEm: 2048
+};
+const DEFAULT_SANS_SERIF_FONT = {
+    name: "Arial",
+    xAvgCharWidth: 904,
+    azAvgWidth: 934.5116279069767,
+    unitsPerEm: 2048
+};
+const STATIC_STATUS_PAGES = [
+    "/500"
+];
+const TRACE_OUTPUT_VERSION = 1;
+const TURBO_TRACE_DEFAULT_MEMORY_LIMIT = 6000;
+const RSC_MODULE_TYPES = {
+    client: "client",
+    server: "server"
+};
+const EDGE_UNSUPPORTED_NODE_APIS = [
+    "clearImmediate",
+    "setImmediate",
+    "BroadcastChannel",
+    "ByteLengthQueuingStrategy",
+    "CompressionStream",
+    "CountQueuingStrategy",
+    "DecompressionStream",
+    "DomException",
+    "MessageChannel",
+    "MessageEvent",
+    "MessagePort",
+    "ReadableByteStreamController",
+    "ReadableStreamBYOBRequest",
+    "ReadableStreamDefaultController",
+    "TransformStreamDefaultController",
+    "WritableStreamDefaultController"
+];
+const SYSTEM_ENTRYPOINTS = new Set([
+    CLIENT_STATIC_FILES_RUNTIME_MAIN,
+    CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH,
+    CLIENT_STATIC_FILES_RUNTIME_AMP,
+    CLIENT_STATIC_FILES_RUNTIME_MAIN_APP
+]);
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=constants.js.map

node_modules/next/dist/shared/lib/deep-freeze.d.ts

@@ -0,0 +1,10 @@
+import type { DeepReadonly } from './deep-readonly';
+/**
+ * Recursively freezes an object and all of its properties. This prevents the
+ * object from being modified at runtime. When the JS runtime is running in
+ * strict mode, any attempts to modify a frozen object will throw an error.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+ * @param obj The object to freeze.
+ */
+export declare function deepFreeze<T extends object>(obj: T): DeepReadonly<T>;

node_modules/next/dist/shared/lib/deep-freeze.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "deepFreeze", {
+    enumerable: true,
+    get: function() {
+        return deepFreeze;
+    }
+});
+function deepFreeze(obj) {
+    // If the object is already frozen, there's no need to freeze it again.
+    if (Object.isFrozen(obj)) return obj;
+    // An array is an object, but we also want to freeze each element in the array
+    // as well.
+    if (Array.isArray(obj)) {
+        for (const item of obj){
+            if (!item || typeof item !== "object") continue;
+            deepFreeze(item);
+        }
+        return Object.freeze(obj);
+    }
+    for (const value of Object.values(obj)){
+        if (!value || typeof value !== "object") continue;
+        deepFreeze(value);
+    }
+    return Object.freeze(obj);
+}
+
+//# sourceMappingURL=deep-freeze.js.map

node_modules/next/dist/shared/lib/deep-freeze.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/deep-freeze.ts"],"names":["deepFreeze","obj","Object","isFrozen","Array","isArray","item","freeze","value","values"],"mappings":";;;;+BAUgBA;;;eAAAA;;;AAAT,SAASA,WAA6BC,GAAM;IACjD,uEAAuE;IACvE,IAAIC,OAAOC,QAAQ,CAACF,MAAM,OAAOA;IAEjC,8EAA8E;IAC9E,WAAW;IACX,IAAIG,MAAMC,OAAO,CAACJ,MAAM;QACtB,KAAK,MAAMK,QAAQL,IAAK;YACtB,IAAI,CAACK,QAAQ,OAAOA,SAAS,UAAU;YACvCN,WAAWM;QACb;QAEA,OAAOJ,OAAOK,MAAM,CAACN;IACvB;IAEA,KAAK,MAAMO,SAASN,OAAOO,MAAM,CAACR,KAAM;QACtC,IAAI,CAACO,SAAS,OAAOA,UAAU,UAAU;QACzCR,WAAWQ;IACb;IAEA,OAAON,OAAOK,MAAM,CAACN;AACvB"}

node_modules/next/dist/shared/lib/deep-freeze.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/shared/lib/deep-readonly.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A type that represents a deeply readonly object. This is similar to
+ * TypeScript's `Readonly` type, but it recursively applies the `readonly`
+ * modifier to all properties of an object and all elements of arrays.
+ */
+export type DeepReadonly<T> = T extends (infer R)[] ? ReadonlyArray<DeepReadonly<R>> : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;

node_modules/next/dist/shared/lib/deep-readonly.js

@@ -0,0 +1,10 @@
+/**
+ * A type that represents a deeply readonly object. This is similar to
+ * TypeScript's `Readonly` type, but it recursively applies the `readonly`
+ * modifier to all properties of an object and all elements of arrays.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=deep-readonly.js.map

node_modules/next/dist/shared/lib/deep-readonly.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/deep-readonly.ts"],"names":[],"mappings":"AAAA;;;;CAIC"}

node_modules/next/dist/shared/lib/dynamic.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+type ComponentModule<P = {}> = {
+    default: React.ComponentType<P>;
+};
+export declare type LoaderComponent<P = {}> = Promise<React.ComponentType<P> | ComponentModule<P>>;
+export declare type Loader<P = {}> = (() => LoaderComponent<P>) | LoaderComponent<P>;
+export type LoaderMap = {
+    [module: string]: () => Loader<any>;
+};
+export type LoadableGeneratedOptions = {
+    webpack?(): any;
+    modules?(): LoaderMap;
+};
+export type DynamicOptionsLoadingProps = {
+    error?: Error | null;
+    isLoading?: boolean;
+    pastDelay?: boolean;
+    retry?: () => void;
+    timedOut?: boolean;
+};
+export type DynamicOptions<P = {}> = LoadableGeneratedOptions & {
+    loading?: (loadingProps: DynamicOptionsLoadingProps) => JSX.Element | null;
+    loader?: Loader<P> | LoaderMap;
+    loadableGenerated?: LoadableGeneratedOptions;
+    ssr?: boolean;
+    /**
+     * @deprecated `suspense` prop is not required anymore
+     */
+    suspense?: boolean;
+};
+export type LoadableOptions<P = {}> = DynamicOptions<P>;
+export type LoadableFn<P = {}> = (opts: LoadableOptions<P>) => React.ComponentType<P>;
+export type LoadableComponent<P = {}> = React.ComponentType<P>;
+export declare function noSSR<P = {}>(LoadableInitializer: LoadableFn<P>, loadableOptions: DynamicOptions<P>): React.ComponentType<P>;
+/**
+ * This function lets you dynamically import a component.
+ * It uses [React.lazy()](https://react.dev/reference/react/lazy) with [Suspense](https://react.dev/reference/react/Suspense) under the hood.
+ *
+ * Read more: [Next.js Docs: `next/dynamic`](https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading#nextdynamic)
+ */
+export default function dynamic<P = {}>(dynamicOptions: DynamicOptions<P> | Loader<P>, options?: DynamicOptions<P>): React.ComponentType<P>;
+export {};

node_modules/next/dist/shared/lib/dynamic.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    noSSR: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    /**
+ * This function lets you dynamically import a component.
+ * It uses [React.lazy()](https://react.dev/reference/react/lazy) with [Suspense](https://react.dev/reference/react/Suspense) under the hood.
+ *
+ * Read more: [Next.js Docs: `next/dynamic`](https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading#nextdynamic)
+ */ default: function() {
+        return dynamic;
+    },
+    noSSR: function() {
+        return noSSR;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _loadablesharedruntime = /*#__PURE__*/ _interop_require_default._(require("./loadable.shared-runtime"));
+const isServerSide = typeof window === "undefined";
+// Normalize loader to return the module as form { default: Component } for `React.lazy`.
+// Also for backward compatible since next/dynamic allows to resolve a component directly with loader
+// Client component reference proxy need to be converted to a module.
+function convertModule(mod) {
+    return {
+        default: (mod == null ? void 0 : mod.default) || mod
+    };
+}
+function noSSR(LoadableInitializer, loadableOptions) {
+    // Removing webpack and modules means react-loadable won't try preloading
+    delete loadableOptions.webpack;
+    delete loadableOptions.modules;
+    // This check is necessary to prevent react-loadable from initializing on the server
+    if (!isServerSide) {
+        return LoadableInitializer(loadableOptions);
+    }
+    const Loading = loadableOptions.loading;
+    // This will only be rendered on the server side
+    return ()=>/*#__PURE__*/ (0, _jsxruntime.jsx)(Loading, {
+            error: null,
+            isLoading: true,
+            pastDelay: false,
+            timedOut: false
+        });
+}
+function dynamic(dynamicOptions, options) {
+    let loadableFn = _loadablesharedruntime.default;
+    let loadableOptions = {
+        // A loading component is not required, so we default it
+        loading: (param)=>{
+            let { error, isLoading, pastDelay } = param;
+            if (!pastDelay) return null;
+            if (process.env.NODE_ENV !== "production") {
+                if (isLoading) {
+                    return null;
+                }
+                if (error) {
+                    return /*#__PURE__*/ (0, _jsxruntime.jsxs)("p", {
+                        children: [
+                            error.message,
+                            /*#__PURE__*/ (0, _jsxruntime.jsx)("br", {}),
+                            error.stack
+                        ]
+                    });
+                }
+            }
+            return null;
+        }
+    };
+    // Support for direct import(), eg: dynamic(import('../hello-world'))
+    // Note that this is only kept for the edge case where someone is passing in a promise as first argument
+    // The react-loadable babel plugin will turn dynamic(import('../hello-world')) into dynamic(() => import('../hello-world'))
+    // To make sure we don't execute the import without rendering first
+    if (dynamicOptions instanceof Promise) {
+        loadableOptions.loader = ()=>dynamicOptions;
+    // Support for having import as a function, eg: dynamic(() => import('../hello-world'))
+    } else if (typeof dynamicOptions === "function") {
+        loadableOptions.loader = dynamicOptions;
+    // Support for having first argument being options, eg: dynamic({loader: import('../hello-world')})
+    } else if (typeof dynamicOptions === "object") {
+        loadableOptions = {
+            ...loadableOptions,
+            ...dynamicOptions
+        };
+    }
+    // Support for passing options, eg: dynamic(import('../hello-world'), {loading: () => <p>Loading something</p>})
+    loadableOptions = {
+        ...loadableOptions,
+        ...options
+    };
+    const loaderFn = loadableOptions.loader;
+    const loader = ()=>loaderFn != null ? loaderFn().then(convertModule) : Promise.resolve(convertModule(()=>null));
+    // coming from build/babel/plugins/react-loadable-plugin.js
+    if (loadableOptions.loadableGenerated) {
+        loadableOptions = {
+            ...loadableOptions,
+            ...loadableOptions.loadableGenerated
+        };
+        delete loadableOptions.loadableGenerated;
+    }
+    // support for disabling server side rendering, eg: dynamic(() => import('../hello-world'), {ssr: false}).
+    if (typeof loadableOptions.ssr === "boolean" && !loadableOptions.ssr) {
+        delete loadableOptions.webpack;
+        delete loadableOptions.modules;
+        return noSSR(loadableFn, loadableOptions);
+    }
+    return loadableFn({
+        ...loadableOptions,
+        loader: loader
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=dynamic.js.map

node_modules/next/dist/shared/lib/dynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/dynamic.tsx"],"names":["dynamic","noSSR","isServerSide","window","convertModule","mod","default","LoadableInitializer","loadableOptions","webpack","modules","Loading","loading","error","isLoading","pastDelay","timedOut","dynamicOptions","options","loadableFn","Loadable","process","env","NODE_ENV","p","message","br","stack","Promise","loader","loaderFn","then","resolve","loadableGenerated","ssr"],"mappings":";;;;;;;;;;;;;;;IA4EA;;;;;CAKC,GACD,OAqEC;eArEuBA;;IA1BRC,KAAK;eAALA;;;;;gEAxDE;gFACG;AAErB,MAAMC,eAAe,OAAOC,WAAW;AA2BvC,yFAAyF;AACzF,qGAAqG;AACrG,qEAAqE;AACrE,SAASC,cAAiBC,GAAgD;IACxE,OAAO;QAAEC,SAAS,CAACD,uBAAD,AAACA,IAA4BC,OAAO,KAAID;IAAI;AAChE;AAqBO,SAASJ,MACdM,mBAAkC,EAClCC,eAAkC;IAElC,yEAAyE;IACzE,OAAOA,gBAAgBC,OAAO;IAC9B,OAAOD,gBAAgBE,OAAO;IAE9B,oFAAoF;IACpF,IAAI,CAACR,cAAc;QACjB,OAAOK,oBAAoBC;IAC7B;IAEA,MAAMG,UAAUH,gBAAgBI,OAAO;IACvC,gDAAgD;IAChD,OAAO,kBACL,qBAACD;YAAQE,OAAO;YAAMC,SAAS;YAACC,WAAW;YAAOC,UAAU;;AAEhE;AAQe,SAAShB,QACtBiB,cAA6C,EAC7CC,OAA2B;IAE3B,IAAIC,aAAaC,8BAAQ;IAEzB,IAAIZ,kBAAsC;QACxC,wDAAwD;QACxDI,SAAS;gBAAC,EAAEC,KAAK,EAAEC,SAAS,EAAEC,SAAS,EAAE;YACvC,IAAI,CAACA,WAAW,OAAO;YACvB,IAAIM,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,IAAIT,WAAW;oBACb,OAAO;gBACT;gBACA,IAAID,OAAO;oBACT,qBACE,sBAACW;;4BACEX,MAAMY,OAAO;0CACd,qBAACC;4BACAb,MAAMc,KAAK;;;gBAGlB;YACF;YACA,OAAO;QACT;IACF;IAEA,qEAAqE;IACrE,wGAAwG;IACxG,2HAA2H;IAC3H,mEAAmE;IACnE,IAAIV,0BAA0BW,SAAS;QACrCpB,gBAAgBqB,MAAM,GAAG,IAAMZ;IAC/B,uFAAuF;IACzF,OAAO,IAAI,OAAOA,mBAAmB,YAAY;QAC/CT,gBAAgBqB,MAAM,GAAGZ;IACzB,mGAAmG;IACrG,OAAO,IAAI,OAAOA,mBAAmB,UAAU;QAC7CT,kBAAkB;YAAE,GAAGA,eAAe;YAAE,GAAGS,cAAc;QAAC;IAC5D;IAEA,gHAAgH;IAChHT,kBAAkB;QAAE,GAAGA,eAAe;QAAE,GAAGU,OAAO;IAAC;IAEnD,MAAMY,WAAWtB,gBAAgBqB,MAAM;IACvC,MAAMA,SAAS,IACbC,YAAY,OACRA,WAAWC,IAAI,CAAC3B,iBAChBwB,QAAQI,OAAO,CAAC5B,cAAc,IAAM;IAE1C,2DAA2D;IAC3D,IAAII,gBAAgByB,iBAAiB,EAAE;QACrCzB,kBAAkB;YAChB,GAAGA,eAAe;YAClB,GAAGA,gBAAgByB,iBAAiB;QACtC;QACA,OAAOzB,gBAAgByB,iBAAiB;IAC1C;IAEA,0GAA0G;IAC1G,IAAI,OAAOzB,gBAAgB0B,GAAG,KAAK,aAAa,CAAC1B,gBAAgB0B,GAAG,EAAE;QACpE,OAAO1B,gBAAgBC,OAAO;QAC9B,OAAOD,gBAAgBE,OAAO;QAE9B,OAAOT,MAAMkB,YAAYX;IAC3B;IAEA,OAAOW,WAAW;QAAE,GAAGX,eAAe;QAAEqB,QAAQA;IAAoB;AACtE"}

node_modules/next/dist/shared/lib/encode-uri-path.d.ts

@@ -0,0 +1 @@
+export declare function encodeURIPath(file: string): string;

node_modules/next/dist/shared/lib/encode-uri-path.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "encodeURIPath", {
+    enumerable: true,
+    get: function() {
+        return encodeURIPath;
+    }
+});
+function encodeURIPath(file) {
+    return file.split("/").map((p)=>encodeURIComponent(p)).join("/");
+}
+
+//# sourceMappingURL=encode-uri-path.js.map

node_modules/next/dist/shared/lib/encode-uri-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/encode-uri-path.ts"],"names":["encodeURIPath","file","split","map","p","encodeURIComponent","join"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,cAAcC,IAAY;IACxC,OAAOA,KACJC,KAAK,CAAC,KACNC,GAAG,CAAC,CAACC,IAAMC,mBAAmBD,IAC9BE,IAAI,CAAC;AACV"}

node_modules/next/dist/shared/lib/error-source.d.ts

@@ -0,0 +1,3 @@
+export declare function getErrorSource(error: Error): 'server' | 'edge-server' | null;
+export type ErrorSourceType = 'edge-server' | 'server';
+export declare function decorateServerError(error: Error, type: ErrorSourceType): void;

node_modules/next/dist/shared/lib/error-source.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    decorateServerError: null,
+    getErrorSource: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    decorateServerError: function() {
+        return decorateServerError;
+    },
+    getErrorSource: function() {
+        return getErrorSource;
+    }
+});
+const symbolError = Symbol.for("NextjsError");
+function getErrorSource(error) {
+    return error[symbolError] || null;
+}
+function decorateServerError(error, type) {
+    Object.defineProperty(error, symbolError, {
+        writable: false,
+        enumerable: false,
+        configurable: false,
+        value: type
+    });
+}
+
+//# sourceMappingURL=error-source.js.map

node_modules/next/dist/shared/lib/error-source.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/error-source.ts"],"names":["decorateServerError","getErrorSource","symbolError","Symbol","for","error","type","Object","defineProperty","writable","enumerable","configurable","value"],"mappings":";;;;;;;;;;;;;;;IAQgBA,mBAAmB;eAAnBA;;IANAC,cAAc;eAAdA;;;AAFhB,MAAMC,cAAcC,OAAOC,GAAG,CAAC;AAExB,SAASH,eAAeI,KAAY;IACzC,OAAO,AAACA,KAAa,CAACH,YAAY,IAAI;AACxC;AAIO,SAASF,oBAAoBK,KAAY,EAAEC,IAAqB;IACrEC,OAAOC,cAAc,CAACH,OAAOH,aAAa;QACxCO,UAAU;QACVC,YAAY;QACZC,cAAc;QACdC,OAAON;IACT;AACF"}

node_modules/next/dist/shared/lib/escape-regexp.d.ts

@@ -0,0 +1 @@
+export declare function escapeStringRegexp(str: string): string;

node_modules/next/dist/shared/lib/escape-regexp.js

@@ -0,0 +1,22 @@
+// regexp is based on https://github.com/sindresorhus/escape-string-regexp
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "escapeStringRegexp", {
+    enumerable: true,
+    get: function() {
+        return escapeStringRegexp;
+    }
+});
+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;
+}
+
+//# sourceMappingURL=escape-regexp.js.map

node_modules/next/dist/shared/lib/escape-regexp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/escape-regexp.ts"],"names":["escapeStringRegexp","reHasRegExp","reReplaceRegExp","str","test","replace"],"mappings":"AAAA,0EAA0E;;;;;+BAI1DA;;;eAAAA;;;AAHhB,MAAMC,cAAc;AACpB,MAAMC,kBAAkB;AAEjB,SAASF,mBAAmBG,GAAW;IAC5C,+GAA+G;IAC/G,IAAIF,YAAYG,IAAI,CAACD,MAAM;QACzB,OAAOA,IAAIE,OAAO,CAACH,iBAAiB;IACtC;IACA,OAAOC;AACT"}

node_modules/next/dist/shared/lib/fnv1a.d.ts

@@ -0,0 +1,13 @@
+declare const FNV_PRIMES: {
+    readonly 32: bigint;
+    readonly 64: bigint;
+    readonly 128: bigint;
+    readonly 256: bigint;
+    readonly 512: bigint;
+    readonly 1024: bigint;
+};
+export default function fnv1a(inputString: string, { size, seed, }?: {
+    size?: keyof typeof FNV_PRIMES;
+    seed?: number;
+}): bigint;
+export {};

node_modules/next/dist/shared/lib/fnv1a.js

@@ -0,0 +1,53 @@
+// source: https://github.com/sindresorhus/fnv1a
+// FNV_PRIMES and FNV_OFFSETS from
+// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
+/* eslint-disable @typescript-eslint/no-loss-of-precision */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return fnv1a;
+    }
+});
+const FNV_PRIMES = {
+    32: BigInt(16777619),
+    64: BigInt(1099511628211),
+    128: BigInt(309485009821345068724781371),
+    256: BigInt(374144419156711147060143317175368453031918731002211),
+    512: BigInt(35835915874844867368919076489095108449946327955754392558399825615420669938882575126094039892345713852759),
+    1024: BigInt(5016456510113118655434598811035278955030765345404790744303017523831112055108147451509157692220295382716162651878526895249385292291816524375083746691371804094271873160484737966720260389217684476157468082573)
+};
+const FNV_OFFSETS = {
+    32: BigInt(2166136261),
+    64: BigInt(14695981039346656037),
+    128: BigInt(144066263297769815596495629667062367629),
+    256: BigInt(100029257958052580907070968620625704837092796014241193945225284501741471925557),
+    512: BigInt(9659303129496669498009435400716310466090418745672637896108374329434462657994582932197716438449813051892206539805784495328239340083876191928701583869517785),
+    1024: BigInt(14197795064947621068722070641403218320880622795441933960878474914617582723252296732303717722150864096521202355549365628174669108571814760471015076148029755969804077320157692458563003215304957150157403644460363550505412711285966361610267868082893823963790439336411086884584107735010676915)
+};
+function fnv1a(inputString, param) {
+    let { size = 32, seed = 0 } = param === void 0 ? {} : param;
+    if (!FNV_PRIMES[size]) {
+        throw new Error("The `size` option must be one of 32, 64, 128, 256, 512, or 1024");
+    }
+    let hash = FNV_OFFSETS[size] ^ BigInt(seed);
+    const fnvPrime = FNV_PRIMES[size];
+    // Handle Unicode code points > 0x7f
+    let isUnicoded = false;
+    for(let index = 0; index < inputString.length; index++){
+        let characterCode = inputString.charCodeAt(index);
+        // Non-ASCII characters trigger the Unicode escape logic
+        if (characterCode > 0x7f && !isUnicoded) {
+            inputString = unescape(encodeURIComponent(inputString));
+            characterCode = inputString.charCodeAt(index);
+            isUnicoded = true;
+        }
+        hash ^= BigInt(characterCode);
+        hash = BigInt.asUintN(size, hash * fnvPrime);
+    }
+    return hash;
+}
+
+//# sourceMappingURL=fnv1a.js.map

node_modules/next/dist/shared/lib/fnv1a.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/fnv1a.ts"],"names":["fnv1a","FNV_PRIMES","BigInt","FNV_OFFSETS","inputString","size","seed","Error","hash","fnvPrime","isUnicoded","index","length","characterCode","charCodeAt","unescape","encodeURIComponent","asUintN"],"mappings":"AAAA,gDAAgD;AAChD,kCAAkC;AAClC,iEAAiE;AACjE,0DAA0D;;;;+BAgC1D;;;eAAwBA;;;AA9BxB,MAAMC,aAAa;IACjB,IAAIC,OAAO;IACX,IAAIA,OAAO;IACX,KAAKA,OAAO;IACZ,KAAKA,OACH;IAEF,KAAKA,OACH;IAEF,MAAMA,OACJ;AAEJ;AAEA,MAAMC,cAAc;IAClB,IAAID,OAAO;IACX,IAAIA,OAAO;IACX,KAAKA,OAAO;IACZ,KAAKA,OACH;IAEF,KAAKA,OACH;IAEF,MAAMA,OACJ;AAEJ;AAEe,SAASF,MACtBI,WAAmB,EACnB;IAAA,IAAA,EACEC,OAAO,EAAE,EACTC,OAAO,CAAC,EAIT,GAND,mBAMI,CAAC,IANL;IAQA,IAAI,CAACL,UAAU,CAACI,KAAK,EAAE;QACrB,MAAM,IAAIE,MACR;IAEJ;IAEA,IAAIC,OAAeL,WAAW,CAACE,KAAK,GAAGH,OAAOI;IAC9C,MAAMG,WAAWR,UAAU,CAACI,KAAK;IAEjC,oCAAoC;IACpC,IAAIK,aAAa;IAEjB,IAAK,IAAIC,QAAQ,GAAGA,QAAQP,YAAYQ,MAAM,EAAED,QAAS;QACvD,IAAIE,gBAAgBT,YAAYU,UAAU,CAACH;QAE3C,wDAAwD;QACxD,IAAIE,gBAAgB,QAAQ,CAACH,YAAY;YACvCN,cAAcW,SAASC,mBAAmBZ;YAC1CS,gBAAgBT,YAAYU,UAAU,CAACH;YACvCD,aAAa;QACf;QAEAF,QAAQN,OAAOW;QACfL,OAAON,OAAOe,OAAO,CAACZ,MAAMG,OAAOC;IACrC;IAEA,OAAOD;AACT"}

node_modules/next/dist/shared/lib/get-hostname.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { OutgoingHttpHeaders } from 'http';
+/**
+ * Takes an object with a hostname property (like a parsed URL) and some
+ * headers that may contain Host and returns the preferred hostname.
+ * @param parsed An object containing a hostname property.
+ * @param headers A dictionary with headers containing a `host`.
+ */
+export declare function getHostname(parsed: {
+    hostname?: string | null;
+}, headers?: OutgoingHttpHeaders): string | undefined;

node_modules/next/dist/shared/lib/get-hostname.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getHostname", {
+    enumerable: true,
+    get: function() {
+        return getHostname;
+    }
+});
+function getHostname(parsed, headers) {
+    // Get the hostname from the headers if it exists, otherwise use the parsed
+    // hostname.
+    let hostname;
+    if ((headers == null ? void 0 : headers.host) && !Array.isArray(headers.host)) {
+        hostname = headers.host.toString().split(":", 1)[0];
+    } else if (parsed.hostname) {
+        hostname = parsed.hostname;
+    } else return;
+    return hostname.toLowerCase();
+}
+
+//# sourceMappingURL=get-hostname.js.map

node_modules/next/dist/shared/lib/get-hostname.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/get-hostname.ts"],"names":["getHostname","parsed","headers","hostname","host","Array","isArray","toString","split","toLowerCase"],"mappings":";;;;+BAQgBA;;;eAAAA;;;AAAT,SAASA,YACdC,MAAoC,EACpCC,OAA6B;IAE7B,2EAA2E;IAC3E,YAAY;IACZ,IAAIC;IACJ,IAAID,CAAAA,2BAAAA,QAASE,IAAI,KAAI,CAACC,MAAMC,OAAO,CAACJ,QAAQE,IAAI,GAAG;QACjDD,WAAWD,QAAQE,IAAI,CAACG,QAAQ,GAAGC,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE;IACrD,OAAO,IAAIP,OAAOE,QAAQ,EAAE;QAC1BA,WAAWF,OAAOE,QAAQ;IAC5B,OAAO;IAEP,OAAOA,SAASM,WAAW;AAC7B"}

node_modules/next/dist/shared/lib/get-hostname.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/shared/lib/get-img-props.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="react" />
+import type { ImageConfigComplete, ImageLoaderProps, ImageLoaderPropsWithConfig } from './image-config';
+export interface StaticImageData {
+    src: string;
+    height: number;
+    width: number;
+    blurDataURL?: string;
+    blurWidth?: number;
+    blurHeight?: number;
+}
+export interface StaticRequire {
+    default: StaticImageData;
+}
+export type StaticImport = StaticRequire | StaticImageData;
+export type ImageProps = Omit<JSX.IntrinsicElements['img'], 'src' | 'srcSet' | 'ref' | 'alt' | 'width' | 'height' | 'loading'> & {
+    src: string | StaticImport;
+    alt: string;
+    width?: number | `${number}`;
+    height?: number | `${number}`;
+    fill?: boolean;
+    loader?: ImageLoader;
+    quality?: number | `${number}`;
+    priority?: boolean;
+    loading?: LoadingValue;
+    placeholder?: PlaceholderValue;
+    blurDataURL?: string;
+    unoptimized?: boolean;
+    overrideSrc?: string;
+    /**
+     * @deprecated Use `onLoad` instead.
+     * @see https://nextjs.org/docs/app/api-reference/components/image#onload
+     */
+    onLoadingComplete?: OnLoadingComplete;
+    /**
+     * @deprecated Use `fill` prop instead of `layout="fill"` or change import to `next/legacy/image`.
+     * @see https://nextjs.org/docs/api-reference/next/legacy/image
+     */
+    layout?: string;
+    /**
+     * @deprecated Use `style` prop instead.
+     */
+    objectFit?: string;
+    /**
+     * @deprecated Use `style` prop instead.
+     */
+    objectPosition?: string;
+    /**
+     * @deprecated This prop does not do anything.
+     */
+    lazyBoundary?: string;
+    /**
+     * @deprecated This prop does not do anything.
+     */
+    lazyRoot?: string;
+};
+export type ImgProps = Omit<ImageProps, 'src' | 'alt' | 'loader'> & {
+    loading: LoadingValue;
+    width: number | undefined;
+    height: number | undefined;
+    style: NonNullable<JSX.IntrinsicElements['img']['style']>;
+    sizes: string | undefined;
+    srcSet: string | undefined;
+    src: string;
+};
+declare const VALID_LOADING_VALUES: readonly ["lazy", "eager", undefined];
+type LoadingValue = (typeof VALID_LOADING_VALUES)[number];
+export type ImageLoader = (p: ImageLoaderProps) => string;
+type ImageLoaderWithConfig = (p: ImageLoaderPropsWithConfig) => string;
+export type PlaceholderValue = 'blur' | 'empty' | `data:image/${string}`;
+export type OnLoad = React.ReactEventHandler<HTMLImageElement> | undefined;
+export type OnLoadingComplete = (img: HTMLImageElement) => void;
+/**
+ * A shared function, used on both client and server, to generate the props for <img>.
+ */
+export declare function getImgProps({ src, sizes, unoptimized, priority, loading, className, quality, width, height, fill, style, overrideSrc, onLoad, onLoadingComplete, placeholder, blurDataURL, fetchPriority, layout, objectFit, objectPosition, lazyBoundary, lazyRoot, ...rest }: ImageProps, _state: {
+    defaultLoader: ImageLoaderWithConfig;
+    imgConf: ImageConfigComplete;
+    showAltText?: boolean;
+    blurComplete?: boolean;
+}): {
+    props: ImgProps;
+    meta: {
+        unoptimized: boolean;
+        priority: boolean;
+        placeholder: NonNullable<ImageProps['placeholder']>;
+        fill: boolean;
+    };
+};
+export {};

node_modules/next/dist/shared/lib/get-img-props.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getImgProps", {
+    enumerable: true,
+    get: function() {
+        return getImgProps;
+    }
+});
+const _warnonce = require("./utils/warn-once");
+const _imageblursvg = require("./image-blur-svg");
+const _imageconfig = require("./image-config");
+const VALID_LOADING_VALUES = [
+    "lazy",
+    "eager",
+    undefined
+];
+function isStaticRequire(src) {
+    return src.default !== undefined;
+}
+function isStaticImageData(src) {
+    return src.src !== undefined;
+}
+function isStaticImport(src) {
+    return typeof src === "object" && (isStaticRequire(src) || isStaticImageData(src));
+}
+const allImgs = new Map();
+let perfObserver;
+function getInt(x) {
+    if (typeof x === "undefined") {
+        return x;
+    }
+    if (typeof x === "number") {
+        return Number.isFinite(x) ? x : NaN;
+    }
+    if (typeof x === "string" && /^[0-9]+$/.test(x)) {
+        return parseInt(x, 10);
+    }
+    return NaN;
+}
+function getWidths(param, width, sizes) {
+    let { deviceSizes, allSizes } = param;
+    if (sizes) {
+        // Find all the "vw" percent sizes used in the sizes prop
+        const viewportWidthRe = /(^|\s)(1?\d?\d)vw/g;
+        const percentSizes = [];
+        for(let match; match = viewportWidthRe.exec(sizes); match){
+            percentSizes.push(parseInt(match[2]));
+        }
+        if (percentSizes.length) {
+            const smallestRatio = Math.min(...percentSizes) * 0.01;
+            return {
+                widths: allSizes.filter((s)=>s >= deviceSizes[0] * smallestRatio),
+                kind: "w"
+            };
+        }
+        return {
+            widths: allSizes,
+            kind: "w"
+        };
+    }
+    if (typeof width !== "number") {
+        return {
+            widths: deviceSizes,
+            kind: "w"
+        };
+    }
+    const widths = [
+        ...new Set(// > This means that most OLED screens that say they are 3x resolution,
+        // > are actually 3x in the green color, but only 1.5x in the red and
+        // > blue colors. Showing a 3x resolution image in the app vs a 2x
+        // > resolution image will be visually the same, though the 3x image
+        // > takes significantly more data. Even true 3x resolution screens are
+        // > wasteful as the human eye cannot see that level of detail without
+        // > something like a magnifying glass.
+        // https://blog.twitter.com/engineering/en_us/topics/infrastructure/2019/capping-image-fidelity-on-ultra-high-resolution-devices.html
+        [
+            width,
+            width * 2 /*, width * 3*/ 
+        ].map((w)=>allSizes.find((p)=>p >= w) || allSizes[allSizes.length - 1]))
+    ];
+    return {
+        widths,
+        kind: "x"
+    };
+}
+function generateImgAttrs(param) {
+    let { config, src, unoptimized, width, quality, sizes, loader } = param;
+    if (unoptimized) {
+        return {
+            src,
+            srcSet: undefined,
+            sizes: undefined
+        };
+    }
+    const { widths, kind } = getWidths(config, width, sizes);
+    const last = widths.length - 1;
+    return {
+        sizes: !sizes && kind === "w" ? "100vw" : sizes,
+        srcSet: widths.map((w, i)=>loader({
+                config,
+                src,
+                quality,
+                width: w
+            }) + " " + (kind === "w" ? w : i + 1) + kind).join(", "),
+        // It's intended to keep `src` the last attribute because React updates
+        // attributes in order. If we keep `src` the first one, Safari will
+        // immediately start to fetch `src`, before `sizes` and `srcSet` are even
+        // updated by React. That causes multiple unnecessary requests if `srcSet`
+        // and `sizes` are defined.
+        // This bug cannot be reproduced in Chrome or Firefox.
+        src: loader({
+            config,
+            src,
+            quality,
+            width: widths[last]
+        })
+    };
+}
+function getImgProps(param, _state) {
+    let { src, sizes, unoptimized = false, priority = false, loading, className, quality, width, height, fill = false, style, overrideSrc, onLoad, onLoadingComplete, placeholder = "empty", blurDataURL, fetchPriority, layout, objectFit, objectPosition, lazyBoundary, lazyRoot, ...rest } = param;
+    const { imgConf, showAltText, blurComplete, defaultLoader } = _state;
+    let config;
+    let c = imgConf || _imageconfig.imageConfigDefault;
+    if ("allSizes" in c) {
+        config = c;
+    } else {
+        const allSizes = [
+            ...c.deviceSizes,
+            ...c.imageSizes
+        ].sort((a, b)=>a - b);
+        const deviceSizes = c.deviceSizes.sort((a, b)=>a - b);
+        config = {
+            ...c,
+            allSizes,
+            deviceSizes
+        };
+    }
+    if (typeof defaultLoader === "undefined") {
+        throw new Error("images.loaderFile detected but the file is missing default export.\nRead more: https://nextjs.org/docs/messages/invalid-images-config");
+    }
+    let loader = rest.loader || defaultLoader;
+    // Remove property so it's not spread on <img> element
+    delete rest.loader;
+    delete rest.srcSet;
+    // This special value indicates that the user
+    // didn't define a "loader" prop or "loader" config.
+    const isDefaultLoader = "__next_img_default" in loader;
+    if (isDefaultLoader) {
+        if (config.loader === "custom") {
+            throw new Error('Image with src "' + src + '" is missing "loader" prop.' + "\nRead more: https://nextjs.org/docs/messages/next-image-missing-loader");
+        }
+    } else {
+        // The user defined a "loader" prop or config.
+        // Since the config object is internal only, we
+        // must not pass it to the user-defined "loader".
+        const customImageLoader = loader;
+        loader = (obj)=>{
+            const { config: _, ...opts } = obj;
+            return customImageLoader(opts);
+        };
+    }
+    if (layout) {
+        if (layout === "fill") {
+            fill = true;
+        }
+        const layoutToStyle = {
+            intrinsic: {
+                maxWidth: "100%",
+                height: "auto"
+            },
+            responsive: {
+                width: "100%",
+                height: "auto"
+            }
+        };
+        const layoutToSizes = {
+            responsive: "100vw",
+            fill: "100vw"
+        };
+        const layoutStyle = layoutToStyle[layout];
+        if (layoutStyle) {
+            style = {
+                ...style,
+                ...layoutStyle
+            };
+        }
+        const layoutSizes = layoutToSizes[layout];
+        if (layoutSizes && !sizes) {
+            sizes = layoutSizes;
+        }
+    }
+    let staticSrc = "";
+    let widthInt = getInt(width);
+    let heightInt = getInt(height);
+    let blurWidth;
+    let blurHeight;
+    if (isStaticImport(src)) {
+        const staticImageData = isStaticRequire(src) ? src.default : src;
+        if (!staticImageData.src) {
+            throw new Error("An object should only be passed to the image component src parameter if it comes from a static image import. It must include src. Received " + JSON.stringify(staticImageData));
+        }
+        if (!staticImageData.height || !staticImageData.width) {
+            throw new Error("An object should only be passed to the image component src parameter if it comes from a static image import. It must include height and width. Received " + JSON.stringify(staticImageData));
+        }
+        blurWidth = staticImageData.blurWidth;
+        blurHeight = staticImageData.blurHeight;
+        blurDataURL = blurDataURL || staticImageData.blurDataURL;
+        staticSrc = staticImageData.src;
+        if (!fill) {
+            if (!widthInt && !heightInt) {
+                widthInt = staticImageData.width;
+                heightInt = staticImageData.height;
+            } else if (widthInt && !heightInt) {
+                const ratio = widthInt / staticImageData.width;
+                heightInt = Math.round(staticImageData.height * ratio);
+            } else if (!widthInt && heightInt) {
+                const ratio = heightInt / staticImageData.height;
+                widthInt = Math.round(staticImageData.width * ratio);
+            }
+        }
+    }
+    src = typeof src === "string" ? src : staticSrc;
+    let isLazy = !priority && (loading === "lazy" || typeof loading === "undefined");
+    if (!src || src.startsWith("data:") || src.startsWith("blob:")) {
+        // https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
+        unoptimized = true;
+        isLazy = false;
+    }
+    if (config.unoptimized) {
+        unoptimized = true;
+    }
+    if (isDefaultLoader && src.endsWith(".svg") && !config.dangerouslyAllowSVG) {
+        // Special case to make svg serve as-is to avoid proxying
+        // through the built-in Image Optimization API.
+        unoptimized = true;
+    }
+    if (priority) {
+        fetchPriority = "high";
+    }
+    const qualityInt = getInt(quality);
+    if (process.env.NODE_ENV !== "production") {
+        if (config.output === "export" && isDefaultLoader && !unoptimized) {
+            throw new Error("Image Optimization using the default loader is not compatible with `{ output: 'export' }`.\n  Possible solutions:\n    - Remove `{ output: 'export' }` and run \"next start\" to run server mode including the Image Optimization API.\n    - Configure `{ images: { unoptimized: true } }` in `next.config.js` to disable the Image Optimization API.\n  Read more: https://nextjs.org/docs/messages/export-image-api");
+        }
+        if (!src) {
+            // React doesn't show the stack trace and there's
+            // no `src` to help identify which image, so we
+            // instead console.error(ref) during mount.
+            unoptimized = true;
+        } else {
+            if (fill) {
+                if (width) {
+                    throw new Error('Image with src "' + src + '" has both "width" and "fill" properties. Only one should be used.');
+                }
+                if (height) {
+                    throw new Error('Image with src "' + src + '" has both "height" and "fill" properties. Only one should be used.');
+                }
+                if ((style == null ? void 0 : style.position) && style.position !== "absolute") {
+                    throw new Error('Image with src "' + src + '" has both "fill" and "style.position" properties. Images with "fill" always use position absolute - it cannot be modified.');
+                }
+                if ((style == null ? void 0 : style.width) && style.width !== "100%") {
+                    throw new Error('Image with src "' + src + '" has both "fill" and "style.width" properties. Images with "fill" always use width 100% - it cannot be modified.');
+                }
+                if ((style == null ? void 0 : style.height) && style.height !== "100%") {
+                    throw new Error('Image with src "' + src + '" has both "fill" and "style.height" properties. Images with "fill" always use height 100% - it cannot be modified.');
+                }
+            } else {
+                if (typeof widthInt === "undefined") {
+                    throw new Error('Image with src "' + src + '" is missing required "width" property.');
+                } else if (isNaN(widthInt)) {
+                    throw new Error('Image with src "' + src + '" has invalid "width" property. Expected a numeric value in pixels but received "' + width + '".');
+                }
+                if (typeof heightInt === "undefined") {
+                    throw new Error('Image with src "' + src + '" is missing required "height" property.');
+                } else if (isNaN(heightInt)) {
+                    throw new Error('Image with src "' + src + '" has invalid "height" property. Expected a numeric value in pixels but received "' + height + '".');
+                }
+            }
+        }
+        if (!VALID_LOADING_VALUES.includes(loading)) {
+            throw new Error('Image with src "' + src + '" has invalid "loading" property. Provided "' + loading + '" should be one of ' + VALID_LOADING_VALUES.map(String).join(",") + ".");
+        }
+        if (priority && loading === "lazy") {
+            throw new Error('Image with src "' + src + '" has both "priority" and "loading=\'lazy\'" properties. Only one should be used.');
+        }
+        if (placeholder !== "empty" && placeholder !== "blur" && !placeholder.startsWith("data:image/")) {
+            throw new Error('Image with src "' + src + '" has invalid "placeholder" property "' + placeholder + '".');
+        }
+        if (placeholder !== "empty") {
+            if (widthInt && heightInt && widthInt * heightInt < 1600) {
+                (0, _warnonce.warnOnce)('Image with src "' + src + '" is smaller than 40x40. Consider removing the "placeholder" property to improve performance.');
+            }
+        }
+        if (placeholder === "blur" && !blurDataURL) {
+            const VALID_BLUR_EXT = [
+                "jpeg",
+                "png",
+                "webp",
+                "avif"
+            ] // should match next-image-loader
+            ;
+            throw new Error('Image with src "' + src + '" has "placeholder=\'blur\'" property but is missing the "blurDataURL" property.\n        Possible solutions:\n          - Add a "blurDataURL" property, the contents should be a small Data URL to represent the image\n          - Change the "src" property to a static import with one of the supported file types: ' + VALID_BLUR_EXT.join(",") + ' (animated images not supported)\n          - Remove the "placeholder" property, effectively no blur effect\n        Read more: https://nextjs.org/docs/messages/placeholder-blur-data-url');
+        }
+        if ("ref" in rest) {
+            (0, _warnonce.warnOnce)('Image with src "' + src + '" is using unsupported "ref" property. Consider using the "onLoad" property instead.');
+        }
+        if (!unoptimized && !isDefaultLoader) {
+            const urlStr = loader({
+                config,
+                src,
+                width: widthInt || 400,
+                quality: qualityInt || 75
+            });
+            let url;
+            try {
+                url = new URL(urlStr);
+            } catch (err) {}
+            if (urlStr === src || url && url.pathname === src && !url.search) {
+                (0, _warnonce.warnOnce)('Image with src "' + src + '" has a "loader" property that does not implement width. Please implement it or use the "unoptimized" property instead.' + "\nRead more: https://nextjs.org/docs/messages/next-image-missing-loader-width");
+            }
+        }
+        if (onLoadingComplete) {
+            (0, _warnonce.warnOnce)('Image with src "' + src + '" is using deprecated "onLoadingComplete" property. Please use the "onLoad" property instead.');
+        }
+        for (const [legacyKey, legacyValue] of Object.entries({
+            layout,
+            objectFit,
+            objectPosition,
+            lazyBoundary,
+            lazyRoot
+        })){
+            if (legacyValue) {
+                (0, _warnonce.warnOnce)('Image with src "' + src + '" has legacy prop "' + legacyKey + '". Did you forget to run the codemod?' + "\nRead more: https://nextjs.org/docs/messages/next-image-upgrade-to-13");
+            }
+        }
+        if (typeof window !== "undefined" && !perfObserver && window.PerformanceObserver) {
+            perfObserver = new PerformanceObserver((entryList)=>{
+                for (const entry of entryList.getEntries()){
+                    var _entry_element;
+                    // @ts-ignore - missing "LargestContentfulPaint" class with "element" prop
+                    const imgSrc = (entry == null ? void 0 : (_entry_element = entry.element) == null ? void 0 : _entry_element.src) || "";
+                    const lcpImage = allImgs.get(imgSrc);
+                    if (lcpImage && !lcpImage.priority && lcpImage.placeholder === "empty" && !lcpImage.src.startsWith("data:") && !lcpImage.src.startsWith("blob:")) {
+                        // https://web.dev/lcp/#measure-lcp-in-javascript
+                        (0, _warnonce.warnOnce)('Image with src "' + lcpImage.src + '" was detected as the Largest Contentful Paint (LCP). Please add the "priority" property if this image is above the fold.' + "\nRead more: https://nextjs.org/docs/api-reference/next/image#priority");
+                    }
+                }
+            });
+            try {
+                perfObserver.observe({
+                    type: "largest-contentful-paint",
+                    buffered: true
+                });
+            } catch (err) {
+                // Log error but don't crash the app
+                console.error(err);
+            }
+        }
+    }
+    const imgStyle = Object.assign(fill ? {
+        position: "absolute",
+        height: "100%",
+        width: "100%",
+        left: 0,
+        top: 0,
+        right: 0,
+        bottom: 0,
+        objectFit,
+        objectPosition
+    } : {}, showAltText ? {} : {
+        color: "transparent"
+    }, style);
+    const backgroundImage = !blurComplete && placeholder !== "empty" ? placeholder === "blur" ? 'url("data:image/svg+xml;charset=utf-8,' + (0, _imageblursvg.getImageBlurSvg)({
+        widthInt,
+        heightInt,
+        blurWidth,
+        blurHeight,
+        blurDataURL: blurDataURL || "",
+        objectFit: imgStyle.objectFit
+    }) + '")' : 'url("' + placeholder + '")' // assume `data:image/`
+     : null;
+    let placeholderStyle = backgroundImage ? {
+        backgroundSize: imgStyle.objectFit || "cover",
+        backgroundPosition: imgStyle.objectPosition || "50% 50%",
+        backgroundRepeat: "no-repeat",
+        backgroundImage
+    } : {};
+    if (process.env.NODE_ENV === "development") {
+        if (placeholderStyle.backgroundImage && placeholder === "blur" && (blurDataURL == null ? void 0 : blurDataURL.startsWith("/"))) {
+            // During `next dev`, we don't want to generate blur placeholders with webpack
+            // because it can delay starting the dev server. Instead, `next-image-loader.js`
+            // will inline a special url to lazily generate the blur placeholder at request time.
+            placeholderStyle.backgroundImage = 'url("' + blurDataURL + '")';
+        }
+    }
+    const imgAttributes = generateImgAttrs({
+        config,
+        src,
+        unoptimized,
+        width: widthInt,
+        quality: qualityInt,
+        sizes,
+        loader
+    });
+    if (process.env.NODE_ENV !== "production") {
+        if (typeof window !== "undefined") {
+            let fullUrl;
+            try {
+                fullUrl = new URL(imgAttributes.src);
+            } catch (e) {
+                fullUrl = new URL(imgAttributes.src, window.location.href);
+            }
+            allImgs.set(fullUrl.href, {
+                src,
+                priority,
+                placeholder
+            });
+        }
+    }
+    const props = {
+        ...rest,
+        loading: isLazy ? "lazy" : loading,
+        fetchPriority,
+        width: widthInt,
+        height: heightInt,
+        decoding: "async",
+        className,
+        style: {
+            ...imgStyle,
+            ...placeholderStyle
+        },
+        sizes: imgAttributes.sizes,
+        srcSet: imgAttributes.srcSet,
+        src: overrideSrc || imgAttributes.src
+    };
+    const meta = {
+        unoptimized,
+        priority,
+        placeholder,
+        fill
+    };
+    return {
+        props,
+        meta
+    };
+}
+
+//# sourceMappingURL=get-img-props.js.map

node_modules/next/dist/shared/lib/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function djb2Hash(str: string): number;
+export declare function hexHash(str: string): string;

node_modules/next/dist/shared/lib/hash.js

@@ -0,0 +1,42 @@
+// http://www.cse.yorku.ca/~oz/hash.html
+// More specifically, 32-bit hash via djbxor
+// (ref: https://gist.github.com/eplawless/52813b1d8ad9af510d85?permalink_comment_id=3367765#gistcomment-3367765)
+// This is due to number type differences between rust for turbopack to js number types,
+// where rust does not have easy way to repreesnt js's 53-bit float number type for the matching
+// overflow behavior. This is more `correct` in terms of having canonical hash across different runtime / implementation
+// as can gaurantee determinstic output from 32bit hash.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    djb2Hash: null,
+    hexHash: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    djb2Hash: function() {
+        return djb2Hash;
+    },
+    hexHash: function() {
+        return hexHash;
+    }
+});
+function djb2Hash(str) {
+    let hash = 5381;
+    for(let i = 0; i < str.length; i++){
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) + hash + char & 0xffffffff;
+    }
+    return hash >>> 0;
+}
+function hexHash(str) {
+    return djb2Hash(str).toString(36).slice(0, 5);
+}
+
+//# sourceMappingURL=hash.js.map

node_modules/next/dist/shared/lib/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/hash.ts"],"names":["djb2Hash","hexHash","str","hash","i","length","char","charCodeAt","toString","slice"],"mappings":"AAAA,wCAAwC;AACxC,4CAA4C;AAC5C,iHAAiH;AACjH,wFAAwF;AACxF,gGAAgG;AAChG,wHAAwH;AACxH,wDAAwD;;;;;;;;;;;;;;;;IACxCA,QAAQ;eAARA;;IASAC,OAAO;eAAPA;;;AATT,SAASD,SAASE,GAAW;IAClC,IAAIC,OAAO;IACX,IAAK,IAAIC,IAAI,GAAGA,IAAIF,IAAIG,MAAM,EAAED,IAAK;QACnC,MAAME,OAAOJ,IAAIK,UAAU,CAACH;QAC5BD,OAAO,AAAEA,CAAAA,QAAQ,CAAA,IAAKA,OAAOG,OAAQ;IACvC;IACA,OAAOH,SAAS;AAClB;AAEO,SAASF,QAAQC,GAAW;IACjC,OAAOF,SAASE,KAAKM,QAAQ,CAAC,IAAIC,KAAK,CAAC,GAAG;AAC7C"}

node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare const HeadManagerContext: React.Context<{
+    updateHead?: (state: any) => void;
+    mountedInstances?: any;
+    updateScripts?: (state: any) => void;
+    scripts?: any;
+    getIsSsr?: () => boolean;
+    appDir?: boolean;
+    nonce?: string;
+}>;

node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HeadManagerContext", {
+    enumerable: true,
+    get: function() {
+        return HeadManagerContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const HeadManagerContext = _react.default.createContext({});
+if (process.env.NODE_ENV !== "production") {
+    HeadManagerContext.displayName = "HeadManagerContext";
+}
+
+//# sourceMappingURL=head-manager-context.shared-runtime.js.map

node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/head-manager-context.shared-runtime.ts"],"names":["HeadManagerContext","React","createContext","process","env","NODE_ENV","displayName"],"mappings":";;;;+BAEaA;;;eAAAA;;;;gEAFK;AAEX,MAAMA,qBAURC,cAAK,CAACC,aAAa,CAAC,CAAC;AAE1B,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCL,mBAAmBM,WAAW,GAAG;AACnC"}

node_modules/next/dist/shared/lib/head.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare function defaultHead(inAmpMode?: boolean): JSX.Element[];
+/**
+ * This component injects elements to `<head>` of your page.
+ * To avoid duplicated `tags` in `<head>` you can use the `key` property, which will make sure every tag is only rendered once.
+ */
+declare function Head({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export default Head;

node_modules/next/dist/shared/lib/head.js

@@ -0,0 +1,189 @@
+"use client";
+
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    defaultHead: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    defaultHead: function() {
+        return defaultHead;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _sideeffect = /*#__PURE__*/ _interop_require_default._(require("./side-effect"));
+const _ampcontextsharedruntime = require("./amp-context.shared-runtime");
+const _headmanagercontextsharedruntime = require("./head-manager-context.shared-runtime");
+const _ampmode = require("./amp-mode");
+const _warnonce = require("./utils/warn-once");
+function defaultHead(inAmpMode) {
+    if (inAmpMode === void 0) inAmpMode = false;
+    const head = [
+        /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            charSet: "utf-8"
+        })
+    ];
+    if (!inAmpMode) {
+        head.push(/*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            name: "viewport",
+            content: "width=device-width"
+        }));
+    }
+    return head;
+}
+function onlyReactElement(list, child) {
+    // React children can be "string" or "number" in this case we ignore them for backwards compat
+    if (typeof child === "string" || typeof child === "number") {
+        return list;
+    }
+    // Adds support for React.Fragment
+    if (child.type === _react.default.Fragment) {
+        return list.concat(// @ts-expect-error @types/react does not remove fragments but this could also return ReactPortal[]
+        _react.default.Children.toArray(child.props.children).reduce(// @ts-expect-error @types/react does not remove fragments but this could also return ReactPortal[]
+        (fragmentList, fragmentChild)=>{
+            if (typeof fragmentChild === "string" || typeof fragmentChild === "number") {
+                return fragmentList;
+            }
+            return fragmentList.concat(fragmentChild);
+        }, []));
+    }
+    return list.concat(child);
+}
+const METATYPES = [
+    "name",
+    "httpEquiv",
+    "charSet",
+    "itemProp"
+];
+/*
+ returns a function for filtering head child elements
+ which shouldn't be duplicated, like <title/>
+ Also adds support for deduplicated `key` properties
+*/ function unique() {
+    const keys = new Set();
+    const tags = new Set();
+    const metaTypes = new Set();
+    const metaCategories = {};
+    return (h)=>{
+        let isUnique = true;
+        let hasKey = false;
+        if (h.key && typeof h.key !== "number" && h.key.indexOf("$") > 0) {
+            hasKey = true;
+            const key = h.key.slice(h.key.indexOf("$") + 1);
+            if (keys.has(key)) {
+                isUnique = false;
+            } else {
+                keys.add(key);
+            }
+        }
+        // eslint-disable-next-line default-case
+        switch(h.type){
+            case "title":
+            case "base":
+                if (tags.has(h.type)) {
+                    isUnique = false;
+                } else {
+                    tags.add(h.type);
+                }
+                break;
+            case "meta":
+                for(let i = 0, len = METATYPES.length; i < len; i++){
+                    const metatype = METATYPES[i];
+                    if (!h.props.hasOwnProperty(metatype)) continue;
+                    if (metatype === "charSet") {
+                        if (metaTypes.has(metatype)) {
+                            isUnique = false;
+                        } else {
+                            metaTypes.add(metatype);
+                        }
+                    } else {
+                        const category = h.props[metatype];
+                        const categories = metaCategories[metatype] || new Set();
+                        if ((metatype !== "name" || !hasKey) && categories.has(category)) {
+                            isUnique = false;
+                        } else {
+                            categories.add(category);
+                            metaCategories[metatype] = categories;
+                        }
+                    }
+                }
+                break;
+        }
+        return isUnique;
+    };
+}
+/**
+ *
+ * @param headChildrenElements List of children of <Head>
+ */ function reduceComponents(headChildrenElements, props) {
+    const { inAmpMode } = props;
+    return headChildrenElements.reduce(onlyReactElement, []).reverse().concat(defaultHead(inAmpMode).reverse()).filter(unique()).reverse().map((c, i)=>{
+        const key = c.key || i;
+        if (process.env.NODE_ENV !== "development" && process.env.__NEXT_OPTIMIZE_FONTS && !inAmpMode) {
+            if (c.type === "link" && c.props["href"] && // TODO(prateekbh@): Replace this with const from `constants` when the tree shaking works.
+            [
+                "https://fonts.googleapis.com/css",
+                "https://use.typekit.net/"
+            ].some((url)=>c.props["href"].startsWith(url))) {
+                const newProps = {
+                    ...c.props || {}
+                };
+                newProps["data-href"] = newProps["href"];
+                newProps["href"] = undefined;
+                // Add this attribute to make it easy to identify optimized tags
+                newProps["data-optimized-fonts"] = true;
+                return /*#__PURE__*/ _react.default.cloneElement(c, newProps);
+            }
+        }
+        if (process.env.NODE_ENV === "development") {
+            // omit JSON-LD structured data snippets from the warning
+            if (c.type === "script" && c.props["type"] !== "application/ld+json") {
+                const srcMessage = c.props["src"] ? '<script> tag with src="' + c.props["src"] + '"' : "inline <script>";
+                (0, _warnonce.warnOnce)("Do not add <script> tags using next/head (see " + srcMessage + "). Use next/script instead. \nSee more info here: https://nextjs.org/docs/messages/no-script-tags-in-head-component");
+            } else if (c.type === "link" && c.props["rel"] === "stylesheet") {
+                (0, _warnonce.warnOnce)('Do not add stylesheets using next/head (see <link rel="stylesheet"> tag with href="' + c.props["href"] + '"). Use Document instead. \nSee more info here: https://nextjs.org/docs/messages/no-stylesheets-in-head-component');
+            }
+        }
+        return /*#__PURE__*/ _react.default.cloneElement(c, {
+            key
+        });
+    });
+}
+/**
+ * This component injects elements to `<head>` of your page.
+ * To avoid duplicated `tags` in `<head>` you can use the `key` property, which will make sure every tag is only rendered once.
+ */ function Head(param) {
+    let { children } = param;
+    const ampState = (0, _react.useContext)(_ampcontextsharedruntime.AmpStateContext);
+    const headManager = (0, _react.useContext)(_headmanagercontextsharedruntime.HeadManagerContext);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_sideeffect.default, {
+        reduceComponentsToState: reduceComponents,
+        headManager: headManager,
+        inAmpMode: (0, _ampmode.isInAmpMode)(ampState),
+        children: children
+    });
+}
+const _default = Head;
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=head.js.map

node_modules/next/dist/shared/lib/head.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/head.tsx"],"names":["defaultHead","inAmpMode","head","meta","charSet","push","name","content","onlyReactElement","list","child","type","React","Fragment","concat","Children","toArray","props","children","reduce","fragmentList","fragmentChild","METATYPES","unique","keys","Set","tags","metaTypes","metaCategories","h","isUnique","hasKey","key","indexOf","slice","has","add","i","len","length","metatype","hasOwnProperty","category","categories","reduceComponents","headChildrenElements","reverse","filter","map","c","process","env","NODE_ENV","__NEXT_OPTIMIZE_FONTS","some","url","startsWith","newProps","undefined","cloneElement","srcMessage","warnOnce","Head","ampState","useContext","AmpStateContext","headManager","HeadManagerContext","Effect","reduceComponentsToState","isInAmpMode"],"mappings":"AAAA;;;;;;;;;;;;;;;;IAqMA,OAAmB;eAAnB;;IAxLgBA,WAAW;eAAXA;;;;;;iEAXkB;qEACf;yCACa;iDACG;yBACP;0BACH;AAMlB,SAASA,YAAYC,SAAiB;IAAjBA,IAAAA,sBAAAA,YAAY;IACtC,MAAMC,OAAO;sBAAC,qBAACC;YAAKC,SAAQ;;KAAW;IACvC,IAAI,CAACH,WAAW;QACdC,KAAKG,IAAI,eAAC,qBAACF;YAAKG,MAAK;YAAWC,SAAQ;;IAC1C;IACA,OAAOL;AACT;AAEA,SAASM,iBACPC,IAAoC,EACpCC,KAAuB;IAEvB,8FAA8F;IAC9F,IAAI,OAAOA,UAAU,YAAY,OAAOA,UAAU,UAAU;QAC1D,OAAOD;IACT;IACA,kCAAkC;IAClC,IAAIC,MAAMC,IAAI,KAAKC,cAAK,CAACC,QAAQ,EAAE;QACjC,OAAOJ,KAAKK,MAAM,CAChB,mGAAmG;QACnGF,cAAK,CAACG,QAAQ,CAACC,OAAO,CAACN,MAAMO,KAAK,CAACC,QAAQ,EAAEC,MAAM,CACjD,mGAAmG;QACnG,CACEC,cACAC;YAEA,IACE,OAAOA,kBAAkB,YACzB,OAAOA,kBAAkB,UACzB;gBACA,OAAOD;YACT;YACA,OAAOA,aAAaN,MAAM,CAACO;QAC7B,GACA,EAAE;IAGR;IACA,OAAOZ,KAAKK,MAAM,CAACJ;AACrB;AAEA,MAAMY,YAAY;IAAC;IAAQ;IAAa;IAAW;CAAW;AAE9D;;;;AAIA,GACA,SAASC;IACP,MAAMC,OAAO,IAAIC;IACjB,MAAMC,OAAO,IAAID;IACjB,MAAME,YAAY,IAAIF;IACtB,MAAMG,iBAAsD,CAAC;IAE7D,OAAO,CAACC;QACN,IAAIC,WAAW;QACf,IAAIC,SAAS;QAEb,IAAIF,EAAEG,GAAG,IAAI,OAAOH,EAAEG,GAAG,KAAK,YAAYH,EAAEG,GAAG,CAACC,OAAO,CAAC,OAAO,GAAG;YAChEF,SAAS;YACT,MAAMC,MAAMH,EAAEG,GAAG,CAACE,KAAK,CAACL,EAAEG,GAAG,CAACC,OAAO,CAAC,OAAO;YAC7C,IAAIT,KAAKW,GAAG,CAACH,MAAM;gBACjBF,WAAW;YACb,OAAO;gBACLN,KAAKY,GAAG,CAACJ;YACX;QACF;QAEA,wCAAwC;QACxC,OAAQH,EAAElB,IAAI;YACZ,KAAK;YACL,KAAK;gBACH,IAAIe,KAAKS,GAAG,CAACN,EAAElB,IAAI,GAAG;oBACpBmB,WAAW;gBACb,OAAO;oBACLJ,KAAKU,GAAG,CAACP,EAAElB,IAAI;gBACjB;gBACA;YACF,KAAK;gBACH,IAAK,IAAI0B,IAAI,GAAGC,MAAMhB,UAAUiB,MAAM,EAAEF,IAAIC,KAAKD,IAAK;oBACpD,MAAMG,WAAWlB,SAAS,CAACe,EAAE;oBAC7B,IAAI,CAACR,EAAEZ,KAAK,CAACwB,cAAc,CAACD,WAAW;oBAEvC,IAAIA,aAAa,WAAW;wBAC1B,IAAIb,UAAUQ,GAAG,CAACK,WAAW;4BAC3BV,WAAW;wBACb,OAAO;4BACLH,UAAUS,GAAG,CAACI;wBAChB;oBACF,OAAO;wBACL,MAAME,WAAWb,EAAEZ,KAAK,CAACuB,SAAS;wBAClC,MAAMG,aAAaf,cAAc,CAACY,SAAS,IAAI,IAAIf;wBACnD,IAAI,AAACe,CAAAA,aAAa,UAAU,CAACT,MAAK,KAAMY,WAAWR,GAAG,CAACO,WAAW;4BAChEZ,WAAW;wBACb,OAAO;4BACLa,WAAWP,GAAG,CAACM;4BACfd,cAAc,CAACY,SAAS,GAAGG;wBAC7B;oBACF;gBACF;gBACA;QACJ;QAEA,OAAOb;IACT;AACF;AAEA;;;CAGC,GACD,SAASc,iBACPC,oBAAoD,EACpD5B,KAAQ;IAER,MAAM,EAAEhB,SAAS,EAAE,GAAGgB;IACtB,OAAO4B,qBACJ1B,MAAM,CAACX,kBAAkB,EAAE,EAC3BsC,OAAO,GACPhC,MAAM,CAACd,YAAYC,WAAW6C,OAAO,IACrCC,MAAM,CAACxB,UACPuB,OAAO,GACPE,GAAG,CAAC,CAACC,GAA4BZ;QAChC,MAAML,MAAMiB,EAAEjB,GAAG,IAAIK;QACrB,IACEa,QAAQC,GAAG,CAACC,QAAQ,KAAK,iBACzBF,QAAQC,GAAG,CAACE,qBAAqB,IACjC,CAACpD,WACD;YACA,IACEgD,EAAEtC,IAAI,KAAK,UACXsC,EAAEhC,KAAK,CAAC,OAAO,IACf,0FAA0F;YAC1F;gBAAC;gBAAoC;aAA2B,CAACqC,IAAI,CACnE,CAACC,MAAQN,EAAEhC,KAAK,CAAC,OAAO,CAACuC,UAAU,CAACD,OAEtC;gBACA,MAAME,WAAW;oBAAE,GAAIR,EAAEhC,KAAK,IAAI,CAAC,CAAC;gBAAE;gBACtCwC,QAAQ,CAAC,YAAY,GAAGA,QAAQ,CAAC,OAAO;gBACxCA,QAAQ,CAAC,OAAO,GAAGC;gBAEnB,gEAAgE;gBAChED,QAAQ,CAAC,uBAAuB,GAAG;gBAEnC,qBAAO7C,cAAK,CAAC+C,YAAY,CAACV,GAAGQ;YAC/B;QACF;QACA,IAAIP,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;YAC1C,yDAAyD;YACzD,IAAIH,EAAEtC,IAAI,KAAK,YAAYsC,EAAEhC,KAAK,CAAC,OAAO,KAAK,uBAAuB;gBACpE,MAAM2C,aAAaX,EAAEhC,KAAK,CAAC,MAAM,GAC7B,AAAC,4BAAyBgC,EAAEhC,KAAK,CAAC,MAAM,GAAC,MACxC;gBACL4C,IAAAA,kBAAQ,EACN,AAAC,mDAAgDD,aAAW;YAEhE,OAAO,IAAIX,EAAEtC,IAAI,KAAK,UAAUsC,EAAEhC,KAAK,CAAC,MAAM,KAAK,cAAc;gBAC/D4C,IAAAA,kBAAQ,EACN,AAAC,wFAAqFZ,EAAEhC,KAAK,CAAC,OAAO,GAAC;YAE1G;QACF;QACA,qBAAOL,cAAK,CAAC+C,YAAY,CAACV,GAAG;YAAEjB;QAAI;IACrC;AACJ;AAEA;;;CAGC,GACD,SAAS8B,KAAK,KAA2C;IAA3C,IAAA,EAAE5C,QAAQ,EAAiC,GAA3C;IACZ,MAAM6C,WAAWC,IAAAA,iBAAU,EAACC,wCAAe;IAC3C,MAAMC,cAAcF,IAAAA,iBAAU,EAACG,mDAAkB;IACjD,qBACE,qBAACC,mBAAM;QACLC,yBAAyBzB;QACzBsB,aAAaA;QACbjE,WAAWqE,IAAAA,oBAAW,EAACP;kBAEtB7C;;AAGP;MAEA,WAAe4C"}

node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { Params } from '../../shared/lib/router/utils/route-matcher';
+export declare const SearchParamsContext: import("react").Context<URLSearchParams | null>;
+export declare const PathnameContext: import("react").Context<string | null>;
+export declare const PathParamsContext: import("react").Context<Params | null>;

node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js

@@ -0,0 +1,39 @@
+"use client";
+
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PathParamsContext: null,
+    PathnameContext: null,
+    SearchParamsContext: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PathParamsContext: function() {
+        return PathParamsContext;
+    },
+    PathnameContext: function() {
+        return PathnameContext;
+    },
+    SearchParamsContext: function() {
+        return SearchParamsContext;
+    }
+});
+const _react = require("react");
+const SearchParamsContext = (0, _react.createContext)(null);
+const PathnameContext = (0, _react.createContext)(null);
+const PathParamsContext = (0, _react.createContext)(null);
+if (process.env.NODE_ENV !== "production") {
+    SearchParamsContext.displayName = "SearchParamsContext";
+    PathnameContext.displayName = "PathnameContext";
+    PathParamsContext.displayName = "PathParamsContext";
+}
+
+//# sourceMappingURL=hooks-client-context.shared-runtime.js.map

node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/hooks-client-context.shared-runtime.ts"],"names":["PathParamsContext","PathnameContext","SearchParamsContext","createContext","process","env","NODE_ENV","displayName"],"mappings":"AAAA;;;;;;;;;;;;;;;;;IAOaA,iBAAiB;eAAjBA;;IADAC,eAAe;eAAfA;;IADAC,mBAAmB;eAAnBA;;;uBAHiB;AAGvB,MAAMA,sBAAsBC,IAAAA,oBAAa,EAAyB;AAClE,MAAMF,kBAAkBE,IAAAA,oBAAa,EAAgB;AACrD,MAAMH,oBAAoBG,IAAAA,oBAAa,EAAgB;AAE9D,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCJ,oBAAoBK,WAAW,GAAG;IAClCN,gBAAgBM,WAAW,GAAG;IAC9BP,kBAAkBO,WAAW,GAAG;AAClC"}

node_modules/next/dist/shared/lib/html-context.shared-runtime.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="react" />
+import type { BuildManifest } from '../../server/get-page-files';
+import type { ServerRuntime } from 'next/types';
+import type { NEXT_DATA } from './utils';
+import type { FontConfig } from '../../server/font-utils';
+import type { NextFontManifest } from '../../build/webpack/plugins/next-font-manifest-plugin';
+import type { DeepReadonly } from './deep-readonly';
+export type HtmlProps = {
+    __NEXT_DATA__: NEXT_DATA;
+    strictNextHead: boolean;
+    dangerousAsPath: string;
+    docComponentsRendered: {
+        Html?: boolean;
+        Main?: boolean;
+        Head?: boolean;
+        NextScript?: boolean;
+    };
+    buildManifest: BuildManifest;
+    ampPath: string;
+    inAmpMode: boolean;
+    hybridAmp: boolean;
+    isDevelopment: boolean;
+    dynamicImports: string[];
+    assetPrefix?: string;
+    canonicalBase: string;
+    headTags: any[];
+    unstable_runtimeJS?: false;
+    unstable_JsPreload?: false;
+    assetQueryString: string;
+    scriptLoader: {
+        afterInteractive?: string[];
+        beforeInteractive?: any[];
+        worker?: any[];
+    };
+    locale?: string;
+    disableOptimizedLoading?: boolean;
+    styles?: React.ReactElement[] | React.ReactFragment;
+    head?: Array<JSX.Element | null>;
+    crossOrigin?: 'anonymous' | 'use-credentials' | '' | undefined;
+    optimizeCss?: any;
+    optimizeFonts?: FontConfig;
+    nextConfigOutput?: 'standalone' | 'export';
+    nextScriptWorkers?: boolean;
+    runtime?: ServerRuntime;
+    hasConcurrentFeatures?: boolean;
+    largePageDataBytes?: number;
+    nextFontManifest?: DeepReadonly<NextFontManifest>;
+};
+export declare const HtmlContext: import("react").Context<HtmlProps | undefined>;
+export declare function useHtmlContext(): HtmlProps;

node_modules/next/dist/shared/lib/html-context.shared-runtime.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HtmlContext: null,
+    useHtmlContext: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HtmlContext: function() {
+        return HtmlContext;
+    },
+    useHtmlContext: function() {
+        return useHtmlContext;
+    }
+});
+const _react = require("react");
+const HtmlContext = (0, _react.createContext)(undefined);
+if (process.env.NODE_ENV !== "production") {
+    HtmlContext.displayName = "HtmlContext";
+}
+function useHtmlContext() {
+    const context = (0, _react.useContext)(HtmlContext);
+    if (!context) {
+        throw new Error("<Html> should not be imported outside of pages/_document.\n" + "Read more: https://nextjs.org/docs/messages/no-document-import-in-page");
+    }
+    return context;
+}
+
+//# sourceMappingURL=html-context.shared-runtime.js.map

node_modules/next/dist/shared/lib/html-context.shared-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/html-context.shared-runtime.ts"],"names":["HtmlContext","useHtmlContext","createContext","undefined","process","env","NODE_ENV","displayName","context","useContext","Error"],"mappings":";;;;;;;;;;;;;;;IAmDaA,WAAW;eAAXA;;IAKGC,cAAc;eAAdA;;;uBAjD0B;AA4CnC,MAAMD,cAAcE,IAAAA,oBAAa,EAAwBC;AAChE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCN,YAAYO,WAAW,GAAG;AAC5B;AAEO,SAASN;IACd,MAAMO,UAAUC,IAAAA,iBAAU,EAACT;IAE3B,IAAI,CAACQ,SAAS;QACZ,MAAM,IAAIE,MACR,AAAC,gEACC;IAEN;IAEA,OAAOF;AACT"}

node_modules/next/dist/shared/lib/i18n/detect-domain-locale.d.ts

@@ -0,0 +1,2 @@
+import type { DomainLocale } from '../../../server/config-shared';
+export declare function detectDomainLocale(domainItems?: DomainLocale[], hostname?: string, detectedLocale?: string): DomainLocale | undefined;

node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "detectDomainLocale", {
+    enumerable: true,
+    get: function() {
+        return detectDomainLocale;
+    }
+});
+function detectDomainLocale(domainItems, hostname, detectedLocale) {
+    if (!domainItems) return;
+    if (detectedLocale) {
+        detectedLocale = detectedLocale.toLowerCase();
+    }
+    for (const item of domainItems){
+        var _item_domain, _item_locales;
+        // remove port if present
+        const domainHostname = (_item_domain = item.domain) == null ? void 0 : _item_domain.split(":", 1)[0].toLowerCase();
+        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || ((_item_locales = item.locales) == null ? void 0 : _item_locales.some((locale)=>locale.toLowerCase() === detectedLocale))) {
+            return item;
+        }
+    }
+}
+
+//# sourceMappingURL=detect-domain-locale.js.map

node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/i18n/detect-domain-locale.ts"],"names":["detectDomainLocale","domainItems","hostname","detectedLocale","toLowerCase","item","domainHostname","domain","split","defaultLocale","locales","some","locale"],"mappings":";;;;+BAEgBA;;;eAAAA;;;AAAT,SAASA,mBACdC,WAA4B,EAC5BC,QAAiB,EACjBC,cAAuB;IAEvB,IAAI,CAACF,aAAa;IAElB,IAAIE,gBAAgB;QAClBA,iBAAiBA,eAAeC,WAAW;IAC7C;IAEA,KAAK,MAAMC,QAAQJ,YAAa;YAEPI,cAIrBA;QALF,yBAAyB;QACzB,MAAMC,kBAAiBD,eAAAA,KAAKE,MAAM,qBAAXF,aAAaG,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,CAACJ,WAAW;QAChE,IACEF,aAAaI,kBACbH,mBAAmBE,KAAKI,aAAa,CAACL,WAAW,QACjDC,gBAAAA,KAAKK,OAAO,qBAAZL,cAAcM,IAAI,CAAC,CAACC,SAAWA,OAAOR,WAAW,OAAOD,kBACxD;YACA,OAAOE;QACT;IACF;AACF"}

node_modules/next/dist/shared/lib/i18n/get-locale-redirect.d.ts

@@ -0,0 +1,21 @@
+import type { DomainLocale } from '../../../server/config';
+import type { I18NConfig } from '../../../server/config-shared';
+interface Options {
+    defaultLocale: string;
+    domainLocale?: DomainLocale;
+    headers?: {
+        [key: string]: string | string[] | undefined;
+    };
+    nextConfig: {
+        basePath?: string;
+        i18n?: I18NConfig | null;
+        trailingSlash?: boolean;
+    };
+    pathLocale?: string;
+    urlParsed: {
+        hostname?: string | null;
+        pathname: string;
+    };
+}
+export declare function getLocaleRedirect({ defaultLocale, domainLocale, pathLocale, headers, nextConfig, urlParsed, }: Options): string | undefined;
+export {};

node_modules/next/dist/shared/lib/i18n/get-locale-redirect.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getLocaleRedirect", {
+    enumerable: true,
+    get: function() {
+        return getLocaleRedirect;
+    }
+});
+const _acceptheader = require("../../../server/accept-header");
+const _denormalizepagepath = require("../page-path/denormalize-page-path");
+const _detectdomainlocale = require("./detect-domain-locale");
+const _formaturl = require("../router/utils/format-url");
+const _getcookieparser = require("../../../server/api-utils/get-cookie-parser");
+function getLocaleFromCookie(i18n, headers) {
+    if (headers === void 0) headers = {};
+    var _getCookieParser_NEXT_LOCALE, _getCookieParser;
+    const nextLocale = (_getCookieParser = (0, _getcookieparser.getCookieParser)(headers || {})()) == null ? void 0 : (_getCookieParser_NEXT_LOCALE = _getCookieParser.NEXT_LOCALE) == null ? void 0 : _getCookieParser_NEXT_LOCALE.toLowerCase();
+    return nextLocale ? i18n.locales.find((locale)=>nextLocale === locale.toLowerCase()) : undefined;
+}
+function detectLocale(param) {
+    let { i18n, headers, domainLocale, preferredLocale, pathLocale } = param;
+    return pathLocale || (domainLocale == null ? void 0 : domainLocale.defaultLocale) || getLocaleFromCookie(i18n, headers) || preferredLocale || i18n.defaultLocale;
+}
+function getAcceptPreferredLocale(i18n, headers) {
+    if ((headers == null ? void 0 : headers["accept-language"]) && !Array.isArray(headers["accept-language"])) {
+        try {
+            return (0, _acceptheader.acceptLanguage)(headers["accept-language"], i18n.locales);
+        } catch (err) {}
+    }
+}
+function getLocaleRedirect(param) {
+    let { defaultLocale, domainLocale, pathLocale, headers, nextConfig, urlParsed } = param;
+    if (nextConfig.i18n && nextConfig.i18n.localeDetection !== false && (0, _denormalizepagepath.denormalizePagePath)(urlParsed.pathname) === "/") {
+        const preferredLocale = getAcceptPreferredLocale(nextConfig.i18n, headers);
+        const detectedLocale = detectLocale({
+            i18n: nextConfig.i18n,
+            preferredLocale,
+            headers,
+            pathLocale,
+            domainLocale
+        });
+        const preferredDomain = (0, _detectdomainlocale.detectDomainLocale)(nextConfig.i18n.domains, undefined, preferredLocale);
+        if (domainLocale && preferredDomain) {
+            const isPDomain = preferredDomain.domain === domainLocale.domain;
+            const isPLocale = preferredDomain.defaultLocale === preferredLocale;
+            if (!isPDomain || !isPLocale) {
+                const scheme = "http" + (preferredDomain.http ? "" : "s");
+                const rlocale = isPLocale ? "" : preferredLocale;
+                return scheme + "://" + preferredDomain.domain + "/" + rlocale;
+            }
+        }
+        if (detectedLocale.toLowerCase() !== defaultLocale.toLowerCase()) {
+            return (0, _formaturl.formatUrl)({
+                ...urlParsed,
+                pathname: (nextConfig.basePath || "") + "/" + detectedLocale + (nextConfig.trailingSlash ? "/" : "")
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=get-locale-redirect.js.map

node_modules/next/dist/shared/lib/i18n/get-locale-redirect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/i18n/get-locale-redirect.ts"],"names":["getLocaleRedirect","getLocaleFromCookie","i18n","headers","getCookieParser","nextLocale","NEXT_LOCALE","toLowerCase","locales","find","locale","undefined","detectLocale","domainLocale","preferredLocale","pathLocale","defaultLocale","getAcceptPreferredLocale","Array","isArray","acceptLanguage","err","nextConfig","urlParsed","localeDetection","denormalizePagePath","pathname","detectedLocale","preferredDomain","detectDomainLocale","domains","isPDomain","domain","isPLocale","scheme","http","rlocale","formatUrl","basePath","trailingSlash"],"mappings":";;;;+BAqEgBA;;;eAAAA;;;8BAnEe;qCACK;oCACD;2BACT;iCACM;AAehC,SAASC,oBACPC,IAAgB,EAChBC,OAA8D;IAA9DA,IAAAA,oBAAAA,UAA4D,CAAC;QAE1CC,8BAAAA;IAAnB,MAAMC,cAAaD,mBAAAA,IAAAA,gCAAe,EAChCD,WAAW,CAAC,0BADKC,+BAAAA,iBAEdE,WAAW,qBAFGF,6BAEDG,WAAW;IAC7B,OAAOF,aACHH,KAAKM,OAAO,CAACC,IAAI,CAAC,CAACC,SAAWL,eAAeK,OAAOH,WAAW,MAC/DI;AACN;AAEA,SAASC,aAAa,KAYrB;IAZqB,IAAA,EACpBV,IAAI,EACJC,OAAO,EACPU,YAAY,EACZC,eAAe,EACfC,UAAU,EAOX,GAZqB;IAapB,OACEA,eACAF,gCAAAA,aAAcG,aAAa,KAC3Bf,oBAAoBC,MAAMC,YAC1BW,mBACAZ,KAAKc,aAAa;AAEtB;AAEA,SAASC,yBACPf,IAAgB,EAChBC,OAA0D;IAE1D,IACEA,CAAAA,2BAAAA,OAAS,CAAC,kBAAkB,KAC5B,CAACe,MAAMC,OAAO,CAAChB,OAAO,CAAC,kBAAkB,GACzC;QACA,IAAI;YACF,OAAOiB,IAAAA,4BAAc,EAACjB,OAAO,CAAC,kBAAkB,EAAED,KAAKM,OAAO;QAChE,EAAE,OAAOa,KAAK,CAAC;IACjB;AACF;AAEO,SAASrB,kBAAkB,KAOxB;IAPwB,IAAA,EAChCgB,aAAa,EACbH,YAAY,EACZE,UAAU,EACVZ,OAAO,EACPmB,UAAU,EACVC,SAAS,EACD,GAPwB;IAQhC,IACED,WAAWpB,IAAI,IACfoB,WAAWpB,IAAI,CAACsB,eAAe,KAAK,SACpCC,IAAAA,wCAAmB,EAACF,UAAUG,QAAQ,MAAM,KAC5C;QACA,MAAMZ,kBAAkBG,yBAAyBK,WAAWpB,IAAI,EAAEC;QAClE,MAAMwB,iBAAiBf,aAAa;YAClCV,MAAMoB,WAAWpB,IAAI;YACrBY;YACAX;YACAY;YACAF;QACF;QAEA,MAAMe,kBAAkBC,IAAAA,sCAAkB,EACxCP,WAAWpB,IAAI,CAAC4B,OAAO,EACvBnB,WACAG;QAGF,IAAID,gBAAgBe,iBAAiB;YACnC,MAAMG,YAAYH,gBAAgBI,MAAM,KAAKnB,aAAamB,MAAM;YAChE,MAAMC,YAAYL,gBAAgBZ,aAAa,KAAKF;YACpD,IAAI,CAACiB,aAAa,CAACE,WAAW;gBAC5B,MAAMC,SAAS,AAAC,SAAMN,CAAAA,gBAAgBO,IAAI,GAAG,KAAK,GAAE;gBACpD,MAAMC,UAAUH,YAAY,KAAKnB;gBACjC,OAAO,AAAGoB,SAAO,QAAKN,gBAAgBI,MAAM,GAAC,MAAGI;YAClD;QACF;QAEA,IAAIT,eAAepB,WAAW,OAAOS,cAAcT,WAAW,IAAI;YAChE,OAAO8B,IAAAA,oBAAS,EAAC;gBACf,GAAGd,SAAS;gBACZG,UAAU,AAAGJ,CAAAA,WAAWgB,QAAQ,IAAI,EAAC,IAAE,MAAGX,iBACxCL,CAAAA,WAAWiB,aAAa,GAAG,MAAM,EAAC;YAEtC;QACF;IACF;AACF"}

node_modules/next/dist/shared/lib/i18n/normalize-locale-path.d.ts

@@ -0,0 +1,14 @@
+export interface PathLocale {
+    detectedLocale?: string;
+    pathname: string;
+}
+/**
+ * For a pathname that may include a locale from a list of locales, it
+ * removes the locale from the pathname returning it alongside with the
+ * detected locale.
+ *
+ * @param pathname A pathname that may include a locale.
+ * @param locales A list of locales.
+ * @returns The detected locale and pathname without locale
+ */
+export declare function normalizeLocalePath(pathname: string, locales?: string[]): PathLocale;

node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeLocalePath", {
+    enumerable: true,
+    get: function() {
+        return normalizeLocalePath;
+    }
+});
+function normalizeLocalePath(pathname, locales) {
+    let detectedLocale;
+    // first item will be empty string from splitting at first char
+    const pathnameParts = pathname.split("/");
+    (locales || []).some((locale)=>{
+        if (pathnameParts[1] && pathnameParts[1].toLowerCase() === locale.toLowerCase()) {
+            detectedLocale = locale;
+            pathnameParts.splice(1, 1);
+            pathname = pathnameParts.join("/") || "/";
+            return true;
+        }
+        return false;
+    });
+    return {
+        pathname,
+        detectedLocale
+    };
+}
+
+//# sourceMappingURL=normalize-locale-path.js.map

node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/i18n/normalize-locale-path.ts"],"names":["normalizeLocalePath","pathname","locales","detectedLocale","pathnameParts","split","some","locale","toLowerCase","splice","join"],"mappings":";;;;+BAcgBA;;;eAAAA;;;AAAT,SAASA,oBACdC,QAAgB,EAChBC,OAAkB;IAElB,IAAIC;IACJ,+DAA+D;IAC/D,MAAMC,gBAAgBH,SAASI,KAAK,CAAC;IAEnCH,CAAAA,WAAW,EAAE,AAAD,EAAGI,IAAI,CAAC,CAACC;QACrB,IACEH,aAAa,CAAC,EAAE,IAChBA,aAAa,CAAC,EAAE,CAACI,WAAW,OAAOD,OAAOC,WAAW,IACrD;YACAL,iBAAiBI;YACjBH,cAAcK,MAAM,CAAC,GAAG;YACxBR,WAAWG,cAAcM,IAAI,CAAC,QAAQ;YACtC,OAAO;QACT;QACA,OAAO;IACT;IAEA,OAAO;QACLT;QACAE;IACF;AACF"}

node_modules/next/dist/shared/lib/image-blur-svg.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A shared function, used on both client and server, to generate a SVG blur placeholder.
+ */
+export declare function getImageBlurSvg({ widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit, }: {
+    widthInt?: number;
+    heightInt?: number;
+    blurWidth?: number;
+    blurHeight?: number;
+    blurDataURL: string;
+    objectFit?: string;
+}): string;

node_modules/next/dist/shared/lib/image-blur-svg.js

@@ -0,0 +1,23 @@
+/**
+ * A shared function, used on both client and server, to generate a SVG blur placeholder.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getImageBlurSvg", {
+    enumerable: true,
+    get: function() {
+        return getImageBlurSvg;
+    }
+});
+function getImageBlurSvg(param) {
+    let { widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit } = param;
+    const std = 20;
+    const svgWidth = blurWidth ? blurWidth * 40 : widthInt;
+    const svgHeight = blurHeight ? blurHeight * 40 : heightInt;
+    const viewBox = svgWidth && svgHeight ? "viewBox='0 0 " + svgWidth + " " + svgHeight + "'" : "";
+    const preserveAspectRatio = viewBox ? "none" : objectFit === "contain" ? "xMidYMid" : objectFit === "cover" ? "xMidYMid slice" : "none";
+    return "%3Csvg xmlns='http://www.w3.org/2000/svg' " + viewBox + "%3E%3Cfilter id='b' color-interpolation-filters='sRGB'%3E%3CfeGaussianBlur stdDeviation='" + std + "'/%3E%3CfeColorMatrix values='1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1' result='s'/%3E%3CfeFlood x='0' y='0' width='100%25' height='100%25'/%3E%3CfeComposite operator='out' in='s'/%3E%3CfeComposite in2='SourceGraphic'/%3E%3CfeGaussianBlur stdDeviation='" + std + "'/%3E%3C/filter%3E%3Cimage width='100%25' height='100%25' x='0' y='0' preserveAspectRatio='" + preserveAspectRatio + "' style='filter: url(%23b);' href='" + blurDataURL + "'/%3E%3C/svg%3E";
+}
+
+//# sourceMappingURL=image-blur-svg.js.map

node_modules/next/dist/shared/lib/image-blur-svg.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/image-blur-svg.ts"],"names":["getImageBlurSvg","widthInt","heightInt","blurWidth","blurHeight","blurDataURL","objectFit","std","svgWidth","svgHeight","viewBox","preserveAspectRatio"],"mappings":"AAAA;;CAEC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,gBAAgB,KAc/B;IAd+B,IAAA,EAC9BC,QAAQ,EACRC,SAAS,EACTC,SAAS,EACTC,UAAU,EACVC,WAAW,EACXC,SAAS,EAQV,GAd+B;IAe9B,MAAMC,MAAM;IACZ,MAAMC,WAAWL,YAAYA,YAAY,KAAKF;IAC9C,MAAMQ,YAAYL,aAAaA,aAAa,KAAKF;IAEjD,MAAMQ,UACJF,YAAYC,YAAY,AAAC,kBAAeD,WAAS,MAAGC,YAAU,MAAK;IACrE,MAAME,sBAAsBD,UACxB,SACAJ,cAAc,YACd,aACAA,cAAc,UACd,mBACA;IAEJ,OAAO,AAAC,+CAA4CI,UAAQ,8FAA2FH,MAAI,oQAAiQA,MAAI,gGAA6FI,sBAAoB,wCAAqCN,cAAY;AACpkB"}

node_modules/next/dist/shared/lib/image-config-context.shared-runtime.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { ImageConfigComplete } from './image-config';
+export declare const ImageConfigContext: React.Context<ImageConfigComplete>;

node_modules/next/dist/shared/lib/image-config-context.shared-runtime.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImageConfigContext", {
+    enumerable: true,
+    get: function() {
+        return ImageConfigContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _imageconfig = require("./image-config");
+const ImageConfigContext = _react.default.createContext(_imageconfig.imageConfigDefault);
+if (process.env.NODE_ENV !== "production") {
+    ImageConfigContext.displayName = "ImageConfigContext";
+}
+
+//# sourceMappingURL=image-config-context.shared-runtime.js.map

node_modules/next/dist/shared/lib/image-config-context.shared-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/image-config-context.shared-runtime.ts"],"names":["ImageConfigContext","React","createContext","imageConfigDefault","process","env","NODE_ENV","displayName"],"mappings":";;;;+BAIaA;;;eAAAA;;;;gEAJK;6BAEiB;AAE5B,MAAMA,qBACXC,cAAK,CAACC,aAAa,CAAsBC,+BAAkB;AAE7D,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzCN,mBAAmBO,WAAW,GAAG;AACnC"}

node_modules/next/dist/shared/lib/image-config.d.ts

@@ -0,0 +1,74 @@
+export declare const VALID_LOADERS: readonly ["default", "imgix", "cloudinary", "akamai", "custom"];
+export type LoaderValue = (typeof VALID_LOADERS)[number];
+export type ImageLoaderProps = {
+    src: string;
+    width: number;
+    quality?: number;
+};
+export type ImageLoaderPropsWithConfig = ImageLoaderProps & {
+    config: Readonly<ImageConfig>;
+};
+export type RemotePattern = {
+    /**
+     * Must be `http` or `https`.
+     */
+    protocol?: 'http' | 'https';
+    /**
+     * Can be literal or wildcard.
+     * Single `*` matches a single subdomain.
+     * Double `**` matches any number of subdomains.
+     */
+    hostname: string;
+    /**
+     * Can be literal port such as `8080` or empty string
+     * meaning no port.
+     */
+    port?: string;
+    /**
+     * Can be literal or wildcard.
+     * Single `*` matches a single path segment.
+     * Double `**` matches any number of path segments.
+     */
+    pathname?: string;
+};
+type ImageFormat = 'image/avif' | 'image/webp';
+/**
+ * Image configurations
+ *
+ * @see [Image configuration options](https://nextjs.org/docs/api-reference/next/image#configuration-options)
+ */
+export type ImageConfigComplete = {
+    /** @see [Device sizes documentation](https://nextjs.org/docs/api-reference/next/image#device-sizes) */
+    deviceSizes: number[];
+    /** @see [Image sizing documentation](https://nextjs.org/docs/basic-features/image-optimization#image-sizing) */
+    imageSizes: number[];
+    /** @see [Image loaders configuration](https://nextjs.org/docs/api-reference/next/legacy/image#loader) */
+    loader: LoaderValue;
+    /** @see [Image loader configuration](https://nextjs.org/docs/api-reference/next/legacy/image#loader-configuration) */
+    path: string;
+    /** @see [Image loader configuration](https://nextjs.org/docs/api-reference/next/image#loader-configuration) */
+    loaderFile: string;
+    /**
+     * @deprecated Use `remotePatterns` instead.
+     */
+    domains: string[];
+    /** @see [Disable static image import configuration](https://nextjs.org/docs/api-reference/next/image#disable-static-imports) */
+    disableStaticImages: boolean;
+    /** @see [Cache behavior](https://nextjs.org/docs/api-reference/next/image#caching-behavior) */
+    minimumCacheTTL: number;
+    /** @see [Acceptable formats](https://nextjs.org/docs/api-reference/next/image#acceptable-formats) */
+    formats: ImageFormat[];
+    /** @see [Dangerously Allow SVG](https://nextjs.org/docs/api-reference/next/image#dangerously-allow-svg) */
+    dangerouslyAllowSVG: boolean;
+    /** @see [Dangerously Allow SVG](https://nextjs.org/docs/api-reference/next/image#dangerously-allow-svg) */
+    contentSecurityPolicy: string;
+    /** @see [Dangerously Allow SVG](https://nextjs.org/docs/api-reference/next/image#dangerously-allow-svg) */
+    contentDispositionType: 'inline' | 'attachment';
+    /** @see [Remote Patterns](https://nextjs.org/docs/api-reference/next/image#remotepatterns) */
+    remotePatterns: RemotePattern[];
+    /** @see [Unoptimized](https://nextjs.org/docs/api-reference/next/image#unoptimized) */
+    unoptimized: boolean;
+};
+export type ImageConfig = Partial<ImageConfigComplete>;
+export declare const imageConfigDefault: ImageConfigComplete;
+export {};

node_modules/next/dist/shared/lib/image-config.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    VALID_LOADERS: null,
+    imageConfigDefault: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    VALID_LOADERS: function() {
+        return VALID_LOADERS;
+    },
+    imageConfigDefault: function() {
+        return imageConfigDefault;
+    }
+});
+const VALID_LOADERS = [
+    "default",
+    "imgix",
+    "cloudinary",
+    "akamai",
+    "custom"
+];
+const imageConfigDefault = {
+    deviceSizes: [
+        640,
+        750,
+        828,
+        1080,
+        1200,
+        1920,
+        2048,
+        3840
+    ],
+    imageSizes: [
+        16,
+        32,
+        48,
+        64,
+        96,
+        128,
+        256,
+        384
+    ],
+    path: "/_next/image",
+    loader: "default",
+    loaderFile: "",
+    domains: [],
+    disableStaticImages: false,
+    minimumCacheTTL: 60,
+    formats: [
+        "image/webp"
+    ],
+    dangerouslyAllowSVG: false,
+    contentSecurityPolicy: "script-src 'none'; frame-src 'none'; sandbox;",
+    contentDispositionType: "inline",
+    remotePatterns: [],
+    unoptimized: false
+};
+
+//# sourceMappingURL=image-config.js.map

node_modules/next/dist/shared/lib/image-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/image-config.ts"],"names":["VALID_LOADERS","imageConfigDefault","deviceSizes","imageSizes","path","loader","loaderFile","domains","disableStaticImages","minimumCacheTTL","formats","dangerouslyAllowSVG","contentSecurityPolicy","contentDispositionType","remotePatterns","unoptimized"],"mappings":";;;;;;;;;;;;;;;IAAaA,aAAa;eAAbA;;IAsGAC,kBAAkB;eAAlBA;;;AAtGN,MAAMD,gBAAgB;IAC3B;IACA;IACA;IACA;IACA;CACD;AAgGM,MAAMC,qBAA0C;IACrDC,aAAa;QAAC;QAAK;QAAK;QAAK;QAAM;QAAM;QAAM;QAAM;KAAK;IAC1DC,YAAY;QAAC;QAAI;QAAI;QAAI;QAAI;QAAI;QAAK;QAAK;KAAI;IAC/CC,MAAM;IACNC,QAAQ;IACRC,YAAY;IACZC,SAAS,EAAE;IACXC,qBAAqB;IACrBC,iBAAiB;IACjBC,SAAS;QAAC;KAAa;IACvBC,qBAAqB;IACrBC,uBAAwB;IACxBC,wBAAwB;IACxBC,gBAAgB,EAAE;IAClBC,aAAa;AACf"}

node_modules/next/dist/shared/lib/image-external.d.ts

@@ -0,0 +1,15 @@
+import type { ImageLoaderProps } from './image-config';
+import type { ImageProps, ImageLoader, StaticImageData } from './get-img-props';
+import { Image } from '../../client/image-component';
+/**
+ * For more advanced use cases, you can call `getImageProps()`
+ * to get the props that would be passed to the underlying `<img>` element,
+ * and instead pass to them to another component, style, canvas, etc.
+ *
+ * Read more: [Next.js docs: `getImageProps`](https://nextjs.org/docs/app/api-reference/components/image#getimageprops)
+ */
+export declare function getImageProps(imgProps: ImageProps): {
+    props: import("./get-img-props").ImgProps;
+};
+export default Image;
+export type { ImageProps, ImageLoaderProps, ImageLoader, StaticImageData };

node_modules/next/dist/shared/lib/image-external.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    getImageProps: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    getImageProps: function() {
+        return getImageProps;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _getimgprops = require("./get-img-props");
+const _imagecomponent = require("../../client/image-component");
+const _imageloader = /*#__PURE__*/ _interop_require_default._(require("next/dist/shared/lib/image-loader"));
+function getImageProps(imgProps) {
+    const { props } = (0, _getimgprops.getImgProps)(imgProps, {
+        defaultLoader: _imageloader.default,
+        // This is replaced by webpack define plugin
+        imgConf: process.env.__NEXT_IMAGE_OPTS
+    });
+    // Normally we don't care about undefined props because we pass to JSX,
+    // but this exported function could be used by the end user for anything
+    // so we delete undefined props to clean it up a little.
+    for (const [key, value] of Object.entries(props)){
+        if (value === undefined) {
+            delete props[key];
+        }
+    }
+    return {
+        props
+    };
+}
+const _default = _imagecomponent.Image;
+
+//# sourceMappingURL=image-external.js.map

node_modules/next/dist/shared/lib/image-external.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/image-external.tsx"],"names":["getImageProps","imgProps","props","getImgProps","defaultLoader","imgConf","process","env","__NEXT_IMAGE_OPTS","key","value","Object","entries","undefined","Image"],"mappings":";;;;;;;;;;;;;;;IAiCA,OAAoB;eAApB;;IAjBgBA,aAAa;eAAbA;;;;6BAbY;gCACN;sEAGI;AASnB,SAASA,cAAcC,QAAoB;IAChD,MAAM,EAAEC,KAAK,EAAE,GAAGC,IAAAA,wBAAW,EAACF,UAAU;QACtCG,eAAAA,oBAAa;QACb,4CAA4C;QAC5CC,SAASC,QAAQC,GAAG,CAACC,iBAAiB;IACxC;IACA,uEAAuE;IACvE,wEAAwE;IACxE,wDAAwD;IACxD,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACV,OAAQ;QAChD,IAAIQ,UAAUG,WAAW;YACvB,OAAOX,KAAK,CAACO,IAA0B;QACzC;IACF;IACA,OAAO;QAAEP;IAAM;AACjB;MAEA,WAAeY,qBAAK"}

node_modules/next/dist/shared/lib/image-loader.d.ts

@@ -0,0 +1,6 @@
+import type { ImageLoaderPropsWithConfig } from './image-config';
+declare function defaultLoader({ config, src, width, quality, }: ImageLoaderPropsWithConfig): string;
+declare namespace defaultLoader {
+    var __next_img_default: boolean;
+}
+export default defaultLoader;

node_modules/next/dist/shared/lib/image-loader.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+function defaultLoader(param) {
+    let { config, src, width, quality } = param;
+    if (process.env.NODE_ENV !== "production") {
+        const missingValues = [];
+        // these should always be provided but make sure they are
+        if (!src) missingValues.push("src");
+        if (!width) missingValues.push("width");
+        if (missingValues.length > 0) {
+            throw new Error("Next Image Optimization requires " + missingValues.join(", ") + " to be provided. Make sure you pass them as props to the `next/image` component. Received: " + JSON.stringify({
+                src,
+                width,
+                quality
+            }));
+        }
+        if (src.startsWith("//")) {
+            throw new Error('Failed to parse src "' + src + '" on `next/image`, protocol-relative URL (//) must be changed to an absolute URL (http:// or https://)');
+        }
+        if (!src.startsWith("/") && (config.domains || config.remotePatterns)) {
+            let parsedSrc;
+            try {
+                parsedSrc = new URL(src);
+            } catch (err) {
+                console.error(err);
+                throw new Error('Failed to parse src "' + src + '" on `next/image`, if using relative image it must start with a leading slash "/" or be an absolute URL (http:// or https://)');
+            }
+            if (process.env.NODE_ENV !== "test" && // micromatch isn't compatible with edge runtime
+            process.env.NEXT_RUNTIME !== "edge") {
+                // We use dynamic require because this should only error in development
+                const { hasMatch } = require("./match-remote-pattern");
+                if (!hasMatch(config.domains, config.remotePatterns, parsedSrc)) {
+                    throw new Error("Invalid src prop (" + src + ') on `next/image`, hostname "' + parsedSrc.hostname + '" is not configured under images in your `next.config.js`\n' + "See more info: https://nextjs.org/docs/messages/next-image-unconfigured-host");
+                }
+            }
+        }
+    }
+    return config.path + "?url=" + encodeURIComponent(src) + "&w=" + width + "&q=" + (quality || 75) + (process.env.NEXT_DEPLOYMENT_ID ? "&dpl=" + process.env.NEXT_DEPLOYMENT_ID : "");
+}
+// We use this to determine if the import is the default loader
+// or a custom loader defined by the user in next.config.js
+defaultLoader.__next_img_default = true;
+const _default = defaultLoader;
+
+//# sourceMappingURL=image-loader.js.map

node_modules/next/dist/shared/lib/image-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/image-loader.ts"],"names":["defaultLoader","config","src","width","quality","process","env","NODE_ENV","missingValues","push","length","Error","join","JSON","stringify","startsWith","domains","remotePatterns","parsedSrc","URL","err","console","error","NEXT_RUNTIME","hasMatch","require","hostname","path","encodeURIComponent","NEXT_DEPLOYMENT_ID","__next_img_default"],"mappings":";;;;+BAwEA;;;eAAA;;;AAtEA,SAASA,cAAc,KAKM;IALN,IAAA,EACrBC,MAAM,EACNC,GAAG,EACHC,KAAK,EACLC,OAAO,EACoB,GALN;IAMrB,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,MAAMC,gBAAgB,EAAE;QAExB,yDAAyD;QACzD,IAAI,CAACN,KAAKM,cAAcC,IAAI,CAAC;QAC7B,IAAI,CAACN,OAAOK,cAAcC,IAAI,CAAC;QAE/B,IAAID,cAAcE,MAAM,GAAG,GAAG;YAC5B,MAAM,IAAIC,MACR,AAAC,sCAAmCH,cAAcI,IAAI,CACpD,QACA,gGAA+FC,KAAKC,SAAS,CAC7G;gBAAEZ;gBAAKC;gBAAOC;YAAQ;QAG5B;QAEA,IAAIF,IAAIa,UAAU,CAAC,OAAO;YACxB,MAAM,IAAIJ,MACR,AAAC,0BAAuBT,MAAI;QAEhC;QAEA,IAAI,CAACA,IAAIa,UAAU,CAAC,QAASd,CAAAA,OAAOe,OAAO,IAAIf,OAAOgB,cAAc,AAAD,GAAI;YACrE,IAAIC;YACJ,IAAI;gBACFA,YAAY,IAAIC,IAAIjB;YACtB,EAAE,OAAOkB,KAAK;gBACZC,QAAQC,KAAK,CAACF;gBACd,MAAM,IAAIT,MACR,AAAC,0BAAuBT,MAAI;YAEhC;YAEA,IACEG,QAAQC,GAAG,CAACC,QAAQ,KAAK,UACzB,gDAAgD;YAChDF,QAAQC,GAAG,CAACiB,YAAY,KAAK,QAC7B;gBACA,uEAAuE;gBACvE,MAAM,EAAEC,QAAQ,EAAE,GAAGC,QAAQ;gBAC7B,IAAI,CAACD,SAASvB,OAAOe,OAAO,EAAEf,OAAOgB,cAAc,EAAEC,YAAY;oBAC/D,MAAM,IAAIP,MACR,AAAC,uBAAoBT,MAAI,kCAAiCgB,UAAUQ,QAAQ,GAAC,gEAC1E;gBAEP;YACF;QACF;IACF;IAEA,OAAO,AAAGzB,OAAO0B,IAAI,GAAC,UAAOC,mBAAmB1B,OAAK,QAAKC,QAAM,QAC9DC,CAAAA,WAAW,EAAC,IAEZC,CAAAA,QAAQC,GAAG,CAACuB,kBAAkB,GAC1B,AAAC,UAAOxB,QAAQC,GAAG,CAACuB,kBAAkB,GACtC,EAAC;AAET;AAEA,+DAA+D;AAC/D,2DAA2D;AAC3D7B,cAAc8B,kBAAkB,GAAG;MAEnC,WAAe9B"}

node_modules/next/dist/shared/lib/is-plain-object.d.ts

@@ -0,0 +1,2 @@
+export declare function getObjectClassLabel(value: any): string;
+export declare function isPlainObject(value: any): boolean;

node_modules/next/dist/shared/lib/is-plain-object.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getObjectClassLabel: null,
+    isPlainObject: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getObjectClassLabel: function() {
+        return getObjectClassLabel;
+    },
+    isPlainObject: function() {
+        return isPlainObject;
+    }
+});
+function getObjectClassLabel(value) {
+    return Object.prototype.toString.call(value);
+}
+function isPlainObject(value) {
+    if (getObjectClassLabel(value) !== "[object Object]") {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    /**
+   * this used to be previously:
+   *
+   * `return prototype === null || prototype === Object.prototype`
+   *
+   * but Edge Runtime expose Object from vm, being that kind of type-checking wrongly fail.
+   *
+   * It was changed to the current implementation since it's resilient to serialization.
+   */ return prototype === null || prototype.hasOwnProperty("isPrototypeOf");
+}
+
+//# sourceMappingURL=is-plain-object.js.map

node_modules/next/dist/shared/lib/is-plain-object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/shared/lib/is-plain-object.ts"],"names":["getObjectClassLabel","isPlainObject","value","Object","prototype","toString","call","getPrototypeOf","hasOwnProperty"],"mappings":";;;;;;;;;;;;;;;IAAgBA,mBAAmB;eAAnBA;;IAIAC,aAAa;eAAbA;;;AAJT,SAASD,oBAAoBE,KAAU;IAC5C,OAAOC,OAAOC,SAAS,CAACC,QAAQ,CAACC,IAAI,CAACJ;AACxC;AAEO,SAASD,cAAcC,KAAU;IACtC,IAAIF,oBAAoBE,WAAW,mBAAmB;QACpD,OAAO;IACT;IAEA,MAAME,YAAYD,OAAOI,cAAc,CAACL;IAExC;;;;;;;;GAQC,GACD,OAAOE,cAAc,QAAQA,UAAUI,cAAc,CAAC;AACxD"}

node_modules/next/dist/shared/lib/isomorphic/path.d.ts

@@ -0,0 +1 @@
+export { default } from 'path'

node_modules/next/dist/shared/lib/isomorphic/path.js

@@ -0,0 +1,14 @@
+/**
+ * This module is for next.js server internal usage of path module.
+ * It will use native path module for nodejs runtime.
+ * It will use path-browserify polyfill for edge runtime.
+ */ "use strict";
+let path;
+if (process.env.NEXT_RUNTIME === "edge") {
+    path = require("next/dist/compiled/path-browserify");
+} else {
+    path = require("path");
+}
+module.exports = path;
+
+//# sourceMappingURL=path.js.map

node_modules/next/dist/shared/lib/isomorphic/path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/isomorphic/path.js"],"names":["path","process","env","NEXT_RUNTIME","require","module","exports"],"mappings":"AAAA;;;;CAIC;AACD,IAAIA;AAEJ,IAAIC,QAAQC,GAAG,CAACC,YAAY,KAAK,QAAQ;IACvCH,OAAOI,QAAQ;AACjB,OAAO;IACLJ,OAAOI,QAAQ;AACjB;AAEAC,OAAOC,OAAO,GAAGN"}

node_modules/next/dist/shared/lib/lazy-dynamic/bailout-to-csr.d.ts

@@ -0,0 +1,8 @@
+/** An error that should be thrown when we want to bail out to client-side rendering. */
+export declare class BailoutToCSRError extends Error {
+    readonly reason: string;
+    readonly digest = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+    constructor(reason: string);
+}
+/** Checks if a passed argument is an error that is thrown if we want to bail out to client-side rendering. */
+export declare function isBailoutToCSRError(err: unknown): err is BailoutToCSRError;

node_modules/next/dist/shared/lib/lazy-dynamic/bailout-to-csr.js

@@ -0,0 +1,39 @@
+// This has to be a shared module which is shared between client component error boundary and dynamic component
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    BailoutToCSRError: null,
+    isBailoutToCSRError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BailoutToCSRError: function() {
+        return BailoutToCSRError;
+    },
+    isBailoutToCSRError: function() {
+        return isBailoutToCSRError;
+    }
+});
+const BAILOUT_TO_CSR = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+class BailoutToCSRError extends Error {
+    constructor(reason){
+        super("Bail out to client-side rendering: " + reason);
+        this.reason = reason;
+        this.digest = BAILOUT_TO_CSR;
+    }
+}
+function isBailoutToCSRError(err) {
+    if (typeof err !== "object" || err === null || !("digest" in err)) {
+        return false;
+    }
+    return err.digest === BAILOUT_TO_CSR;
+}
+
+//# sourceMappingURL=bailout-to-csr.js.map

node_modules/next/dist/shared/lib/lazy-dynamic/bailout-to-csr.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/lazy-dynamic/bailout-to-csr.ts"],"names":["BailoutToCSRError","isBailoutToCSRError","BAILOUT_TO_CSR","Error","constructor","reason","digest","err"],"mappings":"AAAA,+GAA+G;;;;;;;;;;;;;;;;IAIlGA,iBAAiB;eAAjBA;;IASGC,mBAAmB;eAAnBA;;;AAZhB,MAAMC,iBAAiB;AAGhB,MAAMF,0BAA0BG;IAGrCC,YAAY,AAAgBC,MAAc,CAAE;QAC1C,KAAK,CAAC,AAAC,wCAAqCA;aADlBA,SAAAA;aAFZC,SAASJ;IAIzB;AACF;AAGO,SAASD,oBAAoBM,GAAY;IAC9C,IAAI,OAAOA,QAAQ,YAAYA,QAAQ,QAAQ,CAAE,CAAA,YAAYA,GAAE,GAAI;QACjE,OAAO;IACT;IAEA,OAAOA,IAAID,MAAM,KAAKJ;AACxB"}

node_modules/next/dist/shared/lib/lazy-dynamic/dynamic-bailout-to-csr.d.ts

@@ -0,0 +1,11 @@
+import type { ReactElement } from 'react';
+interface BailoutToCSRProps {
+    reason: string;
+    children: ReactElement;
+}
+/**
+ * If rendered on the server, this component throws an error
+ * to signal Next.js that it should bail out to client-side rendering instead.
+ */
+export declare function BailoutToCSR({ reason, children }: BailoutToCSRProps): ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+export {};

node_modules/next/dist/shared/lib/lazy-dynamic/dynamic-bailout-to-csr.js

@@ -0,0 +1,22 @@
+"use client";
+
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BailoutToCSR", {
+    enumerable: true,
+    get: function() {
+        return BailoutToCSR;
+    }
+});
+const _bailouttocsr = require("./bailout-to-csr");
+function BailoutToCSR(param) {
+    let { reason, children } = param;
+    if (typeof window === "undefined") {
+        throw new _bailouttocsr.BailoutToCSRError(reason);
+    }
+    return children;
+}
+
+//# sourceMappingURL=dynamic-bailout-to-csr.js.map