@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-rt9qq1va.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/dist/server/_chunks/index-rthrsed5.js

@@ -0,0 +1,356 @@
+// @bun
+// src/compat/next/image/props.ts
+var DEFAULT_IMAGES_CONFIG = {
+  deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  imageSizes: [32, 48, 64, 96, 128, 256, 384],
+  allSizes: [32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  qualities: [75],
+  formats: ["image/webp"],
+  path: "/_next/image",
+  loader: "default",
+  loaderFile: "",
+  domains: [],
+  disableStaticImages: false,
+  minimumCacheTTL: 14400,
+  maximumRedirects: 3,
+  maximumResponseBody: 50000000,
+  dangerouslyAllowLocalIP: false,
+  dangerouslyAllowSVG: false,
+  contentSecurityPolicy: `script-src 'none'; frame-src 'none'; sandbox;`,
+  contentDispositionType: "attachment",
+  localPatterns: undefined,
+  remotePatterns: [],
+  unoptimized: false,
+  customCacheHandler: false
+};
+var INVALID_BACKGROUND_SIZE = new Set([
+  "-moz-initial",
+  "fill",
+  "none",
+  "scale-down",
+  undefined
+]);
+function unwrapStaticImport(src) {
+  return "default" in src ? src.default : src;
+}
+function toNumber(value) {
+  if (value === undefined)
+    return;
+  if (typeof value === "number")
+    return value;
+  const n = parseInt(value, 10);
+  return Number.isNaN(n) ? undefined : n;
+}
+function getImagesConfig() {
+  return typeof __PNEXT_IMAGE_CONFIG_INLINED__ === "boolean" ? __PNEXT_IMAGE_CONFIG_INLINE__ : globalThis.__PNEXT_IMAGE_CONFIG__ ?? DEFAULT_IMAGES_CONFIG;
+}
+function defaultLoader(config, src, width, quality) {
+  const q = findClosestQuality(config, quality);
+  return `${config.path}?url=${encodeURIComponent(src)}&w=${width}&q=${q}`;
+}
+function findClosestQuality(config, quality) {
+  const qualities = config.qualities;
+  if (!qualities || qualities.length === 0)
+    return quality ?? 75;
+  if (quality === undefined)
+    return closest(qualities, 75);
+  return closest(qualities, quality);
+}
+function closest(values, target) {
+  let best = values[0];
+  let bestDelta = Math.abs(best - target);
+  for (const value of values) {
+    const delta = Math.abs(value - target);
+    if (delta < bestDelta) {
+      best = value;
+      bestDelta = delta;
+    }
+  }
+  return best;
+}
+function getWidths(config, width, sizes) {
+  const { deviceSizes, allSizes } = config;
+  if (sizes) {
+    const viewportWidthRe = /(^|\s)(1?\d?\d)vw/g;
+    const percentSizes = [];
+    for (let match;match = viewportWidthRe.exec(sizes); ) {
+      percentSizes.push(parseInt(match[2], 10));
+    }
+    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([width, width * 2].map((w) => allSizes.find((p) => p >= w) || allSizes[allSizes.length - 1]))
+  ];
+  return { widths, kind: "x" };
+}
+function generateImgAttrs(params) {
+  const { config, src, unoptimized, width, quality, sizes, loader } = params;
+  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(", "),
+    src: loader({ config, src, quality, width: widths[last] })
+  };
+}
+function getImageBlurSvg(params) {
+  const { widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit } = params;
+  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`;
+}
+function getImageProps(imageProps) {
+  const resolved = resolveImageProps(imageProps, getImagesConfig());
+  return { props: resolved.props };
+}
+function unstable_getImgProps(imageProps) {
+  return getImageProps(imageProps);
+}
+function resolveImageProps(imageProps, config, blurComplete = false, showAltText = false) {
+  const {
+    src: rawSrc,
+    alt = "",
+    width: widthProp,
+    height: heightProp,
+    fill: fillProp = false,
+    loader,
+    quality: qualityProp,
+    priority = false,
+    preload = false,
+    loading,
+    placeholder = "empty",
+    blurDataURL: blurDataURLProp,
+    unoptimized: unoptimizedProp,
+    overrideSrc,
+    sizes: sizesProp,
+    fetchPriority,
+    decoding = "async",
+    style: styleProp,
+    layout,
+    objectFit,
+    objectPosition,
+    onLoad: _onLoad,
+    onError: _onError,
+    onLoadingComplete: _onLoadingComplete,
+    ...rest
+  } = imageProps;
+  let fill = fillProp;
+  let sizes = sizesProp;
+  let userStyle = normalizeStyle(styleProp);
+  if (layout) {
+    if (layout === "fill")
+      fill = true;
+    const layoutStyle = layout === "intrinsic" ? { maxWidth: "100%", height: "auto" } : layout === "responsive" ? { width: "100%", height: "auto" } : undefined;
+    if (layoutStyle)
+      userStyle = { ...userStyle, ...layoutStyle };
+    if (!sizes && (layout === "responsive" || layout === "fill"))
+      sizes = "100vw";
+  }
+  const staticData = rawSrc && typeof rawSrc !== "string" ? unwrapStaticImport(rawSrc) : undefined;
+  const src = typeof rawSrc === "string" ? rawSrc : staticData?.src ?? "";
+  let width = toNumber(widthProp);
+  let height = toNumber(heightProp);
+  if (staticData) {
+    if (width === undefined && height === undefined) {
+      width = staticData.width;
+      height = staticData.height;
+    } else if (width !== undefined && height === undefined) {
+      height = Math.round(staticData.height / staticData.width * width);
+    } else if (height !== undefined && width === undefined) {
+      width = Math.round(staticData.width / staticData.height * height);
+    }
+  }
+  const blurDataURL = blurDataURLProp ?? staticData?.blurDataURL;
+  const quality = toNumber(qualityProp);
+  let unoptimized = Boolean(unoptimizedProp ?? config.unoptimized);
+  if (!src || src.startsWith("data:") || src.startsWith("blob:"))
+    unoptimized = true;
+  const isDefaultLoader = !loader && !config.loaderFile;
+  if (isDefaultLoader && !config.dangerouslyAllowSVG && (src.split("?", 1)[0] ?? "").endsWith(".svg")) {
+    unoptimized = true;
+  }
+  if (!unoptimized)
+    validateLocalSrc(config, src);
+  const activeLoader = loader ? ({ src: s, width: w, quality: q }) => loader({ src: s, width: w, quality: q }) : ({ config: c, src: s, width: w, quality: q }) => defaultLoader(c, s, w, q);
+  const imgAttrs = generateImgAttrs({
+    config,
+    src,
+    unoptimized,
+    width: fill ? undefined : width,
+    quality,
+    sizes,
+    loader: activeLoader
+  });
+  const isBlur = placeholder === "blur" && Boolean(blurDataURL);
+  const imgStyle = {
+    ...fill ? { ...fillStyle(), objectFit, objectPosition } : {},
+    ...showAltText ? {} : { color: "transparent" },
+    ...userStyle
+  };
+  const objectFitVal = typeof imgStyle.objectFit === "string" ? imgStyle.objectFit : undefined;
+  const backgroundImage = !blurComplete && placeholder !== "empty" ? placeholder === "blur" ? (typeof __PNEXT_IMAGE_BLUR__ === "boolean" ? __PNEXT_IMAGE_BLUR__ : true) && blurDataURL ? `url("data:image/svg+xml;charset=utf-8,${getImageBlurSvg({
+    widthInt: fill ? undefined : width,
+    heightInt: fill ? undefined : height,
+    blurWidth: staticData?.blurWidth,
+    blurHeight: staticData?.blurHeight,
+    blurDataURL,
+    objectFit: objectFitVal
+  })}")` : undefined : `url("${placeholder}")` : undefined;
+  let backgroundSize = "cover";
+  if (objectFitVal === "fill")
+    backgroundSize = "100% 100%";
+  else if (objectFitVal && !INVALID_BACKGROUND_SIZE.has(objectFitVal))
+    backgroundSize = objectFitVal;
+  const placeholderStyle = backgroundImage ? {
+    backgroundSize,
+    backgroundPosition: imgStyle.objectPosition || "50% 50%",
+    backgroundRepeat: "no-repeat",
+    backgroundImage
+  } : {};
+  const style = serializeStyle({ ...imgStyle, ...placeholderStyle });
+  const resolvedSrc = (overrideSrc ?? imgAttrs.src) || undefined;
+  const props = {
+    ...rest,
+    alt,
+    ...resolvedSrc !== undefined ? { src: resolvedSrc } : {},
+    ...imgAttrs.srcSet ? { srcSet: imgAttrs.srcSet } : {},
+    ...imgAttrs.sizes ? { sizes: imgAttrs.sizes } : {},
+    decoding,
+    style
+  };
+  if (!fill) {
+    if (width !== undefined)
+      props.width = width;
+    if (height !== undefined)
+      props.height = height;
+  }
+  if (loading !== undefined)
+    props.loading = loading;
+  else if (!priority && !preload)
+    props.loading = "lazy";
+  if (fetchPriority !== undefined)
+    props.fetchpriority = fetchPriority;
+  return {
+    props,
+    meta: {
+      preload: preload || priority,
+      fill,
+      unoptimized,
+      placeholder: isBlur ? "blur" : String(placeholder),
+      imgAttributes: {
+        src: resolvedSrc ?? "",
+        ...imgAttrs.srcSet ? { srcSet: imgAttrs.srcSet } : {},
+        ...imgAttrs.sizes ? { sizes: imgAttrs.sizes } : {}
+      },
+      ...backgroundImage ? { loadedStyle: serializeStyle(imgStyle) } : {}
+    }
+  };
+}
+function normalizeStyle(style) {
+  if (!style)
+    return {};
+  if (typeof style !== "string")
+    return { ...style };
+  const out = {};
+  for (const decl of style.split(";")) {
+    const [k, v] = decl.split(":");
+    if (k && v)
+      out[camel(k.trim())] = v.trim();
+  }
+  return out;
+}
+function fillStyle() {
+  return {
+    position: "absolute",
+    height: "100%",
+    width: "100%",
+    left: "0",
+    top: "0",
+    right: "0",
+    bottom: "0"
+  };
+}
+function validateLocalSrc(config, src) {
+  if (!src.startsWith("/") || src.startsWith("//") || config.localPatterns !== undefined)
+    return;
+  const search = new URL(src, "http://n").search;
+  if (!search)
+    return;
+  throw new Error(`Image with src "${src}" is using a query string which is not configured in images.localPatterns.
+Read more: https://nextjs.org/docs/messages/next-image-unconfigured-localpatterns`);
+}
+function camel(prop) {
+  return prop.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+var UNITLESS_STYLE_PROPS = new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridArea",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth"
+]);
+function serializeStyle(style) {
+  return Object.entries(style).filter(([, v]) => v !== undefined && v !== "").map(([k, v]) => `${kebab(k)}:${cssValue(k, v)}`).join(";");
+}
+function cssValue(prop, value) {
+  if (typeof value === "number" && value !== 0 && !UNITLESS_STYLE_PROPS.has(prop))
+    return `${value}px`;
+  return String(value);
+}
+function kebab(prop) {
+  return prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+
+export { getImagesConfig, findClosestQuality, getImageProps, unstable_getImgProps, resolveImageProps };

package/dist/server/_chunks/index-sq3kvz3g.js

@@ -0,0 +1,200 @@
+// @bun
+// src/compat/next/image/validate.ts
+import fs from "fs";
+import path from "path";
+var LOADERS = ["default", "imgix", "cloudinary", "akamai", "custom"];
+var FORMATS = ["image/avif", "image/webp"];
+var DISPOSITIONS = ["inline", "attachment"];
+var REMOTE_PATTERN_KEYS = new Set(["protocol", "hostname", "port", "pathname", "search"]);
+var LOCAL_PATTERN_KEYS = new Set(["pathname", "search"]);
+function hasDefaultExport(file) {
+  let source;
+  try {
+    source = fs.readFileSync(file, "utf8");
+  } catch {
+    return false;
+  }
+  return /\bexport\s+default\b/.test(source) || /\bmodule\.exports\s*=/.test(source);
+}
+function received(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+function quotedUnion(options) {
+  return options.map((option) => `'${option}'`).join(" | ");
+}
+function collectImagesConfigErrors(config, root) {
+  const errors = [];
+  const assetPrefix = config.assetPrefix;
+  if (typeof assetPrefix === "string" && assetPrefix !== "" && !assetPrefix.startsWith("/")) {
+    try {
+      new URL(assetPrefix);
+    } catch {
+      errors.push("Invalid assetPrefix provided. Original error: TypeError: Invalid URL");
+    }
+  }
+  const images = config.images;
+  if (images === undefined || images === null)
+    return errors;
+  if (typeof images !== "object" || Array.isArray(images)) {
+    errors.push(`Expected object, received ${received(images)} at "images"`);
+    return errors;
+  }
+  const img = images;
+  validateSizeArray(errors, img.deviceSizes, "images.deviceSizes");
+  validateSizeArray(errors, img.imageSizes, "images.imageSizes");
+  if (img.domains !== undefined) {
+    if (!Array.isArray(img.domains)) {
+      errors.push(`Expected array, received ${received(img.domains)} at "images.domains"`);
+    } else if (img.domains.length > 50) {
+      errors.push('Array must contain at most 50 element(s) at "images.domains"');
+    }
+  }
+  if (img.qualities !== undefined) {
+    if (!Array.isArray(img.qualities)) {
+      errors.push(`Expected array, received ${received(img.qualities)} at "images.qualities"`);
+    } else {
+      if (img.qualities.length < 1) {
+        errors.push('Array must contain at least 1 element(s) at "images.qualities"');
+      }
+      if (img.qualities.length > 20) {
+        errors.push('Array must contain at most 20 element(s) at "images.qualities"');
+      }
+      img.qualities.forEach((quality, index) => {
+        if (typeof quality !== "number") {
+          errors.push(`Expected number, received ${received(quality)} at "images.qualities[${index}]"`);
+        } else if (!Number.isInteger(quality)) {
+          errors.push(`Expected integer, received float at "images.qualities[${index}]"`);
+        } else if (quality < 1) {
+          errors.push(`Number must be greater than or equal to 1 at "images.qualities[${index}]"`);
+        } else if (quality > 100) {
+          errors.push(`Number must be less than or equal to 100 at "images.qualities[${index}]"`);
+        }
+      });
+    }
+  }
+  if (img.localPatterns !== undefined) {
+    if (!Array.isArray(img.localPatterns)) {
+      errors.push(`Expected array, received ${received(img.localPatterns)} at "images.localPatterns"`);
+    } else {
+      if (img.localPatterns.length > 25) {
+        errors.push('Array must contain at most 25 element(s) at "images.localPatterns"');
+      }
+      img.localPatterns.forEach((pattern, index) => {
+        if (!pattern || typeof pattern !== "object")
+          return;
+        const unknown = Object.keys(pattern).filter((key) => !LOCAL_PATTERN_KEYS.has(key));
+        if (unknown.length > 0) {
+          errors.push(`Unrecognized key(s) in object: ${unknown.map((key) => `'${key}'`).join(", ")} at "images.localPatterns[${index}]"`);
+        }
+      });
+    }
+  }
+  if (img.remotePatterns !== undefined) {
+    if (!Array.isArray(img.remotePatterns)) {
+      errors.push(`Expected array, received ${received(img.remotePatterns)} at "images.remotePatterns"`);
+    } else {
+      if (img.remotePatterns.length > 50) {
+        errors.push('Array must contain at most 50 element(s) at "images.remotePatterns"');
+      }
+      img.remotePatterns.forEach((pattern, index) => {
+        if (pattern instanceof URL) {
+          const protocol = pattern.protocol.replace(/:$/, "");
+          if (protocol !== "http" && protocol !== "https") {
+            errors.push(`Specified images.remotePatterns must have protocol "http" or "https" received "${protocol}"`);
+          }
+          return;
+        }
+        if (!pattern || typeof pattern !== "object") {
+          errors.push(`Expected object, received ${received(pattern)} at "images.remotePatterns[${index}]"`);
+          return;
+        }
+        const obj = pattern;
+        const unknown = Object.keys(obj).filter((key) => !REMOTE_PATTERN_KEYS.has(key));
+        if (unknown.length > 0) {
+          errors.push(`Unrecognized key(s) in object: ${unknown.map((key) => `'${key}'`).join(", ")} at "images.remotePatterns[${index}]"`);
+        }
+        if (typeof obj.hostname !== "string") {
+          errors.push(`"images.remotePatterns[${index}].hostname" is missing, expected string`);
+        }
+      });
+    }
+  }
+  if (img.loader !== undefined) {
+    if (typeof img.loader !== "string" || !LOADERS.includes(img.loader)) {
+      errors.push(`Expected ${quotedUnion(LOADERS)}, received '${received(img.loader) === "string" ? img.loader : received(img.loader)}' at "images.loader"`);
+    } else if (img.loader !== "default" && img.loader !== "custom") {
+      const loader = img.loader;
+      if (typeof img.path !== "string" || img.path === "" || img.path === "/_next/image") {
+        errors.push(`Specified images.loader property (${loader}) also requires images.path property to be assigned to a URL prefix.`);
+      }
+      if (typeof img.loaderFile === "string" && img.loaderFile !== "") {
+        errors.push(`Specified images.loader property (${loader}) cannot be used with images.loaderFile property. Please set images.loader to "custom".`);
+      }
+    }
+  }
+  if (typeof img.loaderFile === "string" && img.loaderFile !== "") {
+    const absolute = img.loaderFile.startsWith("/") ? path.join(root, img.loaderFile) : path.resolve(root, img.loaderFile);
+    if (!fs.existsSync(absolute)) {
+      errors.push(`Specified images.loaderFile does not exist at "${absolute}".`);
+    } else if (!hasDefaultExport(absolute)) {
+      errors.push(`images.loaderFile detected but the file is missing default export.
+` + "Read more: https://nextjs.org/docs/messages/invalid-images-config");
+    }
+  }
+  if (img.formats !== undefined) {
+    if (!Array.isArray(img.formats)) {
+      errors.push(`Expected array, received ${received(img.formats)} at "images.formats"`);
+    } else {
+      img.formats.forEach((format, index) => {
+        if (!FORMATS.includes(format)) {
+          errors.push(`Expected ${quotedUnion(FORMATS)}, received '${String(format)}' at "images.formats[${index}]"`);
+        }
+      });
+    }
+  }
+  if (img.contentDispositionType !== undefined && !DISPOSITIONS.includes(img.contentDispositionType)) {
+    errors.push(`Expected ${quotedUnion(DISPOSITIONS)}, received '${typeof img.contentDispositionType === "string" ? img.contentDispositionType : received(img.contentDispositionType)}' at "images.contentDispositionType"`);
+  }
+  if (img.contentSecurityPolicy !== undefined && typeof img.contentSecurityPolicy !== "string") {
+    errors.push(`Expected string, received ${received(img.contentSecurityPolicy)} at "images.contentSecurityPolicy"`);
+  }
+  if (img.minimumCacheTTL !== undefined) {
+    if (typeof img.minimumCacheTTL !== "number") {
+      errors.push(`Expected number, received ${received(img.minimumCacheTTL)} at "images.minimumCacheTTL"`);
+    } else if (img.minimumCacheTTL < 0) {
+      errors.push('Number must be greater than or equal to 0 at "images.minimumCacheTTL"');
+    }
+  }
+  for (const key of ["dangerouslyAllowSVG", "unoptimized", "disableStaticImages"]) {
+    if (img[key] !== undefined && typeof img[key] !== "boolean") {
+      errors.push(`Expected boolean, received ${received(img[key])} at "images.${key}"`);
+    }
+  }
+  return errors;
+}
+function validateSizeArray(errors, value, label) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value)) {
+    errors.push(`Expected array, received ${received(value)} at "${label}"`);
+    return;
+  }
+  if (value.length > 25) {
+    errors.push(`Array must contain at most 25 element(s) at "${label}"`);
+  }
+  value.forEach((size, index) => {
+    if (typeof size !== "number") {
+      errors.push(`Expected number, received ${received(size)} at "${label}[${index}]"`);
+    } else if (size < 1) {
+      errors.push(`Number must be greater than or equal to 1 at "${label}[${index}]"`);
+    } else if (size > 1e4) {
+      errors.push(`Number must be less than or equal to 10000 at "${label}[${index}]"`);
+    }
+  });
+}
+
+export { collectImagesConfigErrors };

package/dist/server/_chunks/index-stbk3jhn.js

@@ -0,0 +1,31 @@
+// @bun
+// src/compat/next/dist/client/components/app-router-headers.ts
+var RSC_HEADER = "rsc";
+var ACTION_HEADER = "next-action";
+var NEXT_ROUTER_STATE_TREE_HEADER = "next-router-state-tree";
+var NEXT_ROUTER_PREFETCH_HEADER = "next-router-prefetch";
+var NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = "next-router-segment-prefetch";
+var NEXT_HMR_REFRESH_HEADER = "next-hmr-refresh";
+var NEXT_HMR_REFRESH_HASH_COOKIE = "__next_hmr_refresh_hash__";
+var NEXT_URL = "next-url";
+var RSC_CONTENT_TYPE_HEADER = "text/x-component";
+var NEXT_INSTANT_TEST_COOKIE = "next-instant-navigation-testing";
+var FLIGHT_HEADERS = [
+  RSC_HEADER,
+  NEXT_ROUTER_STATE_TREE_HEADER,
+  NEXT_ROUTER_PREFETCH_HEADER,
+  NEXT_HMR_REFRESH_HEADER,
+  NEXT_ROUTER_SEGMENT_PREFETCH_HEADER
+];
+var NEXT_RSC_UNION_QUERY = "_rsc";
+var NEXT_ROUTER_STALE_TIME_HEADER = "x-nextjs-stale-time";
+var NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
+var NEXT_REWRITTEN_PATH_HEADER = "x-nextjs-rewritten-path";
+var NEXT_REWRITTEN_QUERY_HEADER = "x-nextjs-rewritten-query";
+var NEXT_IS_PRERENDER_HEADER = "x-nextjs-prerender";
+var NEXT_ACTION_NOT_FOUND_HEADER = "x-nextjs-action-not-found";
+var NEXT_REQUEST_ID_HEADER = "x-nextjs-request-id";
+var NEXT_HTML_REQUEST_ID_HEADER = "x-nextjs-html-request-id";
+var NEXT_ACTION_REVALIDATED_HEADER = "x-action-revalidated";
+
+export { RSC_HEADER, ACTION_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_HMR_REFRESH_HEADER, NEXT_HMR_REFRESH_HASH_COOKIE, NEXT_URL, RSC_CONTENT_TYPE_HEADER, NEXT_INSTANT_TEST_COOKIE, FLIGHT_HEADERS, NEXT_RSC_UNION_QUERY, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_DID_POSTPONE_HEADER, NEXT_REWRITTEN_PATH_HEADER, NEXT_REWRITTEN_QUERY_HEADER, NEXT_IS_PRERENDER_HEADER, NEXT_ACTION_NOT_FOUND_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_ACTION_REVALIDATED_HEADER };