@wular/coder 0.4.2 → 0.4.4

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-qcrvt6er.js

@@ -0,0 +1,112 @@
+// @bun
+import {
+  restartCacheEnabled
+} from "./index-knp0s912.js";
+import {
+  frameworkFingerprint
+} from "./index-gcmj16xy.js";
+import {
+  writeFileAtomic
+} from "./index-4da76t62.js";
+import {
+  outCachePath
+} from "./index-bzd2ef7t.js";
+
+// src/compat/next/font/cache.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { mkdir, stat } from "fs/promises";
+import path from "path";
+var INDEX_VERSION = 2;
+var indexes = new Map;
+function fontIndex(config) {
+  const file = path.join(outCachePath(config.outPath), "fonts", "index.json");
+  const existing = indexes.get(file);
+  if (existing)
+    return existing;
+  const created = { file, fonts: readIndex(file), dirty: false };
+  indexes.set(file, created);
+  process.on("exit", () => {
+    if (!created.dirty)
+      return;
+    created.dirty = false;
+    try {
+      writeFileSync(created.file, serializeIndex(created.fonts));
+    } catch {}
+  });
+  return created;
+}
+async function persistedFont(config, key) {
+  if (!restartCacheEnabled())
+    return;
+  const entry = fontIndex(config).fonts.get(key);
+  if (!entry)
+    return;
+  if (!entry.files.every((file) => existsSync(file)))
+    return;
+  const stats = await Promise.all(entry.sourceStats.map(async ([file, mtimeMs, size]) => {
+    const current = await stat(file).catch(() => {
+      return;
+    });
+    return current?.mtimeMs === mtimeMs && current.size === size;
+  }));
+  if (!stats.every(Boolean))
+    return;
+  return entry;
+}
+async function persistFont(config, key, font) {
+  const index = fontIndex(config);
+  const sourceStats = await Promise.all((font.sources ?? []).map(async (file) => {
+    const stats = await stat(file).catch(() => {
+      return;
+    });
+    return stats ? [file, stats.mtimeMs, stats.size] : undefined;
+  }));
+  if (sourceStats.some((entry) => entry === undefined))
+    return;
+  index.fonts.set(key, { ...font, sourceStats });
+  persist(index);
+}
+function persist(index) {
+  index.dirty = true;
+  if (index.flush)
+    return;
+  index.flush = setTimeout(async () => {
+    index.flush = undefined;
+    if (!index.dirty)
+      return;
+    const contents = serializeIndex(index.fonts);
+    try {
+      await mkdir(path.dirname(index.file), { recursive: true });
+      await writeFileAtomic(index.file, contents);
+      index.dirty = false;
+    } catch {}
+  }, 50);
+}
+function readIndex(file) {
+  const fonts = new Map;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return fonts;
+  }
+  if (parsed?.version !== INDEX_VERSION || parsed.runtime !== runtimeFingerprint()) {
+    return fonts;
+  }
+  for (const [key, entry] of Object.entries(parsed.fonts ?? {})) {
+    if (entry && Array.isArray(entry.files) && Array.isArray(entry.sourceStats)) {
+      fonts.set(key, entry);
+    }
+  }
+  return fonts;
+}
+function serializeIndex(fonts) {
+  return JSON.stringify({
+    version: INDEX_VERSION,
+    runtime: runtimeFingerprint(),
+    fonts: Object.fromEntries(fonts)
+  });
+}
+var runtimeFingerprint = () => frameworkFingerprint();
+
+export { persistedFont, persistFont };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-qjj6gddn.js

@@ -0,0 +1,54 @@
+// @bun
+// src/utils/code.ts
+function escapeRegex(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+function specifierSniffTokens(keys) {
+  const heads = [
+    ...new Set([...keys].map((key) => {
+      const head = key.split("/").slice(0, key.startsWith("@") ? 2 : 1).join("/");
+      return head.replace(/\*.*$/, "");
+    }))
+  ];
+  return heads.filter((head) => !heads.some((other) => other !== head && head.startsWith(other)));
+}
+function uniqueIdentifier(source, base, ...used) {
+  const usedNames = new Set(used);
+  let name = base;
+  let index = 0;
+  while (source.includes(name) || usedNames.has(name)) {
+    index += 1;
+    name = `${base}${index}`;
+  }
+  return name;
+}
+function isIdentifier(value) {
+  return /^[A-Za-z_$][\w$]*$/.test(value);
+}
+function esbuildEntryExportNames(code) {
+  const scope = entryCommonJsScope(code);
+  const assignments = [
+    ...scope.matchAll(/module\.exports\s*=\s*(?:[A-Za-z_$][\w$]*\s*\(\s*)?([A-Za-z_$][\w$]*)\s*\)?\s*[;\n]/g)
+  ];
+  const entryVar = assignments.at(-1)?.[1];
+  if (!entryVar)
+    return [];
+  const exportCall = new RegExp(`[A-Za-z_$][\\w$]*\\(\\s*${escapeRegex(entryVar)}\\s*,\\s*\\{([\\s\\S]*?)\\}\\s*\\)`).exec(scope);
+  if (!exportCall?.[1])
+    return [];
+  return [
+    ...exportCall[1].matchAll(/(?:^|,)\s*(?:["']([^"']+)["']|([A-Za-z_$][\w$]*))\s*:\s*\(\s*\)\s*=>/g)
+  ].map((match) => match[1] ?? match[2]).filter((name) => Boolean(name && isIdentifier(name)));
+}
+function entryCommonJsScope(code) {
+  const wrapper = /(^|\n)export default ([A-Za-z_$][\w$]*)\(\)/.exec(code)?.[2];
+  if (!wrapper)
+    return code;
+  const start = code.lastIndexOf(`var ${wrapper} = `);
+  return start === -1 ? code : code.slice(start);
+}
+function stripComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+
+export { escapeRegex, specifierSniffTokens, uniqueIdentifier, isIdentifier, esbuildEntryExportNames, stripComments };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-qpwsgt3a.js

@@ -0,0 +1,158 @@
+// @bun
+import {
+  getWorkUnit,
+  runWithRequest
+} from "./index-grta8ap3.js";
+import {
+  getRenderExtensions,
+  reportRequestError
+} from "./index-zqpqyg8p.js";
+
+// src/routing/handler.ts
+import { isNotFoundError, isRedirectError } from "../../../src/api/navigation.ts";
+import { nextResponseMeta, toNextRequest } from "../../../src/api/server.ts";
+import { safeDecode } from "../../../src/utils/decode.ts";
+var routeMethods = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+var httpMethods = new Set([
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+]);
+async function handleRouteModule(module, request, params, options = {}) {
+  const responseHeaders = new Headers;
+  const method = request.method.toUpperCase();
+  try {
+    if (!httpMethods.has(method))
+      return new Response(null, { status: 400 });
+    const handler = routeMethods.includes(method) ? module[method] : undefined;
+    if (!handler) {
+      if (method === "HEAD" && module.GET) {
+        const response = finalizeResponse(await callHandler(module.GET, request, params, responseHeaders), request, responseHeaders, options);
+        return new Response(null, { status: response.status, headers: response.headers });
+      }
+      return missingMethodResponse(module, method);
+    }
+    return finalizeResponse(await callHandler(handler, request, params, responseHeaders), request, responseHeaders, options);
+  } catch (error) {
+    if (isRedirectError(error)) {
+      const status = method === "POST" ? 303 : error.status;
+      return withResponseHeaders(new Response(null, { status, headers: { location: error.location } }), responseHeaders);
+    }
+    if (isNotFoundError(error)) {
+      return withResponseHeaders(new Response(null, { status: 404 }), responseHeaders);
+    }
+    await reportRequestError(error, { method, url: request.url, headers: request.headers }, { phase: "handler", routeKind: "route-handler", ...getWorkUnit()?.responseHints ?? {} });
+    console.error(error);
+    return new Response(null, { status: 500 });
+  }
+}
+function finalizeResponse(response, request, responseHeaders, options) {
+  const method = request.method.toUpperCase();
+  if (!response) {
+    const file = options.routeFile ?? "<route>";
+    console.error(`No response is returned from route handler '${file}'. Expected a Response object but ` + `received '${typeof response}' (method: ${method}, url: ${request.url}). Ensure you ` + "return a `Response` or a `NextResponse` in all branches of your handler.");
+    return new Response(null, { status: 500 });
+  }
+  if (nextResponseMeta(response)?.kind === "next") {
+    console.error("https://nextjs.org/docs/messages/next-response-next-in-app-route-handler");
+    return new Response(null, { status: 500 });
+  }
+  return withResponseHeaders(response, responseHeaders);
+}
+function callHandler(handler, request, params, responseHeaders) {
+  const nextRequest = toNextRequest(request);
+  const context = Object.keys(params).length > 0 ? {
+    params: getRenderExtensions().legacySyncProps(Promise.resolve(params), "params", params)
+  } : {};
+  return runWithRequest(nextRequest, () => handler(nextRequest, context), params, {
+    responseHeaders
+  });
+}
+function withResponseHeaders(response, extra) {
+  const withSetCookie = extra;
+  const scopeCookies = withSetCookie.getSetCookie?.() ?? [];
+  let hasOthers = false;
+  extra.forEach((_, key) => {
+    if (key !== "set-cookie")
+      hasOthers = true;
+  });
+  if (scopeCookies.length === 0 && !hasOthers)
+    return response;
+  const apply = (headers) => {
+    extra.forEach((value, key) => {
+      if (key !== "set-cookie")
+        headers.set(key, value);
+    });
+    const responseCookies = headers.getSetCookie?.() ?? [];
+    const jar = new Map;
+    for (const cookie of [...scopeCookies, ...responseCookies]) {
+      jar.set(cookieName(cookie), normalizeSetCookie(cookie));
+    }
+    headers.delete("set-cookie");
+    for (const cookie of jar.values())
+      headers.append("set-cookie", cookie);
+  };
+  try {
+    apply(response.headers);
+    return response;
+  } catch {
+    const headers = new Headers(response.headers);
+    apply(headers);
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+function cookieName(setCookie) {
+  return (setCookie.split("=")[0] ?? "").trim();
+}
+function normalizeSetCookie(setCookie) {
+  return /;\s*path=/i.test(setCookie) ? setCookie : `${setCookie}; Path=/`;
+}
+async function staticRouteParams(route, module) {
+  if (typeof module.GET !== "function")
+    return [];
+  const config = route.segmentConfig;
+  const optedStatic = config?.dynamic === "force-static" || config?.dynamic === "error" || config?.revalidate === false || typeof config?.revalidate === "number" && config.revalidate > 0;
+  if (route.hasStaticParams)
+    return module.params?.() ?? [];
+  if (route.usesRequest && !optedStatic)
+    return [];
+  return route.mode === "static" || optedStatic ? [{}] : [];
+}
+function routeParamsFromPath(route, pathname) {
+  const match = new RegExp(`^${route.pattern}$`).exec(pathname);
+  const params = {};
+  if (!match)
+    return params;
+  for (let index = 0;index < route.params.length; index += 1) {
+    params[route.params[index]] = safeDecode(match[index + 1] ?? "");
+  }
+  if (route.catchAll) {
+    params[route.catchAll] = (match[route.params.length + 1] ?? "").split("/").filter(Boolean).map(safeDecode);
+  }
+  return params;
+}
+function missingMethodResponse(module, method) {
+  const headers = { Allow: allowedMethods(module).join(", ") };
+  if (method === "OPTIONS")
+    return new Response(null, { status: 204, headers });
+  return new Response(null, { status: 405, headers });
+}
+function allowedMethods(module) {
+  const allowed = new Set(routeMethods.filter((method) => typeof module[method] === "function"));
+  if (allowed.has("GET"))
+    allowed.add("HEAD");
+  allowed.add("OPTIONS");
+  return [...allowed].sort();
+}
+
+export { handleRouteModule, staticRouteParams, routeParamsFromPath };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-ras0sdab.js

@@ -0,0 +1,26 @@
+// @bun
+// src/client/reference.ts
+import { createHash } from "crypto";
+import path from "path";
+var compiledClientReferences = new Set;
+function noteCompiledClientReference(file) {
+  compiledClientReferences.add(path.resolve(file));
+}
+function compiledClientReferenceFiles() {
+  return compiledClientReferences;
+}
+var clientReferenceSymbol = Symbol.for("pnext.clientReference");
+function clientReferenceId(file, exportName) {
+  return createHash("sha256").update(file).update("\x00").update(exportName).digest("hex").slice(0, 10);
+}
+function ssrClientReference(reference) {
+  if (reference.sideEffect)
+    return false;
+  if (reference.dynamic?.ssr === false)
+    return false;
+  if (reference.dynamic?.load === "visible" && reference.dynamic.ssr !== true)
+    return false;
+  return true;
+}
+
+export { noteCompiledClientReference, compiledClientReferenceFiles, clientReferenceSymbol, clientReferenceId, ssrClientReference };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-rcs322t1.js

@@ -0,0 +1,19 @@
+// @bun
+import {
+  getAssetExtensions
+} from "./index-zqpqyg8p.js";
+
+// src/cli/serve/immutable.ts
+var immutableCacheControl = "public, max-age=31536000, immutable";
+function immutableAssetPath(relativePath) {
+  return immutableAssetPrefixes().some((prefix) => relativePath.startsWith(prefix));
+}
+function immutableAssetPrefixes() {
+  return [
+    "assets/",
+    "_next/static/",
+    ...getAssetExtensions().staticAssetPublicPrefixes().map((prefix) => prefix.replace(/^\/+/, ""))
+  ];
+}
+
+export { immutableCacheControl, immutableAssetPath, immutableAssetPrefixes };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-rgj5mx84.js

@@ -0,0 +1,101 @@
+// @bun
+import {
+  compileSource,
+  evaluateConditions,
+  loadNextConfig,
+  loadResolvedNextConfig,
+  parseConditions,
+  substitute
+} from "./index-he6n2bvp.js";
+
+// src/compat/next/config-headers.ts
+async function loadCompatHeaders(root) {
+  let config = await loadResolvedNextConfig(root);
+  if (typeof config?.headers !== "function")
+    config = await loadNextConfig(root);
+  const producer = config?.headers;
+  if (typeof producer !== "function")
+    return [];
+  let value;
+  try {
+    value = await producer();
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(value))
+    return [];
+  const rules = [];
+  for (const entry of value) {
+    if (!entry?.source || !Array.isArray(entry.headers))
+      continue;
+    const headers = parseHeaderPairs(entry.headers);
+    if (headers.length === 0)
+      continue;
+    const has = parseConditions(entry.has);
+    const missing = parseConditions(entry.missing);
+    if (has === null || missing === null)
+      continue;
+    const compiled = compileSource(entry.source);
+    if (!compiled)
+      continue;
+    rules.push({
+      ...compiled,
+      headers,
+      has,
+      missing,
+      outsideBasePath: entry.basePath === false
+    });
+  }
+  return rules;
+}
+function parseHeaderPairs(value) {
+  const pairs = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const { key, value: headerValue } = raw;
+    if (typeof key !== "string" || typeof headerValue !== "string")
+      continue;
+    pairs.push({ key, value: headerValue });
+  }
+  return pairs;
+}
+function resolveCompatHeaders(rules, pathname, ctx) {
+  const context = ctx ?? {
+    host: "",
+    headers: new Headers,
+    cookies: {},
+    query: new URLSearchParams
+  };
+  const resolved = [];
+  for (const rule of rules) {
+    const match = rule.regex.exec(pathname);
+    if (!match)
+      continue;
+    const params = {};
+    rule.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1] ?? "";
+    });
+    const conditionParams = evaluateConditions(rule, context);
+    if (conditionParams === null)
+      continue;
+    Object.assign(params, conditionParams);
+    const hasParams = Object.keys(params).length > 0;
+    for (const pair of rule.headers) {
+      resolved.push(hasParams ? {
+        key: substitute(pair.key, params).pathname,
+        value: substitute(pair.value, params).pathname
+      } : pair);
+    }
+  }
+  return resolved;
+}
+function appPathname(pathname, basePath) {
+  if (!basePath)
+    return pathname;
+  if (pathname === basePath)
+    return "/";
+  return pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) : undefined;
+}
+
+export { loadCompatHeaders, resolveCompatHeaders, appPathname };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-rt9qq1va.js

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

package/dist/dash/standalone/node_modules/@wular/pnext/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 };