n8n-nodes-base 2.34.2 → 2.35.0

package/dist/nodes/Kafka/v2/consumer/DataEmitter.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXECUTION_TIMEOUT_SECONDS = void 0;
+exports.createDataEmitter = createDataEmitter;
+const ensure_error_1 = require("@n8n/utils/errors/ensure-error");
+const sleep_1 = require("@n8n/utils/sleep");
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../../utils");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/**
+ * The wait an absent workflow execution timeout falls back to. Exported because
+ * the consumer's processing deadline has to agree with it: if the emitter waits
+ * an hour for an execution the broker fenced ten minutes in, the message is
+ * redelivered while n8n still thinks the run owns it.
+ */
+exports.DEFAULT_EXECUTION_TIMEOUT_SECONDS = 3600;
+// Every hand-off returns one of these two, so they are shared rather than
+// rebuilt. Frozen because a caller mutating the one it was handed would change
+// the verdict every later hand-off gets. `readonly` on the field catches that
+// at compile time; the freeze covers callers outside this package's types.
+const ADVANCE = Object.freeze({ mayAdvance: true });
+const HOLD_BACK = Object.freeze({ mayAdvance: false });
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/**
+ * Builds the function that starts an execution for a chunk of items and decides
+ * whether its offsets may advance. `mayAdvance: false` means the caller must not
+ * record the chunk as done, so Kafka delivers it again.
+ *
+ * `immediately` never waits, which is at-most-once. The other three wait for the
+ * execution and are at-least-once. This mirrors v1's `configureDataEmitter`,
+ * with the mode and its inputs resolved by the caller rather than read from node
+ * parameters here.
+ * @param ctx - Trigger context used to emit and log
+ * @param options - Resolved offset mode and its inputs
+ * @param closeSignal - Aborted on teardown, so a wait never outlives the trigger
+ */
+function createDataEmitter(ctx, options, closeSignal) {
+    return options.resolveOffsetMode === 'immediately'
+        ? createImmediateEmitter(ctx, closeSignal)
+        : createAwaitingEmitter(ctx, options, closeSignal);
+}
+// ---------------------------------------------------------------------------
+// The two emitter shapes
+// ---------------------------------------------------------------------------
+/** Hands the chunk over and advances at once, without waiting for the run. */
+function createImmediateEmitter(ctx, closeSignal) {
+    return async (items) => {
+        // Never start an execution once the trigger is closing.
+        if (closeSignal.aborted)
+            return HOLD_BACK;
+        ctx.emit([items]);
+        return ADVANCE;
+    };
+}
+/** Waits for the execution and advances only if its status is allowed. */
+function createAwaitingEmitter(ctx, options, closeSignal) {
+    const allowedStatuses = resolveAllowedStatuses(ctx, options);
+    const deadlineSeconds = options.executionTimeoutSeconds ?? exports.DEFAULT_EXECUTION_TIMEOUT_SECONDS;
+    const errorRetryDelay = (0, utils_1.resolveRetryDelay)(options.errorRetryDelay, ctx.logger);
+    // Two views of closing, because the two waits below want different things.
+    // The rejecting one ends the wait for an execution with a reason, which is
+    // what gets logged. The quiet one only needs to stop the retry pause, and
+    // deriving it here also handles the rejection, so the one that loses the race
+    // is not reported as an unhandled rejection.
+    const closedWithReason = rejectOnClose(closeSignal);
+    const closedQuietly = closedWithReason.catch(() => undefined);
+    return async (items) => {
+        if (closeSignal.aborted)
+            return HOLD_BACK;
+        try {
+            const run = await awaitExecution(ctx, items, deadlineSeconds, closedWithReason);
+            if (allowedStatuses && !allowedStatuses.includes(run.status)) {
+                throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Execution status is not allowed for resolving offsets, current status: ${run.status}`);
+            }
+            return ADVANCE;
+        }
+        catch (caught) {
+            // The retry backoff must not delay teardown.
+            if (!closeSignal.aborted)
+                await Promise.race([(0, sleep_1.sleep)(errorRetryDelay), closedQuietly]);
+            const error = (0, ensure_error_1.ensureError)(caught);
+            // Teardown cancelling an in-flight execution is expected, not a failure,
+            // so it must not surface as an error in the log.
+            if (closeSignal.aborted)
+                ctx.logger.debug(error.message, { error });
+            else
+                ctx.logger.error(error.message, { error });
+            return HOLD_BACK;
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** The statuses that let the offset advance, or undefined when any status does. */
+function resolveAllowedStatuses(ctx, options) {
+    if (options.resolveOffsetMode === 'onCompletion')
+        return undefined;
+    if (options.resolveOffsetMode === 'onSuccess')
+        return ['success'];
+    if (!options.allowedStatuses?.length) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'At least one execution status must be selected to resolve offsets on selected statuses.');
+    }
+    return options.allowedStatuses;
+}
+/** Rejects when the trigger closes, so a wait ends with a reason rather than hanging. */
+async function rejectOnClose(closeSignal) {
+    return await new Promise((_, reject) => {
+        const fail = () => reject(new n8n_workflow_1.OperationalError('Trigger closed before the execution finished, offsets not resolved.'));
+        // The abort event fires once. If it already fired, no listener would run.
+        if (closeSignal.aborted)
+            return fail();
+        closeSignal.addEventListener('abort', fail, { once: true });
+    });
+}
+/**
+ * Starts one execution and waits for it, bounded by the workflow's timeout and
+ * by close.
+ * @param deadlineSeconds - Zero or less means unbounded. n8n treats a workflow
+ * timeout of <= 0 that way (workflow-execute-additional-data.ts:255), and handing
+ * it to setTimeout would fire on the next tick and fail every hand-off. A
+ * deadline too large for a timer is treated the same way, for the same reason.
+ */
+async function awaitExecution(ctx, items, deadlineSeconds, closedWithReason) {
+    const response = ctx.helpers.createDeferredPromise();
+    ctx.emit([items], undefined, response);
+    const finished = Promise.race([response.promise, closedWithReason]);
+    if (deadlineSeconds <= 0)
+        return await finished;
+    // Past the 32-bit timer limit setTimeout fires after 1ms instead of waiting,
+    // which would fail every hand-off rather than time out a slow one. A deadline
+    // of 24 days or more is unbounded in practice, so treat it as such.
+    const deadlineMs = deadlineSeconds * 1000;
+    if (deadlineMs > utils_1.MAX_TIMER_DELAY_MS)
+        return await finished;
+    let timer;
+    try {
+        return await Promise.race([
+            finished,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new n8n_workflow_1.NodeOperationError(ctx.getNode(), `Execution took longer than the configured workflow timeout of ${deadlineSeconds} seconds to complete, offsets not resolved.`)), deadlineMs);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=DataEmitter.js.map

package/dist/nodes/Kafka/v2/consumer/DataEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataEmitter.js","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/DataEmitter.ts"],"names":[],"mappings":"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"}

package/dist/nodes/Kafka/v2/consumer/MessageParser.d.ts

@@ -0,0 +1,23 @@
+import type { KafkaJS } from '@confluentinc/kafka-javascript';
+import type { SchemaRegistry } from '@kafkajs/confluent-schema-registry';
+import type { INodeExecutionData, ITriggerFunctions, Logger } from 'n8n-workflow';
+/** The subset of trigger options that changes the parsed item shape. */
+export interface KafkaMessageParserOptions {
+    jsonParseMessage?: boolean;
+    keepBinaryData?: boolean;
+    onlyMessage?: boolean;
+    returnHeaders?: boolean;
+}
+export type KafkaMessageParser = (message: KafkaJS.KafkaMessage, topic: string) => Promise<INodeExecutionData>;
+/**
+ * Builds the parser that turns a library message into the item a workflow
+ * receives. The output shape is v1's, deliberately: `{ json: { message, topic,
+ * headers? }, binary? }`. The message key and timestamp stay absent — exposing
+ * them would be a behaviour change, not a migration.
+ * @param options - The trigger options that affect the item shape
+ * @param logger - Logger used for the warn-and-continue paths
+ * @param registry - Schema Registry client, when the user enabled decoding
+ * @param prepareBinaryData - Helper used to attach the raw value as binary data
+ */
+export declare function createMessageParser(options: KafkaMessageParserOptions, logger: Logger, registry: SchemaRegistry | undefined, prepareBinaryData: ITriggerFunctions['helpers']['prepareBinaryData']): KafkaMessageParser;
+//# sourceMappingURL=MessageParser.d.ts.map

package/dist/nodes/Kafka/v2/consumer/MessageParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageParser.d.ts","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/MessageParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAIX,kBAAkB,EAClB,iBAAiB,EACjB,MAAM,EACN,MAAM,cAAc,CAAC;AAQtB,wEAAwE;AACxE,MAAM,WAAW,yBAAyB;IACzC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAChC,OAAO,EAAE,OAAO,CAAC,YAAY,EAC7B,KAAK,EAAE,MAAM,KACT,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAmBjC;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,yBAAyB,EAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,iBAAiB,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC,mBAAmB,CAAC,GAClE,kBAAkB,CAyEpB"}

package/dist/nodes/Kafka/v2/consumer/MessageParser.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageParser = createMessageParser;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../../utils");
+/**
+ * Renders one Kafka header value the way v1 did: a Buffer decoded as UTF-8, an
+ * array joined with commas, a missing value as an empty string. v1 called
+ * `.toString('utf8')` on whatever kafkajs handed it; the new library also allows
+ * plain strings there, so the cases are spelled out instead.
+ */
+function headerToString(value) {
+    if (value === undefined)
+        return '';
+    if (Buffer.isBuffer(value))
+        return value.toString('utf8');
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => (Buffer.isBuffer(entry) ? entry.toString('utf8') : entry))
+            .join(',');
+    }
+    return value;
+}
+/**
+ * Builds the parser that turns a library message into the item a workflow
+ * receives. The output shape is v1's, deliberately: `{ json: { message, topic,
+ * headers? }, binary? }`. The message key and timestamp stay absent — exposing
+ * them would be a behaviour change, not a migration.
+ * @param options - The trigger options that affect the item shape
+ * @param logger - Logger used for the warn-and-continue paths
+ * @param registry - Schema Registry client, when the user enabled decoding
+ * @param prepareBinaryData - Helper used to attach the raw value as binary data
+ */
+function createMessageParser(options, logger, registry, prepareBinaryData) {
+    return async (message, topic) => {
+        let data = {};
+        let value = message.value?.toString();
+        const binary = {};
+        if (options.jsonParseMessage) {
+            try {
+                value = (0, n8n_workflow_1.jsonParse)(value);
+            }
+            catch (error) {
+                logger.warn('Could not parse message to JSON, returning as string', { error });
+            }
+        }
+        if (registry && message.value) {
+            try {
+                value = await registry.decode(message.value);
+            }
+            catch (error) {
+                // Deliberately fatal, unlike v1, which warns and hands the workflow the
+                // raw bytes. An undecoded Avro value is a magic byte, a schema id and
+                // binary rendered through UTF-8: unusable downstream, and v1 commits the
+                // offset anyway, so the message is gone for good. Measured against a real
+                // broker: stop the registry, consume, restart it, rejoin the same group,
+                // and the message never comes back.
+                //
+                // Throwing hands it to the consume loop, which paces a retry and leaves
+                // the chunk unresolved, so Kafka redelivers it and the message survives
+                // until the registry is healthy again. The partition stalls meanwhile,
+                // which is the visible, recoverable failure we want in place of silent
+                // corruption. A JSON parse failure above stays a warning: a message that
+                // is not JSON is a legitimate case and the string is still usable.
+                const sanitized = (0, utils_1.sanitizeRegistryError)(error);
+                logger.error('Could not decode message with Schema Registry, leaving it unread', sanitized);
+                // Sanitized, and deliberately without the original as `cause`. A registry
+                // error message can carry the URL it was built from, userinfo included,
+                // and the consume loop logs whatever this throws when it decides to leave
+                // the chunk unresolved. Rethrowing the raw error, or attaching it, would
+                // put the credential back in the log the line above just scrubbed.
+                throw new n8n_workflow_1.OperationalError(sanitized.message);
+            }
+        }
+        if (options.keepBinaryData && message.value) {
+            binary.data = await prepareBinaryData(message.value, 'message', 'application/octet-stream');
+        }
+        if (options.returnHeaders) {
+            // Unconditional, and empty when the message carries none: kafkajs always
+            // handed v1 a headers object, the new library leaves it undefined, and the
+            // item must not gain or lose the key depending on the library.
+            data.headers = Object.fromEntries(Object.entries(message.headers ?? {}).map(([headerKey, headerValue]) => [
+                headerKey,
+                headerToString(headerValue),
+            ]));
+        }
+        data.message = value;
+        data.topic = topic;
+        if (options.onlyMessage) {
+            // Matches v1: the parsed value replaces the whole item body, even when it
+            // is not an object.
+            data = value;
+        }
+        if (options.keepBinaryData && Object.keys(binary).length) {
+            return { json: data, binary };
+        }
+        return { json: data };
+    };
+}
+//# sourceMappingURL=MessageParser.js.map

package/dist/nodes/Kafka/v2/consumer/MessageParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageParser.js","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/MessageParser.ts"],"names":[],"mappings":";;;AAUA,+CAA2D;AAE3D,uCAAoD;AAkBpD;;;;;GAKG;AACH,SAAS,cAAc,CAAC,KAA+B;IACtD,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,EAAE,CAAC;IACnC,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK;aACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;aACzE,IAAI,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,6BACC,OAAkC,EAClC,MAAc,EACd,QAAoC,EACpC,iBAAoE;IAEpE,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE;QAC/B,IAAI,IAAI,GAAgB,EAAE,CAAC;QAC3B,IAAI,KAAK,GAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;QACnD,MAAM,MAAM,GAAmB,EAAE,CAAC;QAElC,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAC9B,IAAI,CAAC;gBACJ,KAAK,GAAG,IAAA,wBAAS,EAAc,KAAe,CAAC,CAAC;YACjD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,MAAM,CAAC,IAAI,CAAC,sDAAsD,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YAChF,CAAC;QACF,CAAC;QAED,IAAI,QAAQ,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACJ,KAAK,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC9C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,wEAAwE;gBACxE,sEAAsE;gBACtE,yEAAyE;gBACzE,0EAA0E;gBAC1E,yEAAyE;gBACzE,oCAAoC;gBACpC,EAAE;gBACF,wEAAwE;gBACxE,wEAAwE;gBACxE,uEAAuE;gBACvE,uEAAuE;gBACvE,yEAAyE;gBACzE,mEAAmE;gBACnE,MAAM,SAAS,GAAG,IAAA,6BAAqB,EAAC,KAAK,CAAC,CAAC;gBAC/C,MAAM,CAAC,KAAK,CAAC,kEAAkE,EAAE,SAAS,CAAC,CAAC;gBAC5F,0EAA0E;gBAC1E,wEAAwE;gBACxE,0EAA0E;gBAC1E,yEAAyE;gBACzE,mEAAmE;gBACnE,MAAM,IAAI,+BAAgB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YAC/C,CAAC;QACF,CAAC;QAED,IAAI,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YAC7C,MAAM,CAAC,IAAI,GAAG,MAAM,iBAAiB,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,0BAA0B,CAAC,CAAC;QAC7F,CAAC;QAED,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YAC3B,yEAAyE;YACzE,2EAA2E;YAC3E,+DAA+D;YAC/D,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,WAAW,CAChC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC;gBACvE,SAAS;gBACT,cAAc,CAAC,WAAW,CAAC;aAC3B,CAAC,CACF,CAAC;QACH,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YACzB,0EAA0E;YAC1E,oBAAoB;YACpB,IAAI,GAAG,KAAoB,CAAC;QAC7B,CAAC;QAED,IAAI,OAAO,CAAC,cAAc,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;YAC1D,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC/B,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACvB,CAAC,CAAC;AACH,CAAC"}

package/dist/nodes/Kafka/v2/consumer/index.d.ts

@@ -0,0 +1,7 @@
+export { consumeTopic, DEFAULT_BATCH_SIZE, DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY, } from './ConsumeTopic';
+export type { ConsumeTopicOptions, KafkaConsumerHandle } from './ConsumeTopic';
+export { createDataEmitter, DEFAULT_EXECUTION_TIMEOUT_SECONDS } from './DataEmitter';
+export type { DataEmitter, DataEmitterContext, DataEmitterOptions, OffsetVerdict, ResolveOffsetMode, } from './DataEmitter';
+export { createMessageParser } from './MessageParser';
+export type { KafkaMessageParser, KafkaMessageParserOptions } from './MessageParser';
+//# sourceMappingURL=index.d.ts.map

package/dist/nodes/Kafka/v2/consumer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,YAAY,EACZ,kBAAkB,EAClB,wCAAwC,GACxC,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,iCAAiC,EAAE,MAAM,eAAe,CAAC;AACrF,YAAY,EACX,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,iBAAiB,GACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/nodes/Kafka/v2/consumer/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageParser = exports.DEFAULT_EXECUTION_TIMEOUT_SECONDS = exports.createDataEmitter = exports.DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY = exports.DEFAULT_BATCH_SIZE = exports.consumeTopic = void 0;
+var ConsumeTopic_1 = require("./ConsumeTopic");
+Object.defineProperty(exports, "consumeTopic", { enumerable: true, get: function () { return ConsumeTopic_1.consumeTopic; } });
+Object.defineProperty(exports, "DEFAULT_BATCH_SIZE", { enumerable: true, get: function () { return ConsumeTopic_1.DEFAULT_BATCH_SIZE; } });
+Object.defineProperty(exports, "DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY", { enumerable: true, get: function () { return ConsumeTopic_1.DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY; } });
+var DataEmitter_1 = require("./DataEmitter");
+Object.defineProperty(exports, "createDataEmitter", { enumerable: true, get: function () { return DataEmitter_1.createDataEmitter; } });
+Object.defineProperty(exports, "DEFAULT_EXECUTION_TIMEOUT_SECONDS", { enumerable: true, get: function () { return DataEmitter_1.DEFAULT_EXECUTION_TIMEOUT_SECONDS; } });
+var MessageParser_1 = require("./MessageParser");
+Object.defineProperty(exports, "createMessageParser", { enumerable: true, get: function () { return MessageParser_1.createMessageParser; } });
+//# sourceMappingURL=index.js.map

package/dist/nodes/Kafka/v2/consumer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/consumer/index.ts"],"names":[],"mappings":";;;AAAA,+CAIwB;AAHvB,4GAAA,YAAY,OAAA;AACZ,kHAAA,kBAAkB,OAAA;AAClB,wIAAA,wCAAwC,OAAA;AAGzC,6CAAqF;AAA5E,gHAAA,iBAAiB,OAAA;AAAE,gIAAA,iCAAiC,OAAA;AAQ7D,iDAAsD;AAA7C,oHAAA,mBAAmB,OAAA"}

package/dist/nodes/Kafka/v2/transport/LibraryLogger.d.ts

@@ -0,0 +1,18 @@
+import type { KafkaJS } from '@confluentinc/kafka-javascript';
+import type { Logger } from 'n8n-workflow';
+/** Called with an error the consumer will not recover from without intervention. */
+export type FatalErrorHandler = (error: Error) => void;
+/**
+ * Adapts n8n's logger to the one the Kafka library expects, and watches its
+ * error output for conditions worth surfacing.
+ *
+ * Two problems solved at once. The library's default logger writes to process
+ * stdout, outside n8n's logger, which is why the client otherwise has to pin
+ * its level to ERROR just to stay quiet. And there is no error event to attach
+ * to, so the log stream is the only place a fatal condition is visible.
+ * @param logger - The node's logger, which receives whatever the library says at
+ * or above the level the library itself asks for
+ * @param onFatalError - Called once per non-recoverable error seen
+ */
+export declare function createLibraryLogger(logger: Logger, onFatalError?: FatalErrorHandler): KafkaJS.Logger;
+//# sourceMappingURL=LibraryLogger.d.ts.map

package/dist/nodes/Kafka/v2/transport/LibraryLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LibraryLogger.d.ts","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/transport/LibraryLogger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAyB3C,oFAAoF;AACpF,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAgBvD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,iBAAiB,GAC9B,OAAO,CAAC,MAAM,CA0ChB"}

package/dist/nodes/Kafka/v2/transport/LibraryLogger.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLibraryLogger = createLibraryLogger;
+const n8n_workflow_1 = require("n8n-workflow");
+/**
+ * Conditions librdkafka will never recover from on its own, so the trigger has
+ * to stop waiting and tell n8n. Everything else is left to its automatic retry,
+ * which the ENT-8 findings (section 8) describe as always on and not
+ * configurable.
+ *
+ * Deliberately short. A false positive restarts a healthy trigger, which is
+ * worse than staying quiet, so anything that might resolve by itself is absent:
+ * an unreachable broker, a leader election, an unknown topic that is about to be
+ * created.
+ *
+ * Matching on the message is forced on us. The kafkaJS compatibility layer keeps
+ * no error code by the time it reaches a logger (`_consumer.js` builds the entry
+ * from `err.message` alone) and exposes no error event, so this is the only hook
+ * there is. v1 does the same thing in `toUserFacingConsumerError`.
+ */
+const NON_RECOVERABLE = [/authorization failed/i, /authentication fail/i];
+function isNonRecoverable(message) {
+    return NON_RECOVERABLE.some((pattern) => pattern.test(message));
+}
+/**
+ * The library's `logLevel` values, repeated as plain numbers because only
+ * `transport/client.ts` may import the library at runtime and these are needed
+ * to compare against the level handed to `setLogLevel`. Kept in the library's
+ * order, where a higher number is more verbose (`_common.js:66`).
+ */
+const LEVEL = {
+    NOTHING: 0,
+    ERROR: 1,
+    WARN: 2,
+    INFO: 3,
+    DEBUG: 4,
+};
+/**
+ * Adapts n8n's logger to the one the Kafka library expects, and watches its
+ * error output for conditions worth surfacing.
+ *
+ * Two problems solved at once. The library's default logger writes to process
+ * stdout, outside n8n's logger, which is why the client otherwise has to pin
+ * its level to ERROR just to stay quiet. And there is no error event to attach
+ * to, so the log stream is the only place a fatal condition is visible.
+ * @param logger - The node's logger, which receives whatever the library says at
+ * or above the level the library itself asks for
+ * @param onFatalError - Called once per non-recoverable error seen
+ */
+function createLibraryLogger(logger, onFatalError) {
+    const meta = (extra) => ({ kafka: { ...extra } });
+    // The library does no level filtering of its own. It resolves a level from
+    // the client config and hands it over, expecting the logger to drop anything
+    // below it (`_consumer.js:634`, and `DefaultLogger` in `_common.js:95`). The
+    // same level also reaches librdkafka as `log_level`, so ignoring it here left
+    // the JS side more verbose than the native side it is meant to match.
+    //
+    // Permissive until that call lands, so nothing is dropped before the library
+    // has said what it wants.
+    let level = LEVEL.DEBUG;
+    const libraryLogger = {
+        info: (message, extra) => {
+            if (level >= LEVEL.INFO)
+                logger.info(message, meta(extra));
+        },
+        warn: (message, extra) => {
+            if (level >= LEVEL.WARN)
+                logger.warn(message, meta(extra));
+        },
+        debug: (message, extra) => {
+            if (level >= LEVEL.DEBUG)
+                logger.debug(message, meta(extra));
+        },
+        error: (message, extra) => {
+            if (level >= LEVEL.ERROR)
+                logger.error(message, meta(extra));
+            // Not gated by the level: escalating a non-recoverable error is control
+            // flow rather than logging, and it has to keep working however quiet the
+            // client asks the library to be.
+            if (onFatalError && isNonRecoverable(message)) {
+                onFatalError(new n8n_workflow_1.UserError(message));
+            }
+        },
+        // The library namespaces its loggers per component. n8n's logger has no
+        // equivalent and the entries already say which component they came from,
+        // so the same logger is reused.
+        namespace: () => libraryLogger,
+        setLogLevel: (next) => {
+            level = next;
+        },
+    };
+    return libraryLogger;
+}
+//# sourceMappingURL=LibraryLogger.js.map

package/dist/nodes/Kafka/v2/transport/LibraryLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LibraryLogger.js","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/transport/LibraryLogger.ts"],"names":[],"mappings":";;;AAEA,+CAAyC;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,eAAe,GAAG,CAAC,uBAAuB,EAAE,sBAAsB,CAAC,CAAC;AAE1E,SAAS,gBAAgB,CAAC,OAAe;IACxC,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AACjE,CAAC;AAKD;;;;;GAKG;AACH,MAAM,KAAK,GAAG;IACb,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,KAAK,EAAE,CAAC;CACC,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,6BACC,MAAc,EACd,YAAgC;IAEhC,MAAM,IAAI,GAAG,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,CAAC,CAAC;IAE3D,2EAA2E;IAC3E,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,sEAAsE;IACtE,EAAE;IACF,6EAA6E;IAC7E,0BAA0B;IAC1B,IAAI,KAAK,GAAW,KAAK,CAAC,KAAK,CAAC;IAEhC,MAAM,aAAa,GAAmB;QACrC,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACxB,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI;gBAAE,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5D,CAAC;QACD,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACxB,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI;gBAAE,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5D,CAAC;QACD,KAAK,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACzB,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK;gBAAE,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9D,CAAC;QACD,KAAK,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACzB,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK;gBAAE,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;YAC7D,wEAAwE;YACxE,yEAAyE;YACzE,iCAAiC;YACjC,IAAI,YAAY,IAAI,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC/C,YAAY,CAAC,IAAI,wBAAS,CAAC,OAAO,CAAC,CAAC,CAAC;YACtC,CAAC;QACF,CAAC;QACD,wEAAwE;QACxE,yEAAyE;QACzE,gCAAgC;QAChC,SAAS,EAAE,GAAG,EAAE,CAAC,aAAa;QAC9B,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE;YACrB,KAAK,GAAG,IAAI,CAAC;QACd,CAAC;KACD,CAAC;IAEF,OAAO,aAAa,CAAC;AACtB,CAAC"}

package/dist/nodes/Kafka/v2/transport/client.d.ts

@@ -0,0 +1,20 @@
+import type { KafkaJS as KafkaJSNamespace } from '@confluentinc/kafka-javascript';
+import type { KafkaCredentials } from '../../utils';
+/**
+ * The only file allowed to import '@confluentinc/kafka-javascript' at runtime
+ * (enforced by eslint.config.mjs) — all v2 Kafka code must go through this
+ * lazy access point instead of importing the library directly.
+ *
+ * A rejected import (e.g. the native binding failing to load) propagates
+ * unwrapped and leaves the cache empty, so the next call retries from scratch
+ * rather than permanently wedging on a transient failure.
+ */
+export declare function getKafkaLibrary(): Promise<typeof KafkaJSNamespace>;
+/**
+ * Builds the library client for a credential. Shared by the producer and consumer
+ * factories so the credential conversion and the log-level pin stay in one place
+ * rather than being copied per factory.
+ * @param credentials - The decrypted Kafka credential
+ */
+export declare function createKafkaClient(credentials: KafkaCredentials): Promise<KafkaJSNamespace.Kafka>;
+//# sourceMappingURL=client.d.ts.map

package/dist/nodes/Kafka/v2/transport/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/transport/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAGlF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD;;;;;;;;GAQG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,OAAO,gBAAgB,CAAC,CAKxE;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACtC,WAAW,EAAE,gBAAgB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAMjC"}

package/dist/nodes/Kafka/v2/transport/client.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKafkaLibrary = getKafkaLibrary;
+exports.createKafkaClient = createKafkaClient;
+const config_1 = require("./config");
+let _kafkaJS = null;
+/**
+ * The only file allowed to import '@confluentinc/kafka-javascript' at runtime
+ * (enforced by eslint.config.mjs) — all v2 Kafka code must go through this
+ * lazy access point instead of importing the library directly.
+ *
+ * A rejected import (e.g. the native binding failing to load) propagates
+ * unwrapped and leaves the cache empty, so the next call retries from scratch
+ * rather than permanently wedging on a transient failure.
+ */
+async function getKafkaLibrary() {
+    if (_kafkaJS)
+        return _kafkaJS;
+    const mod = await import('@confluentinc/kafka-javascript');
+    _kafkaJS = mod.KafkaJS;
+    return _kafkaJS;
+}
+/**
+ * Builds the library client for a credential. Shared by the producer and consumer
+ * factories so the credential conversion and the log-level pin stay in one place
+ * rather than being copied per factory.
+ * @param credentials - The decrypted Kafka credential
+ */
+async function createKafkaClient(credentials) {
+    const { Kafka, logLevel } = await getKafkaLibrary();
+    const config = (0, config_1.toKafkaJSConfig)(credentials);
+    // Without an explicit level the library's own logger writes broker host:port to
+    // process stdout on every execution, outside n8n's logger.
+    return new Kafka({ ...config, kafkaJS: { ...config.kafkaJS, logLevel: logLevel.ERROR } });
+}
+//# sourceMappingURL=client.js.map

package/dist/nodes/Kafka/v2/transport/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/transport/client.ts"],"names":[],"mappings":";;;;AAEA,qCAA2C;AAG3C,IAAI,QAAQ,GAAmC,IAAI,CAAC;AAEpD;;;;;;;;GAQG;AACI,KAAK;IACX,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,gCAAgC,CAAC,CAAC;IAC3D,QAAQ,GAAG,GAAG,CAAC,OAAO,CAAC;IACvB,OAAO,QAAQ,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACI,KAAK,4BACX,WAA6B;IAE7B,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,eAAe,EAAE,CAAC;IACpD,MAAM,MAAM,GAAG,IAAA,wBAAe,EAAC,WAAW,CAAC,CAAC;IAC5C,gFAAgF;IAChF,2DAA2D;IAC3D,OAAO,IAAI,KAAK,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AAC3F,CAAC"}

package/dist/nodes/Kafka/v2/transport/config.d.ts

@@ -0,0 +1,13 @@
+import type { KafkaJS } from '@confluentinc/kafka-javascript';
+import { type KafkaCredentials } from '../../utils';
+/**
+ * Converts a decrypted Kafka credential into the library's
+ * `CommonConstructorConfig` — a `kafkaJS` block (app-level: brokers, clientId,
+ * ssl boolean, sasl) sitting alongside flat, dotted-key TLS/mTLS properties
+ * (native-librdkafka-level). No `security.protocol` is emitted: the library
+ * derives it from `kafkaJS.ssl` + presence of `kafkaJS.sasl` on its own.
+ */
+export declare function toKafkaJSConfig(credentials: KafkaCredentials): KafkaJS.CommonConstructorConfig & {
+    kafkaJS: KafkaJS.KafkaConfig;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/nodes/Kafka/v2/transport/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/transport/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAG9D,OAAO,EAAwB,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA+B1E;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,gBAAgB,GAG3B,OAAO,CAAC,uBAAuB,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC,WAAW,CAAA;CAAE,CAqBpE"}

package/dist/nodes/Kafka/v2/transport/config.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKafkaJSConfig = toKafkaJSConfig;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../../utils");
+/**
+ * Builds the flat, dotted-key TLS/mTLS properties the library expects at the
+ * top level of `CommonConstructorConfig` (native librdkafka config) — separate
+ * from the `kafkaJS` block, which only carries a plain `ssl: boolean`.
+ */
+function toTlsProperties(credentials) {
+    if (!credentials.ssl)
+        return {};
+    const cert = credentials.cert?.trim() ? credentials.cert : undefined;
+    const key = credentials.key?.trim() ? credentials.key : undefined;
+    const ca = credentials.ca?.trim() ? credentials.ca : undefined;
+    // A client certificate and its private key are only meaningful together.
+    if (Boolean(cert) !== Boolean(key)) {
+        throw new n8n_workflow_1.UserError('Kafka mTLS needs both a client certificate and a client private key', {
+            level: 'warning',
+            description: 'Set both the "Client Certificate" and "Client Private Key" credential fields, or clear both.',
+        });
+    }
+    return {
+        ...(ca ? { 'ssl.ca.pem': (0, utils_1.formatAndValidatePem)(ca, 'CA certificate') } : {}),
+        ...(cert ? { 'ssl.certificate.pem': (0, utils_1.formatAndValidatePem)(cert, 'client certificate') } : {}),
+        ...(key ? { 'ssl.key.pem': (0, utils_1.formatAndValidatePem)(key, 'client private key') } : {}),
+        ...(credentials.allowUnauthorizedCerts ? { 'enable.ssl.certificate.verification': false } : {}),
+    };
+}
+/**
+ * Converts a decrypted Kafka credential into the library's
+ * `CommonConstructorConfig` — a `kafkaJS` block (app-level: brokers, clientId,
+ * ssl boolean, sasl) sitting alongside flat, dotted-key TLS/mTLS properties
+ * (native-librdkafka-level). No `security.protocol` is emitted: the library
+ * derives it from `kafkaJS.ssl` + presence of `kafkaJS.sasl` on its own.
+ */
+function toKafkaJSConfig(credentials) {
+    const brokers = (credentials.brokers ?? '').split(',').map((broker) => broker.trim());
+    const kafkaJS = {
+        brokers,
+        clientId: credentials.clientId,
+        ssl: credentials.ssl,
+    };
+    if (credentials.authentication) {
+        if (!(credentials.username && credentials.password)) {
+            throw new n8n_workflow_1.UserError('Username and password are required for authentication');
+        }
+        kafkaJS.sasl = {
+            mechanism: credentials.saslMechanism ?? 'plain',
+            username: credentials.username,
+            password: credentials.password,
+        };
+    }
+    return { kafkaJS, ...toTlsProperties(credentials) };
+}
+//# sourceMappingURL=config.js.map

package/dist/nodes/Kafka/v2/transport/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../../nodes/Kafka/v2/transport/config.ts"],"names":[],"mappings":";;;AACA,+CAAyC;AAEzC,uCAA0E;AAE1E;;;;GAIG;AACH,SAAS,eAAe,CAAC,WAA6B;IACrD,IAAI,CAAC,WAAW,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IAEhC,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,MAAM,EAAE,GAAG,WAAW,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAE/D,yEAAyE;IACzE,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,wBAAS,CAAC,qEAAqE,EAAE;YAC1F,KAAK,EAAE,SAAS;YAChB,WAAW,EACV,8FAA8F;SAC/F,CAAC,CAAC;IACJ,CAAC;IAED,OAAO;QACN,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,IAAA,4BAAoB,EAAC,EAAE,EAAE,gBAAgB,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3E,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,qBAAqB,EAAE,IAAA,4BAAoB,EAAC,IAAI,EAAE,oBAAoB,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5F,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,IAAA,4BAAoB,EAAC,GAAG,EAAE,oBAAoB,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClF,GAAG,CAAC,WAAW,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,qCAAqC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC/F,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,yBACC,WAA6B;IAI7B,MAAM,OAAO,GAAG,CAAC,WAAW,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAEtF,MAAM,OAAO,GAAwB;QACpC,OAAO;QACP,QAAQ,EAAE,WAAW,CAAC,QAAQ;QAC9B,GAAG,EAAE,WAAW,CAAC,GAAG;KACpB,CAAC;IAEF,IAAI,WAAW,CAAC,cAAc,EAAE,CAAC;QAChC,IAAI,CAAC,CAAC,WAAW,CAAC,QAAQ,IAAI,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrD,MAAM,IAAI,wBAAS,CAAC,uDAAuD,CAAC,CAAC;QAC9E,CAAC;QACD,OAAO,CAAC,IAAI,GAAG;YACd,SAAS,EAAE,WAAW,CAAC,aAAa,IAAI,OAAO;YAC/C,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,QAAQ,EAAE,WAAW,CAAC,QAAQ;SAC9B,CAAC;IACH,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,GAAG,eAAe,CAAC,WAAW,CAAC,EAAE,CAAC;AACrD,CAAC"}