payload 4.0.0-internal.cd69eef → 4.0.0-internal.ce66a41

package/dist/uploads/transformers/resolveUploadDocument.js

@@ -0,0 +1,77 @@
+import { Forbidden } from '../../errors/Forbidden.js';
+/**
+ * The primary filename, or a configured legacy image size's filename, both match.
+ * Shared with `checkFileAccess.ts` so the two lookups can't drift apart.
+ */ export function buildFilenameWhere({ filename, variants }) {
+    const filenameCondition = {
+        or: [
+            {
+                filename: {
+                    equals: filename
+                }
+            }
+        ]
+    };
+    variants?.forEach(({ name })=>{
+        filenameCondition.or.push({
+            [`variants.${name}.filename`]: {
+                equals: filename
+            }
+        });
+    });
+    return filenameCondition;
+}
+/**
+ * The `filename` and `mimeType` of the file a request actually targets: the
+ * primary file, or the legacy image size whose filename matched (a size can be
+ * stored in a different format than the primary file via `formatOptions`).
+ */ export function getRequestedFile({ document, filename }) {
+    if (document.filename !== filename) {
+        const size = Object.values(document.variants ?? {}).find((size)=>size?.filename === filename);
+        if (size?.filename && size.mimeType) {
+            return {
+                filename: size.filename,
+                mimeType: size.mimeType
+            };
+        }
+    }
+    return {
+        filename: document.filename,
+        mimeType: document.mimeType
+    };
+}
+/**
+ * Finds the upload document matching a filename (or one of its configured legacy
+ * image sizes) and an optional storage `prefix`, without applying any access-control
+ * filtering. Runs unconditionally — no `constraints.length` fast path — because
+ * it's only ever called when at least one transformer is configured, and pipeline
+ * planning needs the document's authoritative `mimeType` before access is enforced.
+ */ export async function resolveUploadDocument({ collection, filename, prefix, req }) {
+    if (filename.includes('../') || filename.includes('..\\')) {
+        throw new Forbidden(req.t);
+    }
+    const { config } = collection;
+    const constraints = [
+        buildFilenameWhere({
+            filename,
+            variants: config.upload.variants
+        })
+    ];
+    if (typeof prefix === 'string') {
+        constraints.push({
+            prefix: {
+                equals: prefix
+            }
+        });
+    }
+    const doc = await req.payload.db.findOne({
+        collection: config.slug,
+        req,
+        where: constraints.length > 1 ? {
+            and: constraints
+        } : constraints[0]
+    });
+    return doc ?? undefined;
+}
+
+//# sourceMappingURL=resolveUploadDocument.js.map

package/dist/uploads/transformers/resolveUploadDocument.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/transformers/resolveUploadDocument.ts"],"sourcesContent":["import type { Collection, TypeWithID } from '../../collections/config/types.js'\nimport type { PayloadRequest, Where } from '../../types/index.js'\n\nimport { Forbidden } from '../../errors/Forbidden.js'\n\nexport type ResolvedUploadDocument = {\n  filename: string\n  mimeType: string\n  variants?: Record<string, { filename?: null | string; mimeType?: null | string } | null>\n} & TypeWithID\n\n/**\n * The primary filename, or a configured legacy image size's filename, both match.\n * Shared with `checkFileAccess.ts` so the two lookups can't drift apart.\n */\nexport function buildFilenameWhere({\n  filename,\n  variants,\n}: {\n  filename: string\n  variants?: { name: string }[]\n}): Where {\n  const filenameCondition: Where = {\n    or: [{ filename: { equals: filename } }],\n  }\n\n  variants?.forEach(({ name }) => {\n    filenameCondition.or!.push({\n      [`variants.${name}.filename`]: { equals: filename },\n    })\n  })\n\n  return filenameCondition\n}\n\n/**\n * The `filename` and `mimeType` of the file a request actually targets: the\n * primary file, or the legacy image size whose filename matched (a size can be\n * stored in a different format than the primary file via `formatOptions`).\n */\nexport function getRequestedFile({\n  document,\n  filename,\n}: {\n  document: ResolvedUploadDocument\n  filename: string\n}): { filename: string; mimeType: string } {\n  if (document.filename !== filename) {\n    const size = Object.values(document.variants ?? {}).find((size) => size?.filename === filename)\n\n    if (size?.filename && size.mimeType) {\n      return { filename: size.filename, mimeType: size.mimeType }\n    }\n  }\n\n  return { filename: document.filename, mimeType: document.mimeType }\n}\n\n/**\n * Finds the upload document matching a filename (or one of its configured legacy\n * image sizes) and an optional storage `prefix`, without applying any access-control\n * filtering. Runs unconditionally — no `constraints.length` fast path — because\n * it's only ever called when at least one transformer is configured, and pipeline\n * planning needs the document's authoritative `mimeType` before access is enforced.\n */\nexport async function resolveUploadDocument({\n  collection,\n  filename,\n  prefix,\n  req,\n}: {\n  collection: Collection\n  filename: string\n  prefix?: string\n  req: PayloadRequest\n}): Promise<ResolvedUploadDocument | undefined> {\n  if (filename.includes('../') || filename.includes('..\\\\')) {\n    throw new Forbidden(req.t)\n  }\n\n  const { config } = collection\n\n  const constraints: Where[] = [buildFilenameWhere({ filename, variants: config.upload.variants })]\n\n  if (typeof prefix === 'string') {\n    constraints.push({ prefix: { equals: prefix } })\n  }\n\n  const doc = await req.payload.db.findOne({\n    collection: config.slug,\n    req,\n    where: constraints.length > 1 ? { and: constraints } : constraints[0],\n  })\n\n  return (doc as null | ResolvedUploadDocument) ?? undefined\n}\n"],"names":["Forbidden","buildFilenameWhere","filename","variants","filenameCondition","or","equals","forEach","name","push","getRequestedFile","document","size","Object","values","find","mimeType","resolveUploadDocument","collection","prefix","req","includes","t","config","constraints","upload","doc","payload","db","findOne","slug","where","length","and","undefined"],"mappings":"AAGA,SAASA,SAAS,QAAQ,4BAA2B;AAQrD;;;CAGC,GACD,OAAO,SAASC,mBAAmB,EACjCC,QAAQ,EACRC,QAAQ,EAIT;IACC,MAAMC,oBAA2B;QAC/BC,IAAI;YAAC;gBAAEH,UAAU;oBAAEI,QAAQJ;gBAAS;YAAE;SAAE;IAC1C;IAEAC,UAAUI,QAAQ,CAAC,EAAEC,IAAI,EAAE;QACzBJ,kBAAkBC,EAAE,CAAEI,IAAI,CAAC;YACzB,CAAC,CAAC,SAAS,EAAED,KAAK,SAAS,CAAC,CAAC,EAAE;gBAAEF,QAAQJ;YAAS;QACpD;IACF;IAEA,OAAOE;AACT;AAEA;;;;CAIC,GACD,OAAO,SAASM,iBAAiB,EAC/BC,QAAQ,EACRT,QAAQ,EAIT;IACC,IAAIS,SAAST,QAAQ,KAAKA,UAAU;QAClC,MAAMU,OAAOC,OAAOC,MAAM,CAACH,SAASR,QAAQ,IAAI,CAAC,GAAGY,IAAI,CAAC,CAACH,OAASA,MAAMV,aAAaA;QAEtF,IAAIU,MAAMV,YAAYU,KAAKI,QAAQ,EAAE;YACnC,OAAO;gBAAEd,UAAUU,KAAKV,QAAQ;gBAAEc,UAAUJ,KAAKI,QAAQ;YAAC;QAC5D;IACF;IAEA,OAAO;QAAEd,UAAUS,SAAST,QAAQ;QAAEc,UAAUL,SAASK,QAAQ;IAAC;AACpE;AAEA;;;;;;CAMC,GACD,OAAO,eAAeC,sBAAsB,EAC1CC,UAAU,EACVhB,QAAQ,EACRiB,MAAM,EACNC,GAAG,EAMJ;IACC,IAAIlB,SAASmB,QAAQ,CAAC,UAAUnB,SAASmB,QAAQ,CAAC,SAAS;QACzD,MAAM,IAAIrB,UAAUoB,IAAIE,CAAC;IAC3B;IAEA,MAAM,EAAEC,MAAM,EAAE,GAAGL;IAEnB,MAAMM,cAAuB;QAACvB,mBAAmB;YAAEC;YAAUC,UAAUoB,OAAOE,MAAM,CAACtB,QAAQ;QAAC;KAAG;IAEjG,IAAI,OAAOgB,WAAW,UAAU;QAC9BK,YAAYf,IAAI,CAAC;YAAEU,QAAQ;gBAAEb,QAAQa;YAAO;QAAE;IAChD;IAEA,MAAMO,MAAM,MAAMN,IAAIO,OAAO,CAACC,EAAE,CAACC,OAAO,CAAC;QACvCX,YAAYK,OAAOO,IAAI;QACvBV;QACAW,OAAOP,YAAYQ,MAAM,GAAG,IAAI;YAAEC,KAAKT;QAAY,IAAIA,WAAW,CAAC,EAAE;IACvE;IAEA,OAAO,AAACE,OAAyCQ;AACnD"}

package/dist/uploads/transformers/transformUploadFile.d.ts

@@ -0,0 +1,18 @@
+import type { PayloadRequest } from '../../types/index.js';
+import type { UploadTransformer } from './types.js';
+/**
+ * Runs one file through every eligible `transformFile` stage in declaration
+ * order. Used both for the ordinary top-level upload call (`options: undefined`)
+ * and, via the private v4 bridge's `transform` callback, once per legacy task
+ * (the main file, crop output, or a named image size) with that task's own
+ * `options`. Retains only the current accumulator — never a history array —
+ * so passing the same `File` through unchanged never copies its buffer.
+ */
+export declare function transformUploadFile({ collectionSlug, file, options, pipeline, req, }: {
+    collectionSlug: string;
+    file: File;
+    options: unknown;
+    pipeline: UploadTransformer[];
+    req: PayloadRequest;
+}): Promise<File>;
+//# sourceMappingURL=transformUploadFile.d.ts.map

package/dist/uploads/transformers/transformUploadFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformUploadFile.d.ts","sourceRoot":"","sources":["../../../src/uploads/transformers/transformUploadFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,cAAc,EACd,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,GAAG,GACJ,EAAE;IACD,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,iBAAiB,EAAE,CAAA;IAC7B,GAAG,EAAE,cAAc,CAAA;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBhB"}

package/dist/uploads/transformers/transformUploadFile.js

@@ -0,0 +1,30 @@
+/**
+ * Runs one file through every eligible `transformFile` stage in declaration
+ * order. Used both for the ordinary top-level upload call (`options: undefined`)
+ * and, via the private v4 bridge's `transform` callback, once per legacy task
+ * (the main file, crop output, or a named image size) with that task's own
+ * `options`. Retains only the current accumulator — never a history array —
+ * so passing the same `File` through unchanged never copies its buffer.
+ */ export async function transformUploadFile({ collectionSlug, file, options, pipeline, req }) {
+    let accumulator = file;
+    for (const transformer of pipeline){
+        if (typeof transformer.transformFile !== 'function') {
+            continue;
+        }
+        const result = await transformer.transformFile({
+            collectionSlug,
+            file: accumulator,
+            options,
+            req
+        });
+        if (result.file) {
+            accumulator = result.file;
+        }
+        if (result.status === 'complete') {
+            return accumulator;
+        }
+    }
+    return accumulator;
+}
+
+//# sourceMappingURL=transformUploadFile.js.map

package/dist/uploads/transformers/transformUploadFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/transformers/transformUploadFile.ts"],"sourcesContent":["import type { PayloadRequest } from '../../types/index.js'\nimport type { UploadTransformer } from './types.js'\n\n/**\n * Runs one file through every eligible `transformFile` stage in declaration\n * order. Used both for the ordinary top-level upload call (`options: undefined`)\n * and, via the private v4 bridge's `transform` callback, once per legacy task\n * (the main file, crop output, or a named image size) with that task's own\n * `options`. Retains only the current accumulator — never a history array —\n * so passing the same `File` through unchanged never copies its buffer.\n */\nexport async function transformUploadFile({\n  collectionSlug,\n  file,\n  options,\n  pipeline,\n  req,\n}: {\n  collectionSlug: string\n  file: File\n  options: unknown\n  pipeline: UploadTransformer[]\n  req: PayloadRequest\n}): Promise<File> {\n  let accumulator = file\n\n  for (const transformer of pipeline) {\n    if (typeof transformer.transformFile !== 'function') {\n      continue\n    }\n\n    const result = await transformer.transformFile({\n      collectionSlug,\n      file: accumulator,\n      options,\n      req,\n    })\n\n    if (result.file) {\n      accumulator = result.file\n    }\n\n    if (result.status === 'complete') {\n      return accumulator\n    }\n  }\n\n  return accumulator\n}\n"],"names":["transformUploadFile","collectionSlug","file","options","pipeline","req","accumulator","transformer","transformFile","result","status"],"mappings":"AAGA;;;;;;;CAOC,GACD,OAAO,eAAeA,oBAAoB,EACxCC,cAAc,EACdC,IAAI,EACJC,OAAO,EACPC,QAAQ,EACRC,GAAG,EAOJ;IACC,IAAIC,cAAcJ;IAElB,KAAK,MAAMK,eAAeH,SAAU;QAClC,IAAI,OAAOG,YAAYC,aAAa,KAAK,YAAY;YACnD;QACF;QAEA,MAAMC,SAAS,MAAMF,YAAYC,aAAa,CAAC;YAC7CP;YACAC,MAAMI;YACNH;YACAE;QACF;QAEA,IAAII,OAAOP,IAAI,EAAE;YACfI,cAAcG,OAAOP,IAAI;QAC3B;QAEA,IAAIO,OAAOC,MAAM,KAAK,YAAY;YAChC,OAAOJ;QACT;IACF;IAEA,OAAOA;AACT"}

package/dist/uploads/transformers/types.d.ts

@@ -0,0 +1,71 @@
+import type { Config } from '../../config/types.js';
+import type { PayloadRequest } from '../../types/index.js';
+export type CanTransformArgs = {
+    collectionSlug: string;
+    documentID?: number | string;
+    mimeType: string;
+    operation: 'request' | 'upload';
+    req: PayloadRequest;
+};
+export type TransformFileArgs<TOptions = unknown> = {
+    collectionSlug: string;
+    file: File;
+    options: TOptions;
+    req: PayloadRequest;
+};
+export type TransformFileResult = {
+    file: File;
+    status: 'complete';
+} | {
+    file?: File;
+    status: 'continue';
+};
+export type HandleTransformRequestArgs = {
+    collectionSlug: string;
+    documentID: number | string;
+    filename: string;
+    getSourceFile: () => Promise<Response>;
+    mimeType: string;
+    req: PayloadRequest;
+};
+export type HandleTransformRequestResult = {
+    response: Response;
+    status: 'complete';
+} | {
+    response?: Response;
+    status: 'continue';
+};
+/**
+ * A capability adapter that can transform files during upload, handle dynamic
+ * file requests, or both. Configured only under `upload.transformers`.
+ */
+export type UploadTransformer = {
+    /**
+     * Inexpensive, side-effect-free routing predicate. Must not fetch the source,
+     * call an external service, or perform the transformation.
+     */
+    canTransform?: (args: CanTransformArgs) => boolean | Promise<boolean>;
+    /**
+     * Handles one stage of a dynamic transformation request.
+     */
+    handleRequest?: (args: HandleTransformRequestArgs) => Promise<HandleTransformRequestResult>;
+    /**
+     * Runs once during `buildConfig`, between the `plugins` loop and storage-adapter
+     * `init()`, for configuration validation and transformer-specific setup.
+     */
+    init?: (config: Config) => Config | Promise<Config>;
+    /**
+     * MIME patterns this transformer supports: exact values (`image/png`), a category
+     * wildcard (`image/*`), or the universal wildcard matching every type and subtype.
+     */
+    mimeTypes: string[];
+    /**
+     * Must be unique across `upload.transformers`.
+     */
+    slug: string;
+    /**
+     * One-file-in, one-file-out upload processing primitive. Never writes to storage.
+     */
+    transformFile?: (args: TransformFileArgs) => Promise<TransformFileResult>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/uploads/transformers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/uploads/transformers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,SAAS,GAAG,QAAQ,CAAA;IAC/B,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,QAAQ,GAAG,OAAO,IAAI;IAClD,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,EAAE,QAAQ,CAAA;IACjB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,UAAU,CAAA;CACnB,GACD;IACE,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,MAAM,EAAE,UAAU,CAAA;CACnB,CAAA;AAEL,MAAM,MAAM,0BAA0B,GAAG;IACvC,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAA;IACtC,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,4BAA4B,GACpC;IACE,QAAQ,EAAE,QAAQ,CAAA;IAClB,MAAM,EAAE,UAAU,CAAA;CACnB,GACD;IACE,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,MAAM,EAAE,UAAU,CAAA;CACnB,CAAA;AAEL;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACrE;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,0BAA0B,KAAK,OAAO,CAAC,4BAA4B,CAAC,CAAA;IAC3F;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnD;;;OAGG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAA;CAC1E,CAAA"}

package/dist/uploads/transformers/types.js

@@ -0,0 +1,6 @@
+/**
+ * A capability adapter that can transform files during upload, handle dynamic
+ * file requests, or both. Configured only under `upload.transformers`.
+ */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/uploads/transformers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/transformers/types.ts"],"sourcesContent":["import type { Config } from '../../config/types.js'\nimport type { PayloadRequest } from '../../types/index.js'\n\nexport type CanTransformArgs = {\n  collectionSlug: string\n  documentID?: number | string\n  mimeType: string\n  operation: 'request' | 'upload'\n  req: PayloadRequest\n}\n\nexport type TransformFileArgs<TOptions = unknown> = {\n  collectionSlug: string\n  file: File\n  options: TOptions\n  req: PayloadRequest\n}\n\nexport type TransformFileResult =\n  | {\n      file: File\n      status: 'complete'\n    }\n  | {\n      file?: File\n      status: 'continue'\n    }\n\nexport type HandleTransformRequestArgs = {\n  collectionSlug: string\n  documentID: number | string\n  filename: string\n  getSourceFile: () => Promise<Response>\n  mimeType: string\n  req: PayloadRequest\n}\n\nexport type HandleTransformRequestResult =\n  | {\n      response: Response\n      status: 'complete'\n    }\n  | {\n      response?: Response\n      status: 'continue'\n    }\n\n/**\n * A capability adapter that can transform files during upload, handle dynamic\n * file requests, or both. Configured only under `upload.transformers`.\n */\nexport type UploadTransformer = {\n  /**\n   * Inexpensive, side-effect-free routing predicate. Must not fetch the source,\n   * call an external service, or perform the transformation.\n   */\n  canTransform?: (args: CanTransformArgs) => boolean | Promise<boolean>\n  /**\n   * Handles one stage of a dynamic transformation request.\n   */\n  handleRequest?: (args: HandleTransformRequestArgs) => Promise<HandleTransformRequestResult>\n  /**\n   * Runs once during `buildConfig`, between the `plugins` loop and storage-adapter\n   * `init()`, for configuration validation and transformer-specific setup.\n   */\n  init?: (config: Config) => Config | Promise<Config>\n  /**\n   * MIME patterns this transformer supports: exact values (`image/png`), a category\n   * wildcard (`image/*`), or the universal wildcard matching every type and subtype.\n   */\n  mimeTypes: string[]\n  /**\n   * Must be unique across `upload.transformers`.\n   */\n  slug: string\n  /**\n   * One-file-in, one-file-out upload processing primitive. Never writes to storage.\n   */\n  transformFile?: (args: TransformFileArgs) => Promise<TransformFileResult>\n}\n"],"names":[],"mappings":"AA+CA;;;CAGC,GACD,WA4BC"}

package/dist/uploads/transformers/uploadTransformerBridge.d.ts

@@ -0,0 +1,48 @@
+import type { PayloadRequest } from '../../types/index.js';
+import type { UploadEdits } from '../types.js';
+/**
+ * Private v4 compatibility bridge, attached to a transformer object under this
+ * symbol. Lets the official Sharp package reproduce the current main-image and
+ * legacy `variants` upload behavior without core exposing a general persisted-
+ * variants API. Never exported from `payload` — `payload/internal` only, and
+ * never documented for third-party use.
+ */
+export declare const uploadTransformerInternal: unique symbol;
+export declare function getUploadFilePath(file: File): string | undefined;
+export declare function setUploadFilePath(file: File, filePath: string): File;
+export type UploadTransformTask<TOptions = unknown> = {
+    fieldPath: 'filename' | `variants.${string}`;
+    /** Source file for this task. Defaults to the original upload (e.g. pass the cropped main output so sizes derive from the crop). */
+    file?: File;
+    options: TOptions;
+};
+export type PreparedUploadTransformation = {
+    fieldPath: 'filename' | `variants.${string}`;
+    /** Omitted when this task was intentionally skipped (e.g. an image size too small to enlarge) — recorded with null metadata, matching the existing `variants` shape. */
+    file?: File;
+    height?: number;
+    mimeType?: string;
+    width?: number;
+};
+export type UploadTransformerInternal = {
+    /**
+     * Whether this bridge owns upload-time processing for the collection. When several
+     * transformers carry a bridge, core drives the upload through the one that owns the
+     * collection, falling back to the first bridge when none does.
+     */
+    handlesCollection?: (args: {
+        collectionSlug: string;
+    }) => boolean;
+    prepareUpload?: (args: {
+        collectionSlug: string;
+        file: File;
+        req: PayloadRequest;
+        transform: (task: UploadTransformTask) => Promise<File>;
+        uploadEdits: UploadEdits;
+    }) => Promise<PreparedUploadTransformation[]>;
+};
+export type TransformerWithInternalBridge = {
+    [uploadTransformerInternal]?: UploadTransformerInternal;
+};
+export declare function getUploadTransformerInternal(transformer: object): undefined | UploadTransformerInternal;
+//# sourceMappingURL=uploadTransformerBridge.d.ts.map

package/dist/uploads/transformers/uploadTransformerBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadTransformerBridge.d.ts","sourceRoot":"","sources":["../../../src/uploads/transformers/uploadTransformerBridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,eAAkD,CAAA;AAOxF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAEhE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAGpE;AAED,MAAM,MAAM,mBAAmB,CAAC,QAAQ,GAAG,OAAO,IAAI;IACpD,SAAS,EAAE,UAAU,GAAG,YAAY,MAAM,EAAE,CAAA;IAC5C,oIAAoI;IACpI,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,SAAS,EAAE,UAAU,GAAG,YAAY,MAAM,EAAE,CAAA;IAC5C,wKAAwK;IACxK,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAA;IACjE,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE;QACrB,cAAc,EAAE,MAAM,CAAA;QACtB,IAAI,EAAE,IAAI,CAAA;QACV,GAAG,EAAE,cAAc,CAAA;QACnB,SAAS,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACvD,WAAW,EAAE,WAAW,CAAA;KACzB,KAAK,OAAO,CAAC,4BAA4B,EAAE,CAAC,CAAA;CAC9C,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC1C,CAAC,yBAAyB,CAAC,CAAC,EAAE,yBAAyB,CAAA;CACxD,CAAA;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,MAAM,GAClB,SAAS,GAAG,yBAAyB,CAEvC"}

package/dist/uploads/transformers/uploadTransformerBridge.js

@@ -0,0 +1,22 @@
+/**
+ * Private v4 compatibility bridge, attached to a transformer object under this
+ * symbol. Lets the official Sharp package reproduce the current main-image and
+ * legacy `variants` upload behavior without core exposing a general persisted-
+ * variants API. Never exported from `payload` — `payload/internal` only, and
+ * never documented for third-party use.
+ */ export const uploadTransformerInternal = Symbol.for('payload.uploadTransformerInternal');
+const uploadFilePath = Symbol.for('payload.uploadFilePath');
+export function getUploadFilePath(file) {
+    return file[uploadFilePath];
+}
+export function setUploadFilePath(file, filePath) {
+    Object.defineProperty(file, uploadFilePath, {
+        value: filePath
+    });
+    return file;
+}
+export function getUploadTransformerInternal(transformer) {
+    return transformer[uploadTransformerInternal];
+}
+
+//# sourceMappingURL=uploadTransformerBridge.js.map

package/dist/uploads/transformers/uploadTransformerBridge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/transformers/uploadTransformerBridge.ts"],"sourcesContent":["import type { PayloadRequest } from '../../types/index.js'\nimport type { UploadEdits } from '../types.js'\n\n/**\n * Private v4 compatibility bridge, attached to a transformer object under this\n * symbol. Lets the official Sharp package reproduce the current main-image and\n * legacy `variants` upload behavior without core exposing a general persisted-\n * variants API. Never exported from `payload` — `payload/internal` only, and\n * never documented for third-party use.\n */\nexport const uploadTransformerInternal = Symbol.for('payload.uploadTransformerInternal')\nconst uploadFilePath = Symbol.for('payload.uploadFilePath')\n\ntype FileWithUploadPath = {\n  [uploadFilePath]?: string\n} & File\n\nexport function getUploadFilePath(file: File): string | undefined {\n  return (file as FileWithUploadPath)[uploadFilePath]\n}\n\nexport function setUploadFilePath(file: File, filePath: string): File {\n  Object.defineProperty(file, uploadFilePath, { value: filePath })\n  return file\n}\n\nexport type UploadTransformTask<TOptions = unknown> = {\n  fieldPath: 'filename' | `variants.${string}`\n  /** Source file for this task. Defaults to the original upload (e.g. pass the cropped main output so sizes derive from the crop). */\n  file?: File\n  options: TOptions\n}\n\nexport type PreparedUploadTransformation = {\n  fieldPath: 'filename' | `variants.${string}`\n  /** Omitted when this task was intentionally skipped (e.g. an image size too small to enlarge) — recorded with null metadata, matching the existing `variants` shape. */\n  file?: File\n  height?: number\n  mimeType?: string\n  width?: number\n}\n\nexport type UploadTransformerInternal = {\n  /**\n   * Whether this bridge owns upload-time processing for the collection. When several\n   * transformers carry a bridge, core drives the upload through the one that owns the\n   * collection, falling back to the first bridge when none does.\n   */\n  handlesCollection?: (args: { collectionSlug: string }) => boolean\n  prepareUpload?: (args: {\n    collectionSlug: string\n    file: File\n    req: PayloadRequest\n    transform: (task: UploadTransformTask) => Promise<File>\n    uploadEdits: UploadEdits\n  }) => Promise<PreparedUploadTransformation[]>\n}\n\nexport type TransformerWithInternalBridge = {\n  [uploadTransformerInternal]?: UploadTransformerInternal\n}\n\nexport function getUploadTransformerInternal(\n  transformer: object,\n): undefined | UploadTransformerInternal {\n  return (transformer as TransformerWithInternalBridge)[uploadTransformerInternal]\n}\n"],"names":["uploadTransformerInternal","Symbol","for","uploadFilePath","getUploadFilePath","file","setUploadFilePath","filePath","Object","defineProperty","value","getUploadTransformerInternal","transformer"],"mappings":"AAGA;;;;;;CAMC,GACD,OAAO,MAAMA,4BAA4BC,OAAOC,GAAG,CAAC,qCAAoC;AACxF,MAAMC,iBAAiBF,OAAOC,GAAG,CAAC;AAMlC,OAAO,SAASE,kBAAkBC,IAAU;IAC1C,OAAO,AAACA,IAA2B,CAACF,eAAe;AACrD;AAEA,OAAO,SAASG,kBAAkBD,IAAU,EAAEE,QAAgB;IAC5DC,OAAOC,cAAc,CAACJ,MAAMF,gBAAgB;QAAEO,OAAOH;IAAS;IAC9D,OAAOF;AACT;AAsCA,OAAO,SAASM,6BACdC,WAAmB;IAEnB,OAAO,AAACA,WAA6C,CAACZ,0BAA0B;AAClF"}

package/dist/uploads/transformers/validateTransformers.d.ts

@@ -0,0 +1,11 @@
+import type { UploadTransformer } from './types.js';
+/**
+ * Validates `upload.transformers` at startup: unique, non-empty slugs; at least one
+ * well-formed MIME pattern per transformer; and every declared capability is a function.
+ * Called once for the authored list and again after every transformer `init()` runs,
+ * since `init()` may return a mutated transformers list.
+ */
+export declare function validateTransformers({ transformers, }: {
+    transformers: UploadTransformer[];
+}): void;
+//# sourceMappingURL=validateTransformers.d.ts.map

package/dist/uploads/transformers/validateTransformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateTransformers.d.ts","sourceRoot":"","sources":["../../../src/uploads/transformers/validateTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AA4BnD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,YAAY,GACb,EAAE;IACD,YAAY,EAAE,iBAAiB,EAAE,CAAA;CAClC,GAAG,IAAI,CAiDP"}

package/dist/uploads/transformers/validateTransformers.js

@@ -0,0 +1,67 @@
+const MIME_TOKEN_PATTERN = /^[\w!#$&^.+-]+$/;
+const CAPABILITY_KEYS = [
+    'init',
+    'canTransform',
+    'transformFile',
+    'handleRequest'
+];
+function isValidMimeTypePattern(pattern) {
+    if (typeof pattern !== 'string' || pattern.length === 0) {
+        return false;
+    }
+    if (pattern === '*/*') {
+        return true;
+    }
+    const [type, subtype] = pattern.split('/');
+    if (type === undefined || subtype === undefined || pattern.split('/').length !== 2) {
+        return false;
+    }
+    if (!MIME_TOKEN_PATTERN.test(type)) {
+        return false;
+    }
+    return subtype === '*' || MIME_TOKEN_PATTERN.test(subtype);
+}
+/**
+ * Validates `upload.transformers` at startup: unique, non-empty slugs; at least one
+ * well-formed MIME pattern per transformer; and every declared capability is a function.
+ * Called once for the authored list and again after every transformer `init()` runs,
+ * since `init()` may return a mutated transformers list.
+ */ export function validateTransformers({ transformers }) {
+    const errors = [];
+    const slugCounts = new Map();
+    transformers.forEach((transformer, index)=>{
+        const label = `upload.transformers[${index}]`;
+        const slug = transformer?.slug;
+        if (typeof slug !== 'string' || slug.trim().length === 0) {
+            errors.push(`${label} must have a non-empty \`slug\`.`);
+        } else {
+            slugCounts.set(slug, (slugCounts.get(slug) ?? 0) + 1);
+        }
+        const identifier = typeof slug === 'string' && slug.length > 0 ? `"${slug}"` : label;
+        if (!Array.isArray(transformer?.mimeTypes) || transformer.mimeTypes.length === 0) {
+            errors.push(`Transformer ${identifier} must declare at least one MIME type in \`mimeTypes\`.`);
+        } else {
+            transformer.mimeTypes.forEach((mimeType)=>{
+                if (!isValidMimeTypePattern(mimeType)) {
+                    errors.push(`Transformer ${identifier} has an invalid MIME type pattern: "${String(mimeType)}". ` + `Use an exact value (e.g. "image/png"), a category wildcard (e.g. "image/*"), or "*/*".`);
+                }
+            });
+        }
+        for (const capability of CAPABILITY_KEYS){
+            const value = transformer?.[capability];
+            if (value !== undefined && typeof value !== 'function') {
+                errors.push(`Transformer ${identifier}'s \`${capability}\` must be a function.`);
+            }
+        }
+    });
+    for (const [slug, count] of slugCounts){
+        if (count > 1) {
+            errors.push(`Duplicate upload transformer slug: "${slug}" is used ${count} times. Every transformer must have a unique \`slug\`.`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid \`upload.transformers\` configuration:\n${errors.join('\n')}`);
+    }
+}
+
+//# sourceMappingURL=validateTransformers.js.map

package/dist/uploads/transformers/validateTransformers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/transformers/validateTransformers.ts"],"sourcesContent":["import type { UploadTransformer } from './types.js'\n\nconst MIME_TOKEN_PATTERN = /^[\\w!#$&^.+-]+$/\n\nconst CAPABILITY_KEYS = ['init', 'canTransform', 'transformFile', 'handleRequest'] as const\n\nfunction isValidMimeTypePattern(pattern: unknown): boolean {\n  if (typeof pattern !== 'string' || pattern.length === 0) {\n    return false\n  }\n\n  if (pattern === '*/*') {\n    return true\n  }\n\n  const [type, subtype] = pattern.split('/')\n\n  if (type === undefined || subtype === undefined || pattern.split('/').length !== 2) {\n    return false\n  }\n\n  if (!MIME_TOKEN_PATTERN.test(type)) {\n    return false\n  }\n\n  return subtype === '*' || MIME_TOKEN_PATTERN.test(subtype)\n}\n\n/**\n * Validates `upload.transformers` at startup: unique, non-empty slugs; at least one\n * well-formed MIME pattern per transformer; and every declared capability is a function.\n * Called once for the authored list and again after every transformer `init()` runs,\n * since `init()` may return a mutated transformers list.\n */\nexport function validateTransformers({\n  transformers,\n}: {\n  transformers: UploadTransformer[]\n}): void {\n  const errors: string[] = []\n  const slugCounts = new Map<string, number>()\n\n  transformers.forEach((transformer, index) => {\n    const label = `upload.transformers[${index}]`\n    const slug = transformer?.slug\n\n    if (typeof slug !== 'string' || slug.trim().length === 0) {\n      errors.push(`${label} must have a non-empty \\`slug\\`.`)\n    } else {\n      slugCounts.set(slug, (slugCounts.get(slug) ?? 0) + 1)\n    }\n\n    const identifier = typeof slug === 'string' && slug.length > 0 ? `\"${slug}\"` : label\n\n    if (!Array.isArray(transformer?.mimeTypes) || transformer.mimeTypes.length === 0) {\n      errors.push(`Transformer ${identifier} must declare at least one MIME type in \\`mimeTypes\\`.`)\n    } else {\n      transformer.mimeTypes.forEach((mimeType) => {\n        if (!isValidMimeTypePattern(mimeType)) {\n          errors.push(\n            `Transformer ${identifier} has an invalid MIME type pattern: \"${String(mimeType)}\". ` +\n              `Use an exact value (e.g. \"image/png\"), a category wildcard (e.g. \"image/*\"), or \"*/*\".`,\n          )\n        }\n      })\n    }\n\n    for (const capability of CAPABILITY_KEYS) {\n      const value = transformer?.[capability]\n\n      if (value !== undefined && typeof value !== 'function') {\n        errors.push(`Transformer ${identifier}'s \\`${capability}\\` must be a function.`)\n      }\n    }\n  })\n\n  for (const [slug, count] of slugCounts) {\n    if (count > 1) {\n      errors.push(\n        `Duplicate upload transformer slug: \"${slug}\" is used ${count} times. Every transformer must have a unique \\`slug\\`.`,\n      )\n    }\n  }\n\n  if (errors.length > 0) {\n    throw new Error(`Invalid \\`upload.transformers\\` configuration:\\n${errors.join('\\n')}`)\n  }\n}\n"],"names":["MIME_TOKEN_PATTERN","CAPABILITY_KEYS","isValidMimeTypePattern","pattern","length","type","subtype","split","undefined","test","validateTransformers","transformers","errors","slugCounts","Map","forEach","transformer","index","label","slug","trim","push","set","get","identifier","Array","isArray","mimeTypes","mimeType","String","capability","value","count","Error","join"],"mappings":"AAEA,MAAMA,qBAAqB;AAE3B,MAAMC,kBAAkB;IAAC;IAAQ;IAAgB;IAAiB;CAAgB;AAElF,SAASC,uBAAuBC,OAAgB;IAC9C,IAAI,OAAOA,YAAY,YAAYA,QAAQC,MAAM,KAAK,GAAG;QACvD,OAAO;IACT;IAEA,IAAID,YAAY,OAAO;QACrB,OAAO;IACT;IAEA,MAAM,CAACE,MAAMC,QAAQ,GAAGH,QAAQI,KAAK,CAAC;IAEtC,IAAIF,SAASG,aAAaF,YAAYE,aAAaL,QAAQI,KAAK,CAAC,KAAKH,MAAM,KAAK,GAAG;QAClF,OAAO;IACT;IAEA,IAAI,CAACJ,mBAAmBS,IAAI,CAACJ,OAAO;QAClC,OAAO;IACT;IAEA,OAAOC,YAAY,OAAON,mBAAmBS,IAAI,CAACH;AACpD;AAEA;;;;;CAKC,GACD,OAAO,SAASI,qBAAqB,EACnCC,YAAY,EAGb;IACC,MAAMC,SAAmB,EAAE;IAC3B,MAAMC,aAAa,IAAIC;IAEvBH,aAAaI,OAAO,CAAC,CAACC,aAAaC;QACjC,MAAMC,QAAQ,CAAC,oBAAoB,EAAED,MAAM,CAAC,CAAC;QAC7C,MAAME,OAAOH,aAAaG;QAE1B,IAAI,OAAOA,SAAS,YAAYA,KAAKC,IAAI,GAAGhB,MAAM,KAAK,GAAG;YACxDQ,OAAOS,IAAI,CAAC,GAAGH,MAAM,gCAAgC,CAAC;QACxD,OAAO;YACLL,WAAWS,GAAG,CAACH,MAAM,AAACN,CAAAA,WAAWU,GAAG,CAACJ,SAAS,CAAA,IAAK;QACrD;QAEA,MAAMK,aAAa,OAAOL,SAAS,YAAYA,KAAKf,MAAM,GAAG,IAAI,CAAC,CAAC,EAAEe,KAAK,CAAC,CAAC,GAAGD;QAE/E,IAAI,CAACO,MAAMC,OAAO,CAACV,aAAaW,cAAcX,YAAYW,SAAS,CAACvB,MAAM,KAAK,GAAG;YAChFQ,OAAOS,IAAI,CAAC,CAAC,YAAY,EAAEG,WAAW,sDAAsD,CAAC;QAC/F,OAAO;YACLR,YAAYW,SAAS,CAACZ,OAAO,CAAC,CAACa;gBAC7B,IAAI,CAAC1B,uBAAuB0B,WAAW;oBACrChB,OAAOS,IAAI,CACT,CAAC,YAAY,EAAEG,WAAW,oCAAoC,EAAEK,OAAOD,UAAU,GAAG,CAAC,GACnF,CAAC,sFAAsF,CAAC;gBAE9F;YACF;QACF;QAEA,KAAK,MAAME,cAAc7B,gBAAiB;YACxC,MAAM8B,QAAQf,aAAa,CAACc,WAAW;YAEvC,IAAIC,UAAUvB,aAAa,OAAOuB,UAAU,YAAY;gBACtDnB,OAAOS,IAAI,CAAC,CAAC,YAAY,EAAEG,WAAW,KAAK,EAAEM,WAAW,sBAAsB,CAAC;YACjF;QACF;IACF;IAEA,KAAK,MAAM,CAACX,MAAMa,MAAM,IAAInB,WAAY;QACtC,IAAImB,QAAQ,GAAG;YACbpB,OAAOS,IAAI,CACT,CAAC,oCAAoC,EAAEF,KAAK,UAAU,EAAEa,MAAM,sDAAsD,CAAC;QAEzH;IACF;IAEA,IAAIpB,OAAOR,MAAM,GAAG,GAAG;QACrB,MAAM,IAAI6B,MAAM,CAAC,gDAAgD,EAAErB,OAAOsB,IAAI,CAAC,OAAO;IACxF;AACF"}

package/dist/uploads/transformers/withFileTransformAccessContext.d.ts

@@ -0,0 +1,13 @@
+import type { PayloadRequest } from '../../types/index.js';
+/**
+ * Sets `req.fileTransform = true` for the duration of `callback()` when
+ * `isTransform` is `true`, then restores the previous value afterward, even
+ * if `callback()` throws. Ordinary reads (`isTransform: false`) never see the
+ * flag set.
+ */
+export declare function withFileTransformAccessContext<T>({ callback, isTransform, req, }: {
+    callback: () => Promise<T> | T;
+    isTransform: boolean;
+    req: PayloadRequest;
+}): Promise<T>;
+//# sourceMappingURL=withFileTransformAccessContext.d.ts.map

package/dist/uploads/transformers/withFileTransformAccessContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFileTransformAccessContext.d.ts","sourceRoot":"","sources":["../../../src/uploads/transformers/withFileTransformAccessContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D;;;;;GAKG;AACH,wBAAsB,8BAA8B,CAAC,CAAC,EAAE,EACtD,QAAQ,EACR,WAAW,EACX,GAAG,GACJ,EAAE;IACD,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;IAC9B,WAAW,EAAE,OAAO,CAAA;IACpB,GAAG,EAAE,cAAc,CAAA;CACpB,GAAG,OAAO,CAAC,CAAC,CAAC,CAYb"}

package/dist/uploads/transformers/withFileTransformAccessContext.js

@@ -0,0 +1,18 @@
+/**
+ * Sets `req.fileTransform = true` for the duration of `callback()` when
+ * `isTransform` is `true`, then restores the previous value afterward, even
+ * if `callback()` throws. Ordinary reads (`isTransform: false`) never see the
+ * flag set.
+ */ export async function withFileTransformAccessContext({ callback, isTransform, req }) {
+    const previousFileTransform = req.fileTransform;
+    if (isTransform) {
+        req.fileTransform = true;
+    }
+    try {
+        return await callback();
+    } finally{
+        req.fileTransform = previousFileTransform;
+    }
+}
+
+//# sourceMappingURL=withFileTransformAccessContext.js.map

package/dist/uploads/transformers/withFileTransformAccessContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/transformers/withFileTransformAccessContext.ts"],"sourcesContent":["import type { PayloadRequest } from '../../types/index.js'\n\n/**\n * Sets `req.fileTransform = true` for the duration of `callback()` when\n * `isTransform` is `true`, then restores the previous value afterward, even\n * if `callback()` throws. Ordinary reads (`isTransform: false`) never see the\n * flag set.\n */\nexport async function withFileTransformAccessContext<T>({\n  callback,\n  isTransform,\n  req,\n}: {\n  callback: () => Promise<T> | T\n  isTransform: boolean\n  req: PayloadRequest\n}): Promise<T> {\n  const previousFileTransform = req.fileTransform\n\n  if (isTransform) {\n    req.fileTransform = true\n  }\n\n  try {\n    return await callback()\n  } finally {\n    req.fileTransform = previousFileTransform\n  }\n}\n"],"names":["withFileTransformAccessContext","callback","isTransform","req","previousFileTransform","fileTransform"],"mappings":"AAEA;;;;;CAKC,GACD,OAAO,eAAeA,+BAAkC,EACtDC,QAAQ,EACRC,WAAW,EACXC,GAAG,EAKJ;IACC,MAAMC,wBAAwBD,IAAIE,aAAa;IAE/C,IAAIH,aAAa;QACfC,IAAIE,aAAa,GAAG;IACtB;IAEA,IAAI;QACF,OAAO,MAAMJ;IACf,SAAU;QACRE,IAAIE,aAAa,GAAGD;IACtB;AACF"}