kindflow 0.1.0

package/web/standalone/apps/web/node_modules/next/dist/client/navigation-build-id.js

@@ -0,0 +1,53 @@
+// This gets assigned as a side-effect during app initialization. Because it
+// represents the build used to create the JS bundle, it should never change
+// after being set, so we store it in a global variable.
+//
+// When performing RSC requests, if the incoming data has a different build ID,
+// we perform an MPA navigation/refresh to load the updated build and ensure
+// that the client and server in sync.
+//
+// Starts as an empty string. In practice, because setNavigationBuildId is called during initialization
+// before hydration starts, this will always get reassigned to the actual ID before it's ever needed
+// by a navigation. If for some reasons it didn't, due to a bug or race condition, then on
+// navigation the build comparision would fail and trigger an MPA navigation.
+//
+// Note that this can also be initialized with the deployment id instead (if available). So it's not
+// the same as "the build id", but we are running out of alternative names for "build id or
+// deployment id".
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getNavigationBuildId: null,
+    setNavigationBuildId: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getNavigationBuildId: function() {
+        return getNavigationBuildId;
+    },
+    setNavigationBuildId: function() {
+        return setNavigationBuildId;
+    }
+});
+let globalBuildId = '';
+function setNavigationBuildId(buildId) {
+    globalBuildId = buildId;
+}
+function getNavigationBuildId() {
+    return globalBuildId;
+}
+
+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=navigation-build-id.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/normalize-trailing-slash.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizePathTrailingSlash", {
+    enumerable: true,
+    get: function() {
+        return normalizePathTrailingSlash;
+    }
+});
+const _removetrailingslash = require("../shared/lib/router/utils/remove-trailing-slash");
+const _parsepath = require("../shared/lib/router/utils/parse-path");
+const normalizePathTrailingSlash = (path)=>{
+    if (!path.startsWith('/') || process.env.__NEXT_MANUAL_TRAILING_SLASH) {
+        return path;
+    }
+    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+    if (process.env.__NEXT_TRAILING_SLASH) {
+        if (/\.[^/]+\/?$/.test(pathname)) {
+            return `${(0, _removetrailingslash.removeTrailingSlash)(pathname)}${query}${hash}`;
+        } else if (pathname.endsWith('/')) {
+            return `${pathname}${query}${hash}`;
+        } else {
+            return `${pathname}/${query}${hash}`;
+        }
+    }
+    return `${(0, _removetrailingslash.removeTrailingSlash)(pathname)}${query}${hash}`;
+};
+
+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=normalize-trailing-slash.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/remove-base-path.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeBasePath", {
+    enumerable: true,
+    get: function() {
+        return removeBasePath;
+    }
+});
+const _hasbasepath = require("./has-base-path");
+const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+function removeBasePath(path) {
+    if (process.env.__NEXT_MANUAL_CLIENT_BASE_PATH) {
+        if (!(0, _hasbasepath.hasBasePath)(path)) {
+            return path;
+        }
+    }
+    // Can't trim the basePath if it has zero length!
+    if (basePath.length === 0) return path;
+    path = path.slice(basePath.length);
+    if (!path.startsWith('/')) path = `/${path}`;
+    return path;
+}
+
+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=remove-base-path.js.map

package/web/standalone/apps/web/node_modules/next/dist/client/route-params.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    doesStaticSegmentAppearInURL: null,
+    getCacheKeyForDynamicParam: null,
+    getParamValueFromCacheKey: null,
+    getRenderedPathname: null,
+    getRenderedSearch: null,
+    parseDynamicParamFromURLPart: null,
+    urlSearchParamsToParsedUrlQuery: null,
+    urlToUrlWithoutFlightMarker: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    doesStaticSegmentAppearInURL: function() {
+        return doesStaticSegmentAppearInURL;
+    },
+    getCacheKeyForDynamicParam: function() {
+        return getCacheKeyForDynamicParam;
+    },
+    getParamValueFromCacheKey: function() {
+        return getParamValueFromCacheKey;
+    },
+    getRenderedPathname: function() {
+        return getRenderedPathname;
+    },
+    getRenderedSearch: function() {
+        return getRenderedSearch;
+    },
+    parseDynamicParamFromURLPart: function() {
+        return parseDynamicParamFromURLPart;
+    },
+    urlSearchParamsToParsedUrlQuery: function() {
+        return urlSearchParamsToParsedUrlQuery;
+    },
+    urlToUrlWithoutFlightMarker: function() {
+        return urlToUrlWithoutFlightMarker;
+    }
+});
+const _segment = require("../shared/lib/segment");
+const _segmentvalueencoding = require("../shared/lib/segment-cache/segment-value-encoding");
+const _approuterheaders = require("./components/app-router-headers");
+function getRenderedSearch(response) {
+    // If the server performed a rewrite, the search params used to render the
+    // page will be different from the params in the request URL. In this case,
+    // the response will include a header that gives the rewritten search query.
+    const rewrittenQuery = response.headers.get(_approuterheaders.NEXT_REWRITTEN_QUERY_HEADER);
+    if (rewrittenQuery !== null) {
+        return rewrittenQuery === '' ? '' : '?' + rewrittenQuery;
+    }
+    // If the header is not present, there was no rewrite, so we use the search
+    // query of the response URL.
+    return urlToUrlWithoutFlightMarker(new URL(response.url)).search;
+}
+function getRenderedPathname(response) {
+    // If the server performed a rewrite, the pathname used to render the
+    // page will be different from the pathname in the request URL. In this case,
+    // the response will include a header that gives the rewritten pathname.
+    const rewrittenPath = response.headers.get(_approuterheaders.NEXT_REWRITTEN_PATH_HEADER);
+    return rewrittenPath ?? urlToUrlWithoutFlightMarker(new URL(response.url)).pathname;
+}
+function parseDynamicParamFromURLPart(paramType, pathnameParts, partIndex) {
+    // This needs to match the behavior in get-dynamic-param.ts.
+    switch(paramType){
+        // Catchalls
+        case 'c':
+            {
+                // Catchalls receive all the remaining URL parts. If there are no
+                // remaining pathname parts, return an empty array.
+                return partIndex < pathnameParts.length ? pathnameParts.slice(partIndex).map((s)=>encodeURIComponent(s)) : [];
+            }
+        // Catchall intercepted
+        case 'ci(..)(..)':
+        case 'ci(.)':
+        case 'ci(..)':
+        case 'ci(...)':
+            {
+                const prefix = paramType.length - 2;
+                return partIndex < pathnameParts.length ? pathnameParts.slice(partIndex).map((s, i)=>{
+                    if (i === 0) {
+                        return encodeURIComponent(s.slice(prefix));
+                    }
+                    return encodeURIComponent(s);
+                }) : [];
+            }
+        // Optional catchalls
+        case 'oc':
+            {
+                // Optional catchalls receive all the remaining URL parts, unless this is
+                // the end of the pathname, in which case they return null.
+                return partIndex < pathnameParts.length ? pathnameParts.slice(partIndex).map((s)=>encodeURIComponent(s)) : null;
+            }
+        // Dynamic
+        case 'd':
+            {
+                if (partIndex >= pathnameParts.length) {
+                    // The route tree expected there to be more parts in the URL than there
+                    // actually are. This could happen if the x-nextjs-rewritten-path header
+                    // is incorrectly set, or potentially due to bug in Next.js. TODO:
+                    // Should this be a hard error? During a prefetch, we can just abort.
+                    // During a client navigation, we could trigger a hard refresh. But if
+                    // it happens during initial render, we don't really have any
+                    // recovery options.
+                    return '';
+                }
+                return encodeURIComponent(pathnameParts[partIndex]);
+            }
+        // Dynamic intercepted
+        case 'di(..)(..)':
+        case 'di(.)':
+        case 'di(..)':
+        case 'di(...)':
+            {
+                const prefix = paramType.length - 2;
+                if (partIndex >= pathnameParts.length) {
+                    // The route tree expected there to be more parts in the URL than there
+                    // actually are. This could happen if the x-nextjs-rewritten-path header
+                    // is incorrectly set, or potentially due to bug in Next.js. TODO:
+                    // Should this be a hard error? During a prefetch, we can just abort.
+                    // During a client navigation, we could trigger a hard refresh. But if
+                    // it happens during initial render, we don't really have any
+                    // recovery options.
+                    return '';
+                }
+                return encodeURIComponent(pathnameParts[partIndex].slice(prefix));
+            }
+        default:
+            paramType;
+            return '';
+    }
+}
+function doesStaticSegmentAppearInURL(segment) {
+    // This is not a parameterized segment; however, we need to determine
+    // whether or not this segment appears in the URL. For example, this route
+    // groups do not appear in the URL, so they should be skipped. Any other
+    // special cases must be handled here.
+    // TODO: Consider encoding this directly into the router tree instead of
+    // inferring it on the client based on the segment type. Something like
+    // a `doesAppearInURL` flag in FlightRouterState.
+    if (segment === _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY || // For some reason, the loader tree sometimes includes extra __PAGE__
+    // "layouts" when part of a parallel route. But it's not a leaf node.
+    // Otherwise, we wouldn't need this special case because pages are
+    // always leaf nodes.
+    // TODO: Investigate why the loader produces these fake page segments.
+    segment.startsWith(_segment.PAGE_SEGMENT_KEY) || // Route groups.
+    segment[0] === '(' && segment.endsWith(')') || segment === _segment.DEFAULT_SEGMENT_KEY || segment === '/_not-found') {
+        return false;
+    } else {
+        // All other segment types appear in the URL
+        return true;
+    }
+}
+function getCacheKeyForDynamicParam(paramValue, renderedSearch) {
+    // This needs to match the logic in get-dynamic-param.ts, until we're able to
+    // unify the various implementations so that these are always computed on
+    // the client.
+    if (typeof paramValue === 'string') {
+        // TODO: Refactor or remove this helper function to accept a string rather
+        // than the whole segment type. Also we can probably just append the
+        // search string instead of turning it into JSON.
+        const pageSegmentWithSearchParams = (0, _segment.addSearchParamsIfPageSegment)(paramValue, Object.fromEntries(new URLSearchParams(renderedSearch)));
+        return pageSegmentWithSearchParams;
+    } else if (paramValue === null) {
+        return '';
+    } else {
+        return paramValue.join('/');
+    }
+}
+function urlToUrlWithoutFlightMarker(url) {
+    const urlWithoutFlightParameters = new URL(url);
+    urlWithoutFlightParameters.searchParams.delete(_approuterheaders.NEXT_RSC_UNION_QUERY);
+    if (process.env.NODE_ENV === 'production') {
+        if (process.env.__NEXT_CONFIG_OUTPUT === 'export' && urlWithoutFlightParameters.pathname.endsWith('.txt')) {
+            const { pathname } = urlWithoutFlightParameters;
+            const length = pathname.endsWith('/index.txt') ? 10 : 4;
+            // Slice off `/index.txt` or `.txt` from the end of the pathname
+            urlWithoutFlightParameters.pathname = pathname.slice(0, -length);
+        }
+    }
+    return urlWithoutFlightParameters;
+}
+function getParamValueFromCacheKey(paramCacheKey, paramType) {
+    // Turn the cache key string sent by the server (as part of FlightRouterState)
+    // into a value that can be passed to `useParams` and client components.
+    const isCatchAll = paramType === 'c' || paramType === 'oc';
+    if (isCatchAll) {
+        // Catch-all param keys are a concatenation of the path segments.
+        // See equivalent logic in `getSelectedParams`.
+        // TODO: We should just pass the array directly, rather than concatenate
+        // it to a string and then split it back to an array. It needs to be an
+        // array in some places, like when passing a key React, but we can convert
+        // it at runtime in those places.
+        return paramCacheKey.split('/');
+    }
+    return paramCacheKey;
+}
+function urlSearchParamsToParsedUrlQuery(searchParams) {
+    // Converts a URLSearchParams object to the same type used by the server when
+    // creating search params props, i.e. the type returned by Node's
+    // "querystring" module.
+    const result = {};
+    for (const [key, value] of searchParams.entries()){
+        if (result[key] === undefined) {
+            result[key] = value;
+        } else if (Array.isArray(result[key])) {
+            result[key].push(value);
+        } else {
+            result[key] = [
+                result[key],
+                value
+            ];
+        }
+    }
+    return result;
+}
+
+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=route-params.js.map

package/web/standalone/apps/web/node_modules/next/dist/compiled/@edge-runtime/cookies/index.js

@@ -0,0 +1,339 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RequestCookies: () => RequestCookies,
+  ResponseCookies: () => ResponseCookies,
+  parseCookie: () => parseCookie,
+  parseSetCookie: () => parseSetCookie,
+  stringifyCookie: () => stringifyCookie
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/serialize.ts
+function stringifyCookie(c) {
+  var _a;
+  const attrs = [
+    "path" in c && c.path && `Path=${c.path}`,
+    "expires" in c && (c.expires || c.expires === 0) && `Expires=${(typeof c.expires === "number" ? new Date(c.expires) : c.expires).toUTCString()}`,
+    "maxAge" in c && typeof c.maxAge === "number" && `Max-Age=${c.maxAge}`,
+    "domain" in c && c.domain && `Domain=${c.domain}`,
+    "secure" in c && c.secure && "Secure",
+    "httpOnly" in c && c.httpOnly && "HttpOnly",
+    "sameSite" in c && c.sameSite && `SameSite=${c.sameSite}`,
+    "partitioned" in c && c.partitioned && "Partitioned",
+    "priority" in c && c.priority && `Priority=${c.priority}`
+  ].filter(Boolean);
+  const stringified = `${c.name}=${encodeURIComponent((_a = c.value) != null ? _a : "")}`;
+  return attrs.length === 0 ? stringified : `${stringified}; ${attrs.join("; ")}`;
+}
+function parseCookie(cookie) {
+  const map = /* @__PURE__ */ new Map();
+  for (const pair of cookie.split(/; */)) {
+    if (!pair)
+      continue;
+    const splitAt = pair.indexOf("=");
+    if (splitAt === -1) {
+      map.set(pair, "true");
+      continue;
+    }
+    const [key, value] = [pair.slice(0, splitAt), pair.slice(splitAt + 1)];
+    try {
+      map.set(key, decodeURIComponent(value != null ? value : "true"));
+    } catch {
+    }
+  }
+  return map;
+}
+function parseSetCookie(setCookie) {
+  if (!setCookie) {
+    return void 0;
+  }
+  const [[name, value], ...attributes] = parseCookie(setCookie);
+  const {
+    domain,
+    expires,
+    httponly,
+    maxage,
+    path,
+    samesite,
+    secure,
+    partitioned,
+    priority
+  } = Object.fromEntries(
+    attributes.map(([key, value2]) => [
+      key.toLowerCase().replace(/-/g, ""),
+      value2
+    ])
+  );
+  const cookie = {
+    name,
+    value: decodeURIComponent(value),
+    domain,
+    ...expires && { expires: new Date(expires) },
+    ...httponly && { httpOnly: true },
+    ...typeof maxage === "string" && { maxAge: Number(maxage) },
+    path,
+    ...samesite && { sameSite: parseSameSite(samesite) },
+    ...secure && { secure: true },
+    ...priority && { priority: parsePriority(priority) },
+    ...partitioned && { partitioned: true }
+  };
+  return compact(cookie);
+}
+function compact(t) {
+  const newT = {};
+  for (const key in t) {
+    if (t[key]) {
+      newT[key] = t[key];
+    }
+  }
+  return newT;
+}
+var SAME_SITE = ["strict", "lax", "none"];
+function parseSameSite(string) {
+  string = string.toLowerCase();
+  return SAME_SITE.includes(string) ? string : void 0;
+}
+var PRIORITY = ["low", "medium", "high"];
+function parsePriority(string) {
+  string = string.toLowerCase();
+  return PRIORITY.includes(string) ? string : void 0;
+}
+function splitCookiesString(cookiesString) {
+  if (!cookiesString)
+    return [];
+  var cookiesStrings = [];
+  var pos = 0;
+  var start;
+  var ch;
+  var lastComma;
+  var nextStart;
+  var cookiesSeparatorFound;
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+
+// src/request-cookies.ts
+var RequestCookies = class {
+  constructor(requestHeaders) {
+    /** @internal */
+    this._parsed = /* @__PURE__ */ new Map();
+    this._headers = requestHeaders;
+    const header = requestHeaders.get("cookie");
+    if (header) {
+      const parsed = parseCookie(header);
+      for (const [name, value] of parsed) {
+        this._parsed.set(name, { name, value });
+      }
+    }
+  }
+  [Symbol.iterator]() {
+    return this._parsed[Symbol.iterator]();
+  }
+  /**
+   * The amount of cookies received from the client
+   */
+  get size() {
+    return this._parsed.size;
+  }
+  get(...args) {
+    const name = typeof args[0] === "string" ? args[0] : args[0].name;
+    return this._parsed.get(name);
+  }
+  getAll(...args) {
+    var _a;
+    const all = Array.from(this._parsed);
+    if (!args.length) {
+      return all.map(([_, value]) => value);
+    }
+    const name = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+    return all.filter(([n]) => n === name).map(([_, value]) => value);
+  }
+  has(name) {
+    return this._parsed.has(name);
+  }
+  set(...args) {
+    const [name, value] = args.length === 1 ? [args[0].name, args[0].value] : args;
+    const map = this._parsed;
+    map.set(name, { name, value });
+    this._headers.set(
+      "cookie",
+      Array.from(map).map(([_, value2]) => stringifyCookie(value2)).join("; ")
+    );
+    return this;
+  }
+  /**
+   * Delete the cookies matching the passed name or names in the request.
+   */
+  delete(names) {
+    const map = this._parsed;
+    const result = !Array.isArray(names) ? map.delete(names) : names.map((name) => map.delete(name));
+    this._headers.set(
+      "cookie",
+      Array.from(map).map(([_, value]) => stringifyCookie(value)).join("; ")
+    );
+    return result;
+  }
+  /**
+   * Delete all the cookies in the cookies in the request.
+   */
+  clear() {
+    this.delete(Array.from(this._parsed.keys()));
+    return this;
+  }
+  /**
+   * Format the cookies in the request as a string for logging
+   */
+  [Symbol.for("edge-runtime.inspect.custom")]() {
+    return `RequestCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+  }
+  toString() {
+    return [...this._parsed.values()].map((v) => `${v.name}=${encodeURIComponent(v.value)}`).join("; ");
+  }
+};
+
+// src/response-cookies.ts
+var ResponseCookies = class {
+  constructor(responseHeaders) {
+    /** @internal */
+    this._parsed = /* @__PURE__ */ new Map();
+    var _a, _b, _c;
+    this._headers = responseHeaders;
+    const setCookie = (_c = (_b = (_a = responseHeaders.getSetCookie) == null ? void 0 : _a.call(responseHeaders)) != null ? _b : responseHeaders.get("set-cookie")) != null ? _c : [];
+    const cookieStrings = Array.isArray(setCookie) ? setCookie : splitCookiesString(setCookie);
+    for (const cookieString of cookieStrings) {
+      const parsed = parseSetCookie(cookieString);
+      if (parsed)
+        this._parsed.set(parsed.name, parsed);
+    }
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+   */
+  get(...args) {
+    const key = typeof args[0] === "string" ? args[0] : args[0].name;
+    return this._parsed.get(key);
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+   */
+  getAll(...args) {
+    var _a;
+    const all = Array.from(this._parsed.values());
+    if (!args.length) {
+      return all;
+    }
+    const key = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+    return all.filter((c) => c.name === key);
+  }
+  has(name) {
+    return this._parsed.has(name);
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+   */
+  set(...args) {
+    const [name, value, cookie] = args.length === 1 ? [args[0].name, args[0].value, args[0]] : args;
+    const map = this._parsed;
+    map.set(name, normalizeCookie({ name, value, ...cookie }));
+    replace(map, this._headers);
+    return this;
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+   */
+  delete(...args) {
+    const [name, options] = typeof args[0] === "string" ? [args[0]] : [args[0].name, args[0]];
+    return this.set({ ...options, name, value: "", expires: /* @__PURE__ */ new Date(0) });
+  }
+  [Symbol.for("edge-runtime.inspect.custom")]() {
+    return `ResponseCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+  }
+  toString() {
+    return [...this._parsed.values()].map(stringifyCookie).join("; ");
+  }
+};
+function replace(bag, headers) {
+  headers.delete("set-cookie");
+  for (const [, value] of bag) {
+    const serialized = stringifyCookie(value);
+    headers.append("set-cookie", serialized);
+  }
+}
+function normalizeCookie(cookie = { name: "", value: "" }) {
+  if (typeof cookie.expires === "number") {
+    cookie.expires = new Date(cookie.expires);
+  }
+  if (cookie.maxAge) {
+    cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
+  }
+  if (cookie.path === null || cookie.path === void 0) {
+    cookie.path = "/";
+  }
+  return cookie;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestCookies,
+  ResponseCookies,
+  parseCookie,
+  parseSetCookie,
+  stringifyCookie
+});

package/web/standalone/apps/web/node_modules/next/dist/compiled/@edge-runtime/cookies/package.json

@@ -0,0 +1 @@
+{"name":"@edge-runtime/cookies","version":"6.0.0","main":"./index.js","license":"MIT"}