大活

art-agent/frontend/node_modules/next/dist/client/request/params.browser.d.ts

@@ -0,0 +1 @@
+export declare const createRenderParamsFromClient: typeof import("./params.browser.dev").createRenderParamsFromClient;

art-agent/frontend/node_modules/next/dist/client/request/params.browser.dev.d.ts

@@ -0,0 +1,2 @@
+import type { Params } from '../../server/request/params';
+export declare function createRenderParamsFromClient(clientParams: Params): Promise<Params>;

art-agent/frontend/node_modules/next/dist/client/request/params.browser.dev.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRenderParamsFromClient", {
+    enumerable: true,
+    get: function() {
+        return createRenderParamsFromClient;
+    }
+});
+const _reflect = require("../../server/web/spec-extension/adapters/reflect");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const CachedParams = new WeakMap();
+function makeDynamicallyTrackedExoticParamsWithDevWarnings(underlyingParams) {
+    const cachedParams = CachedParams.get(underlyingParams);
+    if (cachedParams) {
+        return cachedParams;
+    }
+    // We don't use makeResolvedReactPromise here because params
+    // supports copying with spread and we don't want to unnecessarily
+    // instrument the promise with spreadable properties of ReactPromise.
+    const promise = Promise.resolve(underlyingParams);
+    const proxiedProperties = new Set();
+    const unproxiedProperties = [];
+    Object.keys(underlyingParams).forEach((prop)=>{
+        if (_reflectutils.wellKnownProperties.has(prop)) {
+        // These properties cannot be shadowed because they need to be the
+        // true underlying value for Promises to work correctly at runtime
+        } else {
+            proxiedProperties.add(prop);
+            promise[prop] = underlyingParams[prop];
+        }
+    });
+    const proxiedPromise = new Proxy(promise, {
+        get (target, prop, receiver) {
+            if (typeof prop === 'string') {
+                if (// We are accessing a property that was proxied to the promise instance
+                proxiedProperties.has(prop)) {
+                    const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
+                    warnForSyncAccess(expression);
+                }
+            }
+            return _reflect.ReflectAdapter.get(target, prop, receiver);
+        },
+        set (target, prop, value, receiver) {
+            if (typeof prop === 'string') {
+                proxiedProperties.delete(prop);
+            }
+            return _reflect.ReflectAdapter.set(target, prop, value, receiver);
+        },
+        ownKeys (target) {
+            warnForEnumeration(unproxiedProperties);
+            return Reflect.ownKeys(target);
+        }
+    });
+    CachedParams.set(underlyingParams, proxiedPromise);
+    return proxiedPromise;
+}
+// Similar to `makeDynamicallyTrackedExoticParamsWithDevWarnings`, but just
+// logging the sync access without actually defining the params on the promise.
+function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams) {
+    const cachedParams = CachedParams.get(underlyingParams);
+    if (cachedParams) {
+        return cachedParams;
+    }
+    // We don't use makeResolvedReactPromise here because params
+    // supports copying with spread and we don't want to unnecessarily
+    // instrument the promise with spreadable properties of ReactPromise.
+    const promise = Promise.resolve(underlyingParams);
+    const proxiedProperties = new Set();
+    const unproxiedProperties = [];
+    Object.keys(underlyingParams).forEach((prop)=>{
+        if (_reflectutils.wellKnownProperties.has(prop)) {
+        // These properties cannot be shadowed because they need to be the
+        // true underlying value for Promises to work correctly at runtime
+        } else {
+            proxiedProperties.add(prop);
+        }
+    });
+    const proxiedPromise = new Proxy(promise, {
+        get (target, prop, receiver) {
+            if (typeof prop === 'string') {
+                if (// We are accessing a property that was proxied to the promise instance
+                proxiedProperties.has(prop)) {
+                    const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
+                    warnForSyncAccess(expression);
+                }
+            }
+            return _reflect.ReflectAdapter.get(target, prop, receiver);
+        },
+        set (target, prop, value, receiver) {
+            if (typeof prop === 'string') {
+                proxiedProperties.delete(prop);
+            }
+            return _reflect.ReflectAdapter.set(target, prop, value, receiver);
+        },
+        ownKeys (target) {
+            warnForEnumeration(unproxiedProperties);
+            return Reflect.ownKeys(target);
+        }
+    });
+    CachedParams.set(underlyingParams, proxiedPromise);
+    return proxiedPromise;
+}
+function warnForSyncAccess(expression) {
+    console.error("A param property was accessed directly with " + expression + ". `params` is now a Promise and should be unwrapped with `React.use()` before accessing properties of the underlying params object. In this version of Next.js direct access to param properties is still supported to facilitate migration but in a future version you will be required to unwrap `params` with `React.use()`.");
+}
+function warnForEnumeration(missingProperties) {
+    if (missingProperties.length) {
+        const describedMissingProperties = describeListOfPropertyNames(missingProperties);
+        console.error("params are being enumerated incompletely missing these properties: " + describedMissingProperties + ". " + "`params` should be unwrapped with `React.use()` before using its value. " + "Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis");
+    } else {
+        console.error("params are being enumerated. " + "`params` should be unwrapped with `React.use()` before using its value. " + "Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis");
+    }
+}
+function describeListOfPropertyNames(properties) {
+    switch(properties.length){
+        case 0:
+            throw Object.defineProperty(new _invarianterror.InvariantError('Expected describeListOfPropertyNames to be called with a non-empty list of strings.'), "__NEXT_ERROR_CODE", {
+                value: "E531",
+                enumerable: false,
+                configurable: true
+            });
+        case 1:
+            return "`" + properties[0] + "`";
+        case 2:
+            return "`" + properties[0] + "` and `" + properties[1] + "`";
+        default:
+            {
+                let description = '';
+                for(let i = 0; i < properties.length - 1; i++){
+                    description += "`" + properties[i] + "`, ";
+                }
+                description += ", and `" + properties[properties.length - 1] + "`";
+                return description;
+            }
+    }
+}
+function createRenderParamsFromClient(clientParams) {
+    if (process.env.__NEXT_CACHE_COMPONENTS) {
+        return makeDynamicallyTrackedParamsWithDevWarnings(clientParams);
+    }
+    return makeDynamicallyTrackedExoticParamsWithDevWarnings(clientParams);
+}
+
+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=params.browser.dev.js.map

art-agent/frontend/node_modules/next/dist/client/request/params.browser.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRenderParamsFromClient", {
+    enumerable: true,
+    get: function() {
+        return createRenderParamsFromClient;
+    }
+});
+const createRenderParamsFromClient = process.env.NODE_ENV === 'development' ? require('./params.browser.dev').createRenderParamsFromClient : require('./params.browser.prod').createRenderParamsFromClient;
+
+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=params.browser.js.map

art-agent/frontend/node_modules/next/dist/client/request/params.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/request/params.browser.ts"],"sourcesContent":["export const createRenderParamsFromClient =\n  process.env.NODE_ENV === 'development'\n    ? (require('./params.browser.dev') as typeof import('./params.browser.dev'))\n        .createRenderParamsFromClient\n    : (\n        require('./params.browser.prod') as typeof import('./params.browser.prod')\n      ).createRenderParamsFromClient\n"],"names":["createRenderParamsFromClient","process","env","NODE_ENV","require"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,+BACXC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBACrB,AAACC,QAAQ,wBACNJ,4BAA4B,GAC/B,AACEI,QAAQ,yBACRJ,4BAA4B","ignoreList":[0]}

art-agent/frontend/node_modules/next/dist/client/request/params.browser.prod.d.ts

@@ -0,0 +1,2 @@
+import type { Params } from '../../server/request/params';
+export declare function createRenderParamsFromClient(clientParams: Params): Promise<Params>;

art-agent/frontend/node_modules/next/dist/client/request/params.browser.prod.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRenderParamsFromClient", {
+    enumerable: true,
+    get: function() {
+        return createRenderParamsFromClient;
+    }
+});
+const _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const CachedParams = new WeakMap();
+function makeUntrackedExoticParams(underlyingParams) {
+    const cachedParams = CachedParams.get(underlyingParams);
+    if (cachedParams) {
+        return cachedParams;
+    }
+    const promise = Promise.resolve(underlyingParams);
+    CachedParams.set(underlyingParams, promise);
+    Object.keys(underlyingParams).forEach((prop)=>{
+        if (_reflectutils.wellKnownProperties.has(prop)) {
+        // These properties cannot be shadowed because they need to be the
+        // true underlying value for Promises to work correctly at runtime
+        } else {
+            ;
+            promise[prop] = underlyingParams[prop];
+        }
+    });
+    return promise;
+}
+function makeUntrackedParams(underlyingParams) {
+    const cachedParams = CachedParams.get(underlyingParams);
+    if (cachedParams) {
+        return cachedParams;
+    }
+    const promise = Promise.resolve(underlyingParams);
+    CachedParams.set(underlyingParams, promise);
+    return promise;
+}
+function createRenderParamsFromClient(clientParams) {
+    if (process.env.__NEXT_CACHE_COMPONENTS) {
+        return makeUntrackedParams(clientParams);
+    }
+    return makeUntrackedExoticParams(clientParams);
+}
+
+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=params.browser.prod.js.map

art-agent/frontend/node_modules/next/dist/client/request/params.browser.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/request/params.browser.prod.ts"],"sourcesContent":["import type { Params } from '../../server/request/params'\nimport { wellKnownProperties } from '../../shared/lib/utils/reflect-utils'\n\ninterface CacheLifetime {}\nconst CachedParams = new WeakMap<CacheLifetime, Promise<Params>>()\n\nfunction makeUntrackedExoticParams(underlyingParams: Params): Promise<Params> {\n  const cachedParams = CachedParams.get(underlyingParams)\n  if (cachedParams) {\n    return cachedParams\n  }\n\n  const promise = Promise.resolve(underlyingParams)\n  CachedParams.set(underlyingParams, promise)\n\n  Object.keys(underlyingParams).forEach((prop) => {\n    if (wellKnownProperties.has(prop)) {\n      // These properties cannot be shadowed because they need to be the\n      // true underlying value for Promises to work correctly at runtime\n    } else {\n      ;(promise as any)[prop] = underlyingParams[prop]\n    }\n  })\n\n  return promise\n}\n\nfunction makeUntrackedParams(underlyingParams: Params): Promise<Params> {\n  const cachedParams = CachedParams.get(underlyingParams)\n  if (cachedParams) {\n    return cachedParams\n  }\n\n  const promise = Promise.resolve(underlyingParams)\n  CachedParams.set(underlyingParams, promise)\n\n  return promise\n}\n\nexport function createRenderParamsFromClient(\n  clientParams: Params\n): Promise<Params> {\n  if (process.env.__NEXT_CACHE_COMPONENTS) {\n    return makeUntrackedParams(clientParams)\n  }\n\n  return makeUntrackedExoticParams(clientParams)\n}\n"],"names":["createRenderParamsFromClient","CachedParams","WeakMap","makeUntrackedExoticParams","underlyingParams","cachedParams","get","promise","Promise","resolve","set","Object","keys","forEach","prop","wellKnownProperties","has","makeUntrackedParams","clientParams","process","env","__NEXT_CACHE_COMPONENTS"],"mappings":";;;;+BAuCgBA;;;eAAAA;;;8BAtCoB;AAGpC,MAAMC,eAAe,IAAIC;AAEzB,SAASC,0BAA0BC,gBAAwB;IACzD,MAAMC,eAAeJ,aAAaK,GAAG,CAACF;IACtC,IAAIC,cAAc;QAChB,OAAOA;IACT;IAEA,MAAME,UAAUC,QAAQC,OAAO,CAACL;IAChCH,aAAaS,GAAG,CAACN,kBAAkBG;IAEnCI,OAAOC,IAAI,CAACR,kBAAkBS,OAAO,CAAC,CAACC;QACrC,IAAIC,iCAAmB,CAACC,GAAG,CAACF,OAAO;QACjC,kEAAkE;QAClE,kEAAkE;QACpE,OAAO;;YACHP,OAAe,CAACO,KAAK,GAAGV,gBAAgB,CAACU,KAAK;QAClD;IACF;IAEA,OAAOP;AACT;AAEA,SAASU,oBAAoBb,gBAAwB;IACnD,MAAMC,eAAeJ,aAAaK,GAAG,CAACF;IACtC,IAAIC,cAAc;QAChB,OAAOA;IACT;IAEA,MAAME,UAAUC,QAAQC,OAAO,CAACL;IAChCH,aAAaS,GAAG,CAACN,kBAAkBG;IAEnC,OAAOA;AACT;AAEO,SAASP,6BACdkB,YAAoB;IAEpB,IAAIC,QAAQC,GAAG,CAACC,uBAAuB,EAAE;QACvC,OAAOJ,oBAAoBC;IAC7B;IAEA,OAAOf,0BAA0Be;AACnC","ignoreList":[0]}

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.d.ts

@@ -0,0 +1 @@
+export declare const createRenderSearchParamsFromClient: typeof import("./search-params.browser.dev").createRenderSearchParamsFromClient;

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.dev.d.ts

@@ -0,0 +1,2 @@
+import type { SearchParams } from '../../server/request/search-params';
+export declare function createRenderSearchParamsFromClient(underlyingSearchParams: SearchParams): Promise<SearchParams>;

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.dev.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRenderSearchParamsFromClient", {
+    enumerable: true,
+    get: function() {
+        return createRenderSearchParamsFromClient;
+    }
+});
+const _reflect = require("../../server/web/spec-extension/adapters/reflect");
+const _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const CachedSearchParams = new WeakMap();
+function makeUntrackedExoticSearchParamsWithDevWarnings(underlyingSearchParams) {
+    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    const proxiedProperties = new Set();
+    const unproxiedProperties = [];
+    const promise = Promise.resolve(underlyingSearchParams);
+    Object.keys(underlyingSearchParams).forEach((prop)=>{
+        if (_reflectutils.wellKnownProperties.has(prop)) {
+            // These properties cannot be shadowed because they need to be the
+            // true underlying value for Promises to work correctly at runtime
+            unproxiedProperties.push(prop);
+        } else {
+            proxiedProperties.add(prop);
+            promise[prop] = underlyingSearchParams[prop];
+        }
+    });
+    const proxiedPromise = new Proxy(promise, {
+        get (target, prop, receiver) {
+            if (typeof prop === 'string') {
+                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
+                // the underlying searchParams.
+                Reflect.has(target, prop) === false)) {
+                    const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
+                    warnForSyncAccess(expression);
+                }
+            }
+            return _reflect.ReflectAdapter.get(target, prop, receiver);
+        },
+        set (target, prop, value, receiver) {
+            if (typeof prop === 'string') {
+                proxiedProperties.delete(prop);
+            }
+            return Reflect.set(target, prop, value, receiver);
+        },
+        has (target, prop) {
+            if (typeof prop === 'string') {
+                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
+                // the underlying searchParams.
+                Reflect.has(target, prop) === false)) {
+                    const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
+                    warnForSyncAccess(expression);
+                }
+            }
+            return Reflect.has(target, prop);
+        },
+        ownKeys (target) {
+            warnForSyncSpread();
+            return Reflect.ownKeys(target);
+        }
+    });
+    CachedSearchParams.set(underlyingSearchParams, proxiedPromise);
+    return proxiedPromise;
+}
+// Similar to `makeUntrackedExoticSearchParamsWithDevWarnings`, but just logging
+// the sync access without actually defining the search params on the promise.
+function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams) {
+    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    const proxiedProperties = new Set();
+    const unproxiedProperties = [];
+    const promise = Promise.resolve(underlyingSearchParams);
+    Object.keys(underlyingSearchParams).forEach((prop)=>{
+        if (_reflectutils.wellKnownProperties.has(prop)) {
+            // These properties cannot be shadowed because they need to be the
+            // true underlying value for Promises to work correctly at runtime
+            unproxiedProperties.push(prop);
+        } else {
+            proxiedProperties.add(prop);
+        }
+    });
+    const proxiedPromise = new Proxy(promise, {
+        get (target, prop, receiver) {
+            if (typeof prop === 'string') {
+                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
+                // the underlying searchParams.
+                Reflect.has(target, prop) === false)) {
+                    const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
+                    warnForSyncAccess(expression);
+                }
+            }
+            return _reflect.ReflectAdapter.get(target, prop, receiver);
+        },
+        set (target, prop, value, receiver) {
+            if (typeof prop === 'string') {
+                proxiedProperties.delete(prop);
+            }
+            return Reflect.set(target, prop, value, receiver);
+        },
+        has (target, prop) {
+            if (typeof prop === 'string') {
+                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
+                // the underlying searchParams.
+                Reflect.has(target, prop) === false)) {
+                    const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
+                    warnForSyncAccess(expression);
+                }
+            }
+            return Reflect.has(target, prop);
+        },
+        ownKeys (target) {
+            warnForSyncSpread();
+            return Reflect.ownKeys(target);
+        }
+    });
+    CachedSearchParams.set(underlyingSearchParams, proxiedPromise);
+    return proxiedPromise;
+}
+function warnForSyncAccess(expression) {
+    console.error("A searchParam property was accessed directly with " + expression + ". " + "`searchParams` should be unwrapped with `React.use()` before accessing its properties. " + "Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis");
+}
+function warnForSyncSpread() {
+    console.error("The keys of `searchParams` were accessed directly. " + "`searchParams` should be unwrapped with `React.use()` before accessing its properties. " + "Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis");
+}
+function createRenderSearchParamsFromClient(underlyingSearchParams) {
+    if (process.env.__NEXT_CACHE_COMPONENTS) {
+        return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams);
+    }
+    return makeUntrackedExoticSearchParamsWithDevWarnings(underlyingSearchParams);
+}
+
+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=search-params.browser.dev.js.map

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRenderSearchParamsFromClient", {
+    enumerable: true,
+    get: function() {
+        return createRenderSearchParamsFromClient;
+    }
+});
+const createRenderSearchParamsFromClient = process.env.NODE_ENV === 'development' ? require('./search-params.browser.dev').createRenderSearchParamsFromClient : require('./search-params.browser.prod').createRenderSearchParamsFromClient;
+
+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=search-params.browser.js.map

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/request/search-params.browser.ts"],"sourcesContent":["export const createRenderSearchParamsFromClient =\n  process.env.NODE_ENV === 'development'\n    ? (\n        require('./search-params.browser.dev') as typeof import('./search-params.browser.dev')\n      ).createRenderSearchParamsFromClient\n    : (\n        require('./search-params.browser.prod') as typeof import('./search-params.browser.prod')\n      ).createRenderSearchParamsFromClient\n"],"names":["createRenderSearchParamsFromClient","process","env","NODE_ENV","require"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,qCACXC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBACrB,AACEC,QAAQ,+BACRJ,kCAAkC,GACpC,AACEI,QAAQ,gCACRJ,kCAAkC","ignoreList":[0]}

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.prod.d.ts

@@ -0,0 +1,2 @@
+import type { SearchParams } from '../../server/request/search-params';
+export declare function createRenderSearchParamsFromClient(underlyingSearchParams: SearchParams): Promise<SearchParams>;

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.prod.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRenderSearchParamsFromClient", {
+    enumerable: true,
+    get: function() {
+        return createRenderSearchParamsFromClient;
+    }
+});
+const _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const CachedSearchParams = new WeakMap();
+function makeUntrackedExoticSearchParams(underlyingSearchParams) {
+    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    // We don't use makeResolvedReactPromise here because searchParams
+    // supports copying with spread and we don't want to unnecessarily
+    // instrument the promise with spreadable properties of ReactPromise.
+    const promise = Promise.resolve(underlyingSearchParams);
+    CachedSearchParams.set(underlyingSearchParams, promise);
+    Object.keys(underlyingSearchParams).forEach((prop)=>{
+        if (_reflectutils.wellKnownProperties.has(prop)) {
+        // These properties cannot be shadowed because they need to be the
+        // true underlying value for Promises to work correctly at runtime
+        } else {
+            ;
+            promise[prop] = underlyingSearchParams[prop];
+        }
+    });
+    return promise;
+}
+function makeUntrackedSearchParams(underlyingSearchParams) {
+    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    const promise = Promise.resolve(underlyingSearchParams);
+    CachedSearchParams.set(underlyingSearchParams, promise);
+    return promise;
+}
+function createRenderSearchParamsFromClient(underlyingSearchParams) {
+    if (process.env.__NEXT_CACHE_COMPONENTS) {
+        return makeUntrackedSearchParams(underlyingSearchParams);
+    }
+    return makeUntrackedExoticSearchParams(underlyingSearchParams);
+}
+
+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=search-params.browser.prod.js.map

art-agent/frontend/node_modules/next/dist/client/request/search-params.browser.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/request/search-params.browser.prod.ts"],"sourcesContent":["import type { SearchParams } from '../../server/request/search-params'\n\nimport { wellKnownProperties } from '../../shared/lib/utils/reflect-utils'\n\ninterface CacheLifetime {}\nconst CachedSearchParams = new WeakMap<CacheLifetime, Promise<SearchParams>>()\n\nfunction makeUntrackedExoticSearchParams(\n  underlyingSearchParams: SearchParams\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  // We don't use makeResolvedReactPromise here because searchParams\n  // supports copying with spread and we don't want to unnecessarily\n  // instrument the promise with spreadable properties of ReactPromise.\n  const promise = Promise.resolve(underlyingSearchParams)\n  CachedSearchParams.set(underlyingSearchParams, promise)\n\n  Object.keys(underlyingSearchParams).forEach((prop) => {\n    if (wellKnownProperties.has(prop)) {\n      // These properties cannot be shadowed because they need to be the\n      // true underlying value for Promises to work correctly at runtime\n    } else {\n      ;(promise as any)[prop] = underlyingSearchParams[prop]\n    }\n  })\n\n  return promise\n}\n\nfunction makeUntrackedSearchParams(\n  underlyingSearchParams: SearchParams\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const promise = Promise.resolve(underlyingSearchParams)\n  CachedSearchParams.set(underlyingSearchParams, promise)\n\n  return promise\n}\n\nexport function createRenderSearchParamsFromClient(\n  underlyingSearchParams: SearchParams\n): Promise<SearchParams> {\n  if (process.env.__NEXT_CACHE_COMPONENTS) {\n    return makeUntrackedSearchParams(underlyingSearchParams)\n  }\n\n  return makeUntrackedExoticSearchParams(underlyingSearchParams)\n}\n"],"names":["createRenderSearchParamsFromClient","CachedSearchParams","WeakMap","makeUntrackedExoticSearchParams","underlyingSearchParams","cachedSearchParams","get","promise","Promise","resolve","set","Object","keys","forEach","prop","wellKnownProperties","has","makeUntrackedSearchParams","process","env","__NEXT_CACHE_COMPONENTS"],"mappings":";;;;+BA+CgBA;;;eAAAA;;;8BA7CoB;AAGpC,MAAMC,qBAAqB,IAAIC;AAE/B,SAASC,gCACPC,sBAAoC;IAEpC,MAAMC,qBAAqBJ,mBAAmBK,GAAG,CAACF;IAClD,IAAIC,oBAAoB;QACtB,OAAOA;IACT;IAEA,kEAAkE;IAClE,kEAAkE;IAClE,qEAAqE;IACrE,MAAME,UAAUC,QAAQC,OAAO,CAACL;IAChCH,mBAAmBS,GAAG,CAACN,wBAAwBG;IAE/CI,OAAOC,IAAI,CAACR,wBAAwBS,OAAO,CAAC,CAACC;QAC3C,IAAIC,iCAAmB,CAACC,GAAG,CAACF,OAAO;QACjC,kEAAkE;QAClE,kEAAkE;QACpE,OAAO;;YACHP,OAAe,CAACO,KAAK,GAAGV,sBAAsB,CAACU,KAAK;QACxD;IACF;IAEA,OAAOP;AACT;AAEA,SAASU,0BACPb,sBAAoC;IAEpC,MAAMC,qBAAqBJ,mBAAmBK,GAAG,CAACF;IAClD,IAAIC,oBAAoB;QACtB,OAAOA;IACT;IAEA,MAAME,UAAUC,QAAQC,OAAO,CAACL;IAChCH,mBAAmBS,GAAG,CAACN,wBAAwBG;IAE/C,OAAOA;AACT;AAEO,SAASP,mCACdI,sBAAoC;IAEpC,IAAIc,QAAQC,GAAG,CAACC,uBAAuB,EAAE;QACvC,OAAOH,0BAA0Bb;IACnC;IAEA,OAAOD,gCAAgCC;AACzC","ignoreList":[0]}