@mastra/core 1.0.0-beta.21 → 1.0.0-beta.22

package/dist/{chunk-3RFSIHFR.js → chunk-K2LPTKSY.js}

@@ -1,5 +1,5 @@
 import { __commonJS, require_token_error, __toESM } from './chunk-D22XABFZ.js';
-import { lazyValidator, zodSchema, createIdGenerator, withoutTrailingSlash, resolve, postJsonToApi, createJsonErrorResponseHandler, createJsonResponseHandler, combineHeaders, createEventSourceResponseHandler, loadOptionalSetting, withUserAgentSuffix, APICallError, safeValidateTypes, safeParseJSON, asSchema, getErrorMessage2, generateId, AISDKError, convertBase64ToUint8Array, getRuntimeEnvironmentUserAgent, getErrorMessage, getFromApi, isAbortError, delay, convertUint8ArrayToBase64, validateTypes } from './chunk-7JGQWNV5.js';
+import { lazyValidator, zodSchema, createIdGenerator, withoutTrailingSlash, resolve, postJsonToApi, createJsonErrorResponseHandler, createJsonResponseHandler, combineHeaders, createEventSourceResponseHandler, loadOptionalSetting, withUserAgentSuffix, APICallError, safeValidateTypes, safeParseJSON, asSchema, AISDKError, convertBase64ToUint8Array, getRuntimeEnvironmentUserAgent, getErrorMessage, getFromApi, isAbortError, getErrorMessage2, delay, convertUint8ArrayToBase64 } from './chunk-CPLRD2VP.js';
 import { z } from 'zod/v4';
 
 var require_get_context = __commonJS({
@@ -2557,70 +2557,6 @@ createIdGenerator({
   prefix: "aitxt",
   size: 24
 });
-function prepareHeaders(headers, defaultHeaders) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  for (const [key, value] of Object.entries(defaultHeaders)) {
-    if (!responseHeaders.has(key)) {
-      responseHeaders.set(key, value);
-    }
-  }
-  return responseHeaders;
-}
-function createTextStreamResponse({
-  status,
-  statusText,
-  headers,
-  textStream
-}) {
-  return new Response(textStream.pipeThrough(new TextEncoderStream()), {
-    status: status != null ? status : 200,
-    statusText,
-    headers: prepareHeaders(headers, {
-      "content-type": "text/plain; charset=utf-8"
-    })
-  });
-}
-var JsonToSseTransformStream = class extends TransformStream {
-  constructor() {
-    super({
-      transform(part, controller) {
-        controller.enqueue(`data: ${JSON.stringify(part)}
-
-`);
-      },
-      flush(controller) {
-        controller.enqueue("data: [DONE]\n\n");
-      }
-    });
-  }
-};
-var UI_MESSAGE_STREAM_HEADERS = {
-  "content-type": "text/event-stream",
-  "cache-control": "no-cache",
-  connection: "keep-alive",
-  "x-vercel-ai-ui-message-stream": "v1",
-  "x-accel-buffering": "no"
-  // disable nginx buffering
-};
-function createUIMessageStreamResponse({
-  status,
-  statusText,
-  headers,
-  stream,
-  consumeSseStream
-}) {
-  let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
-  if (consumeSseStream) {
-    const [stream1, stream2] = sseStream.tee();
-    sseStream = stream1;
-    consumeSseStream({ stream: stream2 });
-  }
-  return new Response(sseStream.pipeThrough(new TextEncoderStream()), {
-    status,
-    statusText,
-    headers: prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS)
-  });
-}
 lazyValidator(
   () => zodSchema(
     z.union([
@@ -2770,40 +2706,6 @@ lazyValidator(
     ])
   )
 );
-function isDataUIMessageChunk(chunk) {
-  return chunk.type.startsWith("data-");
-}
-function mergeObjects(base, overrides) {
-  if (base === void 0 && overrides === void 0) {
-    return void 0;
-  }
-  if (base === void 0) {
-    return overrides;
-  }
-  if (overrides === void 0) {
-    return base;
-  }
-  const result = { ...base };
-  for (const key in overrides) {
-    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
-      const overridesValue = overrides[key];
-      if (overridesValue === void 0)
-        continue;
-      const baseValue = key in base ? base[key] : void 0;
-      const isSourceObject = overridesValue !== null && typeof overridesValue === "object" && !Array.isArray(overridesValue) && !(overridesValue instanceof Date) && !(overridesValue instanceof RegExp);
-      const isTargetObject = baseValue !== null && baseValue !== void 0 && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date) && !(baseValue instanceof RegExp);
-      if (isSourceObject && isTargetObject) {
-        result[key] = mergeObjects(
-          baseValue,
-          overridesValue
-        );
-      } else {
-        result[key] = overridesValue;
-      }
-    }
-  }
-  return result;
-}
 function fixJson(input) {
   const stack = ["ROOT"];
   let lastValidIndex = -1;
@@ -3161,541 +3063,6 @@ function getToolName(part) {
 function getToolOrDynamicToolName(part) {
   return isDynamicToolUIPart(part) ? part.toolName : getToolName(part);
 }
-function createStreamingUIMessageState({
-  lastMessage,
-  messageId
-}) {
-  return {
-    message: (lastMessage == null ? void 0 : lastMessage.role) === "assistant" ? lastMessage : {
-      id: messageId,
-      metadata: void 0,
-      role: "assistant",
-      parts: []
-    },
-    activeTextParts: {},
-    activeReasoningParts: {},
-    partialToolCalls: {}
-  };
-}
-function processUIMessageStream({
-  stream,
-  messageMetadataSchema,
-  dataPartSchemas,
-  runUpdateMessageJob,
-  onError,
-  onToolCall,
-  onData
-}) {
-  return stream.pipeThrough(
-    new TransformStream({
-      async transform(chunk, controller) {
-        await runUpdateMessageJob(async ({ state, write }) => {
-          var _a16, _b8, _c, _d;
-          function getToolInvocation(toolCallId) {
-            const toolInvocations = state.message.parts.filter(isToolUIPart);
-            const toolInvocation = toolInvocations.find(
-              (invocation) => invocation.toolCallId === toolCallId
-            );
-            if (toolInvocation == null) {
-              throw new Error(
-                "tool-output-error must be preceded by a tool-input-available"
-              );
-            }
-            return toolInvocation;
-          }
-          function getDynamicToolInvocation(toolCallId) {
-            const toolInvocations = state.message.parts.filter(
-              (part) => part.type === "dynamic-tool"
-            );
-            const toolInvocation = toolInvocations.find(
-              (invocation) => invocation.toolCallId === toolCallId
-            );
-            if (toolInvocation == null) {
-              throw new Error(
-                "tool-output-error must be preceded by a tool-input-available"
-              );
-            }
-            return toolInvocation;
-          }
-          function updateToolPart(options) {
-            var _a17;
-            const part = state.message.parts.find(
-              (part2) => isToolUIPart(part2) && part2.toolCallId === options.toolCallId
-            );
-            const anyOptions = options;
-            const anyPart = part;
-            if (part != null) {
-              part.state = options.state;
-              anyPart.input = anyOptions.input;
-              anyPart.output = anyOptions.output;
-              anyPart.errorText = anyOptions.errorText;
-              anyPart.rawInput = anyOptions.rawInput;
-              anyPart.preliminary = anyOptions.preliminary;
-              anyPart.providerExecuted = (_a17 = anyOptions.providerExecuted) != null ? _a17 : part.providerExecuted;
-              if (anyOptions.providerMetadata != null && part.state === "input-available") {
-                part.callProviderMetadata = anyOptions.providerMetadata;
-              }
-            } else {
-              state.message.parts.push({
-                type: `tool-${options.toolName}`,
-                toolCallId: options.toolCallId,
-                state: options.state,
-                input: anyOptions.input,
-                output: anyOptions.output,
-                rawInput: anyOptions.rawInput,
-                errorText: anyOptions.errorText,
-                providerExecuted: anyOptions.providerExecuted,
-                preliminary: anyOptions.preliminary,
-                ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
-              });
-            }
-          }
-          function updateDynamicToolPart(options) {
-            var _a17, _b22;
-            const part = state.message.parts.find(
-              (part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId
-            );
-            const anyOptions = options;
-            const anyPart = part;
-            if (part != null) {
-              part.state = options.state;
-              anyPart.toolName = options.toolName;
-              anyPart.input = anyOptions.input;
-              anyPart.output = anyOptions.output;
-              anyPart.errorText = anyOptions.errorText;
-              anyPart.rawInput = (_a17 = anyOptions.rawInput) != null ? _a17 : anyPart.rawInput;
-              anyPart.preliminary = anyOptions.preliminary;
-              anyPart.providerExecuted = (_b22 = anyOptions.providerExecuted) != null ? _b22 : part.providerExecuted;
-              if (anyOptions.providerMetadata != null && part.state === "input-available") {
-                part.callProviderMetadata = anyOptions.providerMetadata;
-              }
-            } else {
-              state.message.parts.push({
-                type: "dynamic-tool",
-                toolName: options.toolName,
-                toolCallId: options.toolCallId,
-                state: options.state,
-                input: anyOptions.input,
-                output: anyOptions.output,
-                errorText: anyOptions.errorText,
-                preliminary: anyOptions.preliminary,
-                providerExecuted: anyOptions.providerExecuted,
-                ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
-              });
-            }
-          }
-          async function updateMessageMetadata(metadata) {
-            if (metadata != null) {
-              const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
-              if (messageMetadataSchema != null) {
-                await validateTypes({
-                  value: mergedMetadata,
-                  schema: messageMetadataSchema
-                });
-              }
-              state.message.metadata = mergedMetadata;
-            }
-          }
-          switch (chunk.type) {
-            case "text-start": {
-              const textPart = {
-                type: "text",
-                text: "",
-                providerMetadata: chunk.providerMetadata,
-                state: "streaming"
-              };
-              state.activeTextParts[chunk.id] = textPart;
-              state.message.parts.push(textPart);
-              write();
-              break;
-            }
-            case "text-delta": {
-              const textPart = state.activeTextParts[chunk.id];
-              textPart.text += chunk.delta;
-              textPart.providerMetadata = (_a16 = chunk.providerMetadata) != null ? _a16 : textPart.providerMetadata;
-              write();
-              break;
-            }
-            case "text-end": {
-              const textPart = state.activeTextParts[chunk.id];
-              textPart.state = "done";
-              textPart.providerMetadata = (_b8 = chunk.providerMetadata) != null ? _b8 : textPart.providerMetadata;
-              delete state.activeTextParts[chunk.id];
-              write();
-              break;
-            }
-            case "reasoning-start": {
-              const reasoningPart = {
-                type: "reasoning",
-                text: "",
-                providerMetadata: chunk.providerMetadata,
-                state: "streaming"
-              };
-              state.activeReasoningParts[chunk.id] = reasoningPart;
-              state.message.parts.push(reasoningPart);
-              write();
-              break;
-            }
-            case "reasoning-delta": {
-              const reasoningPart = state.activeReasoningParts[chunk.id];
-              reasoningPart.text += chunk.delta;
-              reasoningPart.providerMetadata = (_c = chunk.providerMetadata) != null ? _c : reasoningPart.providerMetadata;
-              write();
-              break;
-            }
-            case "reasoning-end": {
-              const reasoningPart = state.activeReasoningParts[chunk.id];
-              reasoningPart.providerMetadata = (_d = chunk.providerMetadata) != null ? _d : reasoningPart.providerMetadata;
-              reasoningPart.state = "done";
-              delete state.activeReasoningParts[chunk.id];
-              write();
-              break;
-            }
-            case "file": {
-              state.message.parts.push({
-                type: "file",
-                mediaType: chunk.mediaType,
-                url: chunk.url
-              });
-              write();
-              break;
-            }
-            case "source-url": {
-              state.message.parts.push({
-                type: "source-url",
-                sourceId: chunk.sourceId,
-                url: chunk.url,
-                title: chunk.title,
-                providerMetadata: chunk.providerMetadata
-              });
-              write();
-              break;
-            }
-            case "source-document": {
-              state.message.parts.push({
-                type: "source-document",
-                sourceId: chunk.sourceId,
-                mediaType: chunk.mediaType,
-                title: chunk.title,
-                filename: chunk.filename,
-                providerMetadata: chunk.providerMetadata
-              });
-              write();
-              break;
-            }
-            case "tool-input-start": {
-              const toolInvocations = state.message.parts.filter(isToolUIPart);
-              state.partialToolCalls[chunk.toolCallId] = {
-                text: "",
-                toolName: chunk.toolName,
-                index: toolInvocations.length,
-                dynamic: chunk.dynamic
-              };
-              if (chunk.dynamic) {
-                updateDynamicToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  state: "input-streaming",
-                  input: void 0,
-                  providerExecuted: chunk.providerExecuted
-                });
-              } else {
-                updateToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  state: "input-streaming",
-                  input: void 0,
-                  providerExecuted: chunk.providerExecuted
-                });
-              }
-              write();
-              break;
-            }
-            case "tool-input-delta": {
-              const partialToolCall = state.partialToolCalls[chunk.toolCallId];
-              partialToolCall.text += chunk.inputTextDelta;
-              const { value: partialArgs } = await parsePartialJson(
-                partialToolCall.text
-              );
-              if (partialToolCall.dynamic) {
-                updateDynamicToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: partialToolCall.toolName,
-                  state: "input-streaming",
-                  input: partialArgs
-                });
-              } else {
-                updateToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: partialToolCall.toolName,
-                  state: "input-streaming",
-                  input: partialArgs
-                });
-              }
-              write();
-              break;
-            }
-            case "tool-input-available": {
-              if (chunk.dynamic) {
-                updateDynamicToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  state: "input-available",
-                  input: chunk.input,
-                  providerExecuted: chunk.providerExecuted,
-                  providerMetadata: chunk.providerMetadata
-                });
-              } else {
-                updateToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  state: "input-available",
-                  input: chunk.input,
-                  providerExecuted: chunk.providerExecuted,
-                  providerMetadata: chunk.providerMetadata
-                });
-              }
-              write();
-              if (onToolCall && !chunk.providerExecuted) {
-                await onToolCall({
-                  toolCall: chunk
-                });
-              }
-              break;
-            }
-            case "tool-input-error": {
-              if (chunk.dynamic) {
-                updateDynamicToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  state: "output-error",
-                  input: chunk.input,
-                  errorText: chunk.errorText,
-                  providerExecuted: chunk.providerExecuted,
-                  providerMetadata: chunk.providerMetadata
-                });
-              } else {
-                updateToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  state: "output-error",
-                  input: void 0,
-                  rawInput: chunk.input,
-                  errorText: chunk.errorText,
-                  providerExecuted: chunk.providerExecuted,
-                  providerMetadata: chunk.providerMetadata
-                });
-              }
-              write();
-              break;
-            }
-            case "tool-output-available": {
-              if (chunk.dynamic) {
-                const toolInvocation = getDynamicToolInvocation(
-                  chunk.toolCallId
-                );
-                updateDynamicToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: toolInvocation.toolName,
-                  state: "output-available",
-                  input: toolInvocation.input,
-                  output: chunk.output,
-                  preliminary: chunk.preliminary
-                });
-              } else {
-                const toolInvocation = getToolInvocation(chunk.toolCallId);
-                updateToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: getToolName(toolInvocation),
-                  state: "output-available",
-                  input: toolInvocation.input,
-                  output: chunk.output,
-                  providerExecuted: chunk.providerExecuted,
-                  preliminary: chunk.preliminary
-                });
-              }
-              write();
-              break;
-            }
-            case "tool-output-error": {
-              if (chunk.dynamic) {
-                const toolInvocation = getDynamicToolInvocation(
-                  chunk.toolCallId
-                );
-                updateDynamicToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: toolInvocation.toolName,
-                  state: "output-error",
-                  input: toolInvocation.input,
-                  errorText: chunk.errorText,
-                  providerExecuted: chunk.providerExecuted
-                });
-              } else {
-                const toolInvocation = getToolInvocation(chunk.toolCallId);
-                updateToolPart({
-                  toolCallId: chunk.toolCallId,
-                  toolName: getToolName(toolInvocation),
-                  state: "output-error",
-                  input: toolInvocation.input,
-                  rawInput: toolInvocation.rawInput,
-                  errorText: chunk.errorText,
-                  providerExecuted: chunk.providerExecuted
-                });
-              }
-              write();
-              break;
-            }
-            case "start-step": {
-              state.message.parts.push({ type: "step-start" });
-              break;
-            }
-            case "finish-step": {
-              state.activeTextParts = {};
-              state.activeReasoningParts = {};
-              break;
-            }
-            case "start": {
-              if (chunk.messageId != null) {
-                state.message.id = chunk.messageId;
-              }
-              await updateMessageMetadata(chunk.messageMetadata);
-              if (chunk.messageId != null || chunk.messageMetadata != null) {
-                write();
-              }
-              break;
-            }
-            case "finish": {
-              if (chunk.finishReason != null) {
-                state.finishReason = chunk.finishReason;
-              }
-              await updateMessageMetadata(chunk.messageMetadata);
-              if (chunk.messageMetadata != null) {
-                write();
-              }
-              break;
-            }
-            case "message-metadata": {
-              await updateMessageMetadata(chunk.messageMetadata);
-              if (chunk.messageMetadata != null) {
-                write();
-              }
-              break;
-            }
-            case "error": {
-              onError == null ? void 0 : onError(new Error(chunk.errorText));
-              break;
-            }
-            default: {
-              if (isDataUIMessageChunk(chunk)) {
-                if ((dataPartSchemas == null ? void 0 : dataPartSchemas[chunk.type]) != null) {
-                  await validateTypes({
-                    value: chunk.data,
-                    schema: dataPartSchemas[chunk.type]
-                  });
-                }
-                const dataChunk = chunk;
-                if (dataChunk.transient) {
-                  onData == null ? void 0 : onData(dataChunk);
-                  break;
-                }
-                const existingUIPart = dataChunk.id != null ? state.message.parts.find(
-                  (chunkArg) => dataChunk.type === chunkArg.type && dataChunk.id === chunkArg.id
-                ) : void 0;
-                if (existingUIPart != null) {
-                  existingUIPart.data = dataChunk.data;
-                } else {
-                  state.message.parts.push(dataChunk);
-                }
-                onData == null ? void 0 : onData(dataChunk);
-                write();
-              }
-            }
-          }
-          controller.enqueue(chunk);
-        });
-      }
-    })
-  );
-}
-function handleUIMessageStreamFinish({
-  messageId,
-  originalMessages = [],
-  onFinish,
-  onError,
-  stream
-}) {
-  let lastMessage = originalMessages == null ? void 0 : originalMessages[originalMessages.length - 1];
-  if ((lastMessage == null ? void 0 : lastMessage.role) !== "assistant") {
-    lastMessage = void 0;
-  } else {
-    messageId = lastMessage.id;
-  }
-  let isAborted = false;
-  const idInjectedStream = stream.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        if (chunk.type === "start") {
-          const startChunk = chunk;
-          if (startChunk.messageId == null && messageId != null) {
-            startChunk.messageId = messageId;
-          }
-        }
-        if (chunk.type === "abort") {
-          isAborted = true;
-        }
-        controller.enqueue(chunk);
-      }
-    })
-  );
-  if (onFinish == null) {
-    return idInjectedStream;
-  }
-  const state = createStreamingUIMessageState({
-    lastMessage: lastMessage ? structuredClone(lastMessage) : void 0,
-    messageId: messageId != null ? messageId : ""
-    // will be overridden by the stream
-  });
-  const runUpdateMessageJob = async (job) => {
-    await job({ state, write: () => {
-    } });
-  };
-  let finishCalled = false;
-  const callOnFinish = async () => {
-    if (finishCalled || !onFinish) {
-      return;
-    }
-    finishCalled = true;
-    const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
-    await onFinish({
-      isAborted,
-      isContinuation,
-      responseMessage: state.message,
-      messages: [
-        ...isContinuation ? originalMessages.slice(0, -1) : originalMessages,
-        state.message
-      ],
-      finishReason: state.finishReason
-    });
-  };
-  return processUIMessageStream({
-    stream: idInjectedStream,
-    runUpdateMessageJob,
-    onError
-  }).pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        controller.enqueue(chunk);
-      },
-      // @ts-expect-error cancel is still new and missing from types https://developer.mozilla.org/en-US/docs/Web/API/TransformStream#browser_compatibility
-      async cancel() {
-        await callOnFinish();
-      },
-      async flush() {
-        await callOnFinish();
-      }
-    })
-  );
-}
 createIdGenerator({
   prefix: "aitxt",
   size: 24
@@ -4485,90 +3852,7 @@ lazyValidator(
     ).nonempty("Messages array must not be empty")
   )
 );
-function createUIMessageStream({
-  execute,
-  onError = getErrorMessage2,
-  originalMessages,
-  onFinish,
-  generateId: generateId3 = generateId
-}) {
-  let controller;
-  const ongoingStreamPromises = [];
-  const stream = new ReadableStream({
-    start(controllerArg) {
-      controller = controllerArg;
-    }
-  });
-  function safeEnqueue(data) {
-    try {
-      controller.enqueue(data);
-    } catch (error) {
-    }
-  }
-  try {
-    const result = execute({
-      writer: {
-        write(part) {
-          safeEnqueue(part);
-        },
-        merge(streamArg) {
-          ongoingStreamPromises.push(
-            (async () => {
-              const reader = streamArg.getReader();
-              while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                  break;
-                safeEnqueue(value);
-              }
-            })().catch((error) => {
-              safeEnqueue({
-                type: "error",
-                errorText: onError(error)
-              });
-            })
-          );
-        },
-        onError
-      }
-    });
-    if (result) {
-      ongoingStreamPromises.push(
-        result.catch((error) => {
-          safeEnqueue({
-            type: "error",
-            errorText: onError(error)
-          });
-        })
-      );
-    }
-  } catch (error) {
-    safeEnqueue({
-      type: "error",
-      errorText: onError(error)
-    });
-  }
-  const waitForStreams = new Promise(async (resolve2) => {
-    while (ongoingStreamPromises.length > 0) {
-      await ongoingStreamPromises.shift();
-    }
-    resolve2();
-  });
-  waitForStreams.finally(() => {
-    try {
-      controller.close();
-    } catch (error) {
-    }
-  });
-  return handleUIMessageStreamFinish({
-    stream,
-    messageId: generateId3(),
-    originalMessages,
-    onFinish,
-    onError
-  });
-}
 
-export { convertToModelMessages, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, embed, generateSpeech, isDeepEqualData, isToolUIPart, parsePartialJson, stepCountIs, transcribe };
-//# sourceMappingURL=chunk-3RFSIHFR.js.map
-//# sourceMappingURL=chunk-3RFSIHFR.js.map
+export { convertToModelMessages, embed, generateSpeech, isDeepEqualData, isToolUIPart, parsePartialJson, stepCountIs, transcribe };
+//# sourceMappingURL=chunk-K2LPTKSY.js.map
+//# sourceMappingURL=chunk-K2LPTKSY.js.map