Initial commit with local project files

.gitattributes

@@ -0,0 +1 @@
+.output/** filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.env

Dockerfile

@@ -0,0 +1,31 @@
+# Use the latest Node.js LTS version
+FROM node:latest
+
+# Install pnpm globally
+RUN npm install -g pnpm
+
+# Set working directory
+WORKDIR /app
+
+# Copy dist directory to the container
+COPY dist ./dist
+
+# Copy package.json to the container
+COPY package.json ./
+
+# Copy langgraph.json to the container
+COPY langgraph.json ./
+
+# Install dependencies using pnpm
+RUN pnpm install
+
+# Create a non-root user for security
+RUN groupadd -r appuser && useradd -r -g appuser appuser
+RUN chown -R appuser:appuser /app
+USER appuser
+
+# Expose the port
+EXPOSE 7860
+
+# Start the LangGraph agent server
+CMD ["pnpm", "run", "start"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Auto Anime Agent
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+app_file: app.py
+---
+
+# Auto Anime Deploy

build.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# Set source path
+SOURCE=../automotion
+
+# Get absolute path of current script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Check if source directory exists
+if [ ! -d "$SOURCE" ]; then
+    echo "Error: Source directory $SOURCE does not exist"
+    exit 1
+fi
+
+echo "Starting build process..."
+echo "Source path: $SOURCE"
+echo "Target path: $SCRIPT_DIR"
+
+# Enter source directory
+cd "$SOURCE" || {
+    echo "Error: Cannot enter directory $SOURCE"
+    exit 1
+}
+
+echo "Current directory: $(pwd)"
+
+# Execute build script
+echo "Executing bun scripts/build-langgraph.ts..."
+bun scripts/build-langgraph.ts || {
+    echo "Error: Build script failed"
+    exit 1
+}
+
+# Remove existing dist directory if it exists
+if [ -d "$SCRIPT_DIR/dist" ]; then
+    echo "Removing existing dist directory..."
+    rm -rf "$SCRIPT_DIR/dist" || {
+        echo "Error: Cannot remove existing dist directory"
+        exit 1
+    }
+fi
+
+# Copy dist/langgraph to current dist directory
+if [ -d "dist/langgraph" ]; then
+    echo "Copying dist/langgraph to $SCRIPT_DIR/dist..."
+    mkdir -p "$SCRIPT_DIR"
+    cp -r "dist/langgraph" "$SCRIPT_DIR/dist" || {
+        echo "Error: Cannot copy dist/langgraph directory"
+        exit 1
+    }
+    echo "Copied dist/langgraph/"
+else
+    echo "Error: dist/langgraph directory not found"
+    exit 1
+fi
+
+# Copy apps/web/package.json to current directory
+if [ -f "apps/web/package.json" ]; then
+    echo "Copying apps/web/package.json..."
+    cp "apps/web/package.json" "$SCRIPT_DIR/" || {
+        echo "Error: Cannot copy package.json"
+        exit 1
+    }
+    echo "Copied package.json"
+else
+    echo "Error: apps/web/package.json file not found"
+    exit 1
+fi
+
+echo "Build completed!"

dist/chunk-Dx39-ABv.mjs

@@ -0,0 +1,36 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __commonJS, __export, __require, __toESM };

dist/few_shot-BBzZpDUy.mjs

@@ -0,0 +1,1526 @@
+import { __export } from "./chunk-Dx39-ABv.mjs";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, BasePromptTemplate, BaseStringPromptTemplate, ChatMessage, ChatMessageChunk, ChatPromptValue, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, ImagePromptValue, PromptTemplate, Runnable, RunnableLambda, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, _isMessageFieldWithRole, _mergeDicts, _mergeLists, _mergeObj, _mergeStatus, addLangChainErrorFields, checkValidTemplate, coerceMessageLikeToMessage, convertToChunk, convertToOpenAIImageBlock, convertToProviderContentBlock, getBufferString, isAIMessage, isAIMessageChunk, isBase64ContentBlock, isBaseMessage, isBaseMessageChunk, isChatMessage, isChatMessageChunk, isDataContentBlock, isFunctionMessage, isFunctionMessageChunk, isHumanMessage, isHumanMessageChunk, isIDContentBlock, isOpenAIToolCallArray, isPlainTextContentBlock, isSystemMessage, isSystemMessageChunk, isToolMessage, isToolMessageChunk, isURLContentBlock, mapChatMessagesToStoredMessages, mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages, mergeContent, parseBase64DataUrl, parseFString, parseMimeType, parseMustache, parseTemplate, renderTemplate } from "./prompt-Cmq1pjHH.mjs";
+
+//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/modifier.js
+/**
+* Message responsible for deleting other messages.
+*/
+var RemoveMessage = class extends BaseMessage {
+	constructor(fields) {
+		super({
+			...fields,
+			content: ""
+		});
+		/**
+		* The ID of the message to remove.
+		*/
+		Object.defineProperty(this, "id", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.id = fields.id;
+	}
+	_getType() {
+		return "remove";
+	}
+	get _printableFields() {
+		return {
+			...super._printableFields,
+			id: this.id
+		};
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/transformers.js
+const _isMessageType = (msg, types) => {
+	const typesAsStrings = [...new Set(types?.map((t) => {
+		if (typeof t === "string") return t;
+		const instantiatedMsgClass = new t({});
+		if (!("getType" in instantiatedMsgClass) || typeof instantiatedMsgClass.getType !== "function") throw new Error("Invalid type provided.");
+		return instantiatedMsgClass.getType();
+	}))];
+	const msgType = msg.getType();
+	return typesAsStrings.some((t) => t === msgType);
+};
+function filterMessages(messagesOrOptions, options) {
+	if (Array.isArray(messagesOrOptions)) return _filterMessages(messagesOrOptions, options);
+	return RunnableLambda.from((input) => {
+		return _filterMessages(input, messagesOrOptions);
+	});
+}
+function _filterMessages(messages, options = {}) {
+	const { includeNames, excludeNames, includeTypes, excludeTypes, includeIds, excludeIds } = options;
+	const filtered = [];
+	for (const msg of messages) {
+		if (excludeNames && msg.name && excludeNames.includes(msg.name)) continue;
+		else if (excludeTypes && _isMessageType(msg, excludeTypes)) continue;
+		else if (excludeIds && msg.id && excludeIds.includes(msg.id)) continue;
+		if (!(includeTypes || includeIds || includeNames)) filtered.push(msg);
+		else if (includeNames && msg.name && includeNames.some((iName) => iName === msg.name)) filtered.push(msg);
+		else if (includeTypes && _isMessageType(msg, includeTypes)) filtered.push(msg);
+		else if (includeIds && msg.id && includeIds.some((id) => id === msg.id)) filtered.push(msg);
+	}
+	return filtered;
+}
+function mergeMessageRuns(messages) {
+	if (Array.isArray(messages)) return _mergeMessageRuns(messages);
+	return RunnableLambda.from(_mergeMessageRuns);
+}
+function _mergeMessageRuns(messages) {
+	if (!messages.length) return [];
+	const merged = [];
+	for (const msg of messages) {
+		const curr = msg;
+		const last = merged.pop();
+		if (!last) merged.push(curr);
+		else if (curr.getType() === "tool" || !(curr.getType() === last.getType())) merged.push(last, curr);
+		else {
+			const lastChunk = convertToChunk(last);
+			const currChunk = convertToChunk(curr);
+			const mergedChunks = lastChunk.concat(currChunk);
+			if (typeof lastChunk.content === "string" && typeof currChunk.content === "string") mergedChunks.content = `${lastChunk.content}\n${currChunk.content}`;
+			merged.push(_chunkToMsg(mergedChunks));
+		}
+	}
+	return merged;
+}
+function trimMessages(messagesOrOptions, options) {
+	if (Array.isArray(messagesOrOptions)) {
+		const messages = messagesOrOptions;
+		if (!options) throw new Error("Options parameter is required when providing messages.");
+		return _trimMessagesHelper(messages, options);
+	} else {
+		const trimmerOptions = messagesOrOptions;
+		return RunnableLambda.from((input) => _trimMessagesHelper(input, trimmerOptions)).withConfig({ runName: "trim_messages" });
+	}
+}
+async function _trimMessagesHelper(messages, options) {
+	const { maxTokens, tokenCounter, strategy = "last", allowPartial = false, endOn, startOn, includeSystem = false, textSplitter } = options;
+	if (startOn && strategy === "first") throw new Error("`startOn` should only be specified if `strategy` is 'last'.");
+	if (includeSystem && strategy === "first") throw new Error("`includeSystem` should only be specified if `strategy` is 'last'.");
+	let listTokenCounter;
+	if ("getNumTokens" in tokenCounter) listTokenCounter = async (msgs) => {
+		const tokenCounts = await Promise.all(msgs.map((msg) => tokenCounter.getNumTokens(msg.content)));
+		return tokenCounts.reduce((sum, count) => sum + count, 0);
+	};
+	else listTokenCounter = async (msgs) => tokenCounter(msgs);
+	let textSplitterFunc = defaultTextSplitter;
+	if (textSplitter) if ("splitText" in textSplitter) textSplitterFunc = textSplitter.splitText;
+	else textSplitterFunc = async (text) => textSplitter(text);
+	if (strategy === "first") return _firstMaxTokens(messages, {
+		maxTokens,
+		tokenCounter: listTokenCounter,
+		textSplitter: textSplitterFunc,
+		partialStrategy: allowPartial ? "first" : void 0,
+		endOn
+	});
+	else if (strategy === "last") return _lastMaxTokens(messages, {
+		maxTokens,
+		tokenCounter: listTokenCounter,
+		textSplitter: textSplitterFunc,
+		allowPartial,
+		includeSystem,
+		startOn,
+		endOn
+	});
+	else throw new Error(`Unrecognized strategy: '${strategy}'. Must be one of 'first' or 'last'.`);
+}
+async function _firstMaxTokens(messages, options) {
+	const { maxTokens, tokenCounter, textSplitter, partialStrategy, endOn } = options;
+	let messagesCopy = [...messages];
+	let idx = 0;
+	for (let i = 0; i < messagesCopy.length; i += 1) {
+		const remainingMessages = i > 0 ? messagesCopy.slice(0, -i) : messagesCopy;
+		if (await tokenCounter(remainingMessages) <= maxTokens) {
+			idx = messagesCopy.length - i;
+			break;
+		}
+	}
+	if (idx < messagesCopy.length - 1 && partialStrategy) {
+		let includedPartial = false;
+		if (Array.isArray(messagesCopy[idx].content)) {
+			const excluded = messagesCopy[idx];
+			if (typeof excluded.content === "string") throw new Error("Expected content to be an array.");
+			const numBlock = excluded.content.length;
+			const reversedContent = partialStrategy === "last" ? [...excluded.content].reverse() : excluded.content;
+			for (let i = 1; i <= numBlock; i += 1) {
+				const partialContent = partialStrategy === "first" ? reversedContent.slice(0, i) : reversedContent.slice(-i);
+				const fields = Object.fromEntries(Object.entries(excluded).filter(([k]) => k !== "type" && !k.startsWith("lc_")));
+				const updatedMessage = _switchTypeToMessage(excluded.getType(), {
+					...fields,
+					content: partialContent
+				});
+				const slicedMessages = [...messagesCopy.slice(0, idx), updatedMessage];
+				if (await tokenCounter(slicedMessages) <= maxTokens) {
+					messagesCopy = slicedMessages;
+					idx += 1;
+					includedPartial = true;
+				} else break;
+			}
+			if (includedPartial && partialStrategy === "last") excluded.content = [...reversedContent].reverse();
+		}
+		if (!includedPartial) {
+			const excluded = messagesCopy[idx];
+			let text;
+			if (Array.isArray(excluded.content) && excluded.content.some((block) => typeof block === "string" || block.type === "text")) {
+				const textBlock = excluded.content.find((block) => block.type === "text" && block.text);
+				text = textBlock?.text;
+			} else if (typeof excluded.content === "string") text = excluded.content;
+			if (text) {
+				const splitTexts = await textSplitter(text);
+				const numSplits = splitTexts.length;
+				if (partialStrategy === "last") splitTexts.reverse();
+				for (let _ = 0; _ < numSplits - 1; _ += 1) {
+					splitTexts.pop();
+					excluded.content = splitTexts.join("");
+					if (await tokenCounter([...messagesCopy.slice(0, idx), excluded]) <= maxTokens) {
+						if (partialStrategy === "last") excluded.content = [...splitTexts].reverse().join("");
+						messagesCopy = [...messagesCopy.slice(0, idx), excluded];
+						idx += 1;
+						break;
+					}
+				}
+			}
+		}
+	}
+	if (endOn) {
+		const endOnArr = Array.isArray(endOn) ? endOn : [endOn];
+		while (idx > 0 && !_isMessageType(messagesCopy[idx - 1], endOnArr)) idx -= 1;
+	}
+	return messagesCopy.slice(0, idx);
+}
+async function _lastMaxTokens(messages, options) {
+	const { allowPartial = false, includeSystem = false, endOn, startOn,...rest } = options;
+	let messagesCopy = messages.map((message) => {
+		const fields = Object.fromEntries(Object.entries(message).filter(([k]) => k !== "type" && !k.startsWith("lc_")));
+		return _switchTypeToMessage(message.getType(), fields, isBaseMessageChunk(message));
+	});
+	if (endOn) {
+		const endOnArr = Array.isArray(endOn) ? endOn : [endOn];
+		while (messagesCopy.length > 0 && !_isMessageType(messagesCopy[messagesCopy.length - 1], endOnArr)) messagesCopy = messagesCopy.slice(0, -1);
+	}
+	const swappedSystem = includeSystem && messagesCopy[0]?.getType() === "system";
+	let reversed_ = swappedSystem ? messagesCopy.slice(0, 1).concat(messagesCopy.slice(1).reverse()) : messagesCopy.reverse();
+	reversed_ = await _firstMaxTokens(reversed_, {
+		...rest,
+		partialStrategy: allowPartial ? "last" : void 0,
+		endOn: startOn
+	});
+	if (swappedSystem) return [reversed_[0], ...reversed_.slice(1).reverse()];
+	else return reversed_.reverse();
+}
+const _MSG_CHUNK_MAP = {
+	human: {
+		message: HumanMessage,
+		messageChunk: HumanMessageChunk
+	},
+	ai: {
+		message: AIMessage,
+		messageChunk: AIMessageChunk
+	},
+	system: {
+		message: SystemMessage,
+		messageChunk: SystemMessageChunk
+	},
+	developer: {
+		message: SystemMessage,
+		messageChunk: SystemMessageChunk
+	},
+	tool: {
+		message: ToolMessage,
+		messageChunk: ToolMessageChunk
+	},
+	function: {
+		message: FunctionMessage,
+		messageChunk: FunctionMessageChunk
+	},
+	generic: {
+		message: ChatMessage,
+		messageChunk: ChatMessageChunk
+	},
+	remove: {
+		message: RemoveMessage,
+		messageChunk: RemoveMessage
+	}
+};
+function _switchTypeToMessage(messageType, fields, returnChunk) {
+	let chunk;
+	let msg;
+	switch (messageType) {
+		case "human":
+			if (returnChunk) chunk = new HumanMessageChunk(fields);
+			else msg = new HumanMessage(fields);
+			break;
+		case "ai":
+			if (returnChunk) {
+				let aiChunkFields = { ...fields };
+				if ("tool_calls" in aiChunkFields) aiChunkFields = {
+					...aiChunkFields,
+					tool_call_chunks: aiChunkFields.tool_calls?.map((tc) => ({
+						...tc,
+						type: "tool_call_chunk",
+						index: void 0,
+						args: JSON.stringify(tc.args)
+					}))
+				};
+				chunk = new AIMessageChunk(aiChunkFields);
+			} else msg = new AIMessage(fields);
+			break;
+		case "system":
+			if (returnChunk) chunk = new SystemMessageChunk(fields);
+			else msg = new SystemMessage(fields);
+			break;
+		case "developer":
+			if (returnChunk) chunk = new SystemMessageChunk({
+				...fields,
+				additional_kwargs: {
+					...fields.additional_kwargs,
+					__openai_role__: "developer"
+				}
+			});
+			else msg = new SystemMessage({
+				...fields,
+				additional_kwargs: {
+					...fields.additional_kwargs,
+					__openai_role__: "developer"
+				}
+			});
+			break;
+		case "tool":
+			if ("tool_call_id" in fields) if (returnChunk) chunk = new ToolMessageChunk(fields);
+			else msg = new ToolMessage(fields);
+			else throw new Error("Can not convert ToolMessage to ToolMessageChunk if 'tool_call_id' field is not defined.");
+			break;
+		case "function":
+			if (returnChunk) chunk = new FunctionMessageChunk(fields);
+			else {
+				if (!fields.name) throw new Error("FunctionMessage must have a 'name' field");
+				msg = new FunctionMessage(fields);
+			}
+			break;
+		case "generic":
+			if ("role" in fields) if (returnChunk) chunk = new ChatMessageChunk(fields);
+			else msg = new ChatMessage(fields);
+			else throw new Error("Can not convert ChatMessage to ChatMessageChunk if 'role' field is not defined.");
+			break;
+		default: throw new Error(`Unrecognized message type ${messageType}`);
+	}
+	if (returnChunk && chunk) return chunk;
+	if (msg) return msg;
+	throw new Error(`Unrecognized message type ${messageType}`);
+}
+function _chunkToMsg(chunk) {
+	const chunkType = chunk.getType();
+	let msg;
+	const fields = Object.fromEntries(Object.entries(chunk).filter(([k]) => !["type", "tool_call_chunks"].includes(k) && !k.startsWith("lc_")));
+	if (chunkType in _MSG_CHUNK_MAP) msg = _switchTypeToMessage(chunkType, fields);
+	if (!msg) throw new Error(`Unrecognized message chunk class ${chunkType}. Supported classes are ${Object.keys(_MSG_CHUNK_MAP)}`);
+	return msg;
+}
+/**
+* The default text splitter function that splits text by newlines.
+*
+* @param {string} text
+* @returns A promise that resolves to an array of strings split by newlines.
+*/
+function defaultTextSplitter(text) {
+	const splits = text.split("\n");
+	return Promise.resolve([...splits.slice(0, -1).map((s) => `${s}\n`), splits[splits.length - 1]]);
+}
+
+//#endregion
+//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/messages/index.js
+var messages_exports = {};
+__export(messages_exports, {
+	AIMessage: () => AIMessage,
+	AIMessageChunk: () => AIMessageChunk,
+	BaseMessage: () => BaseMessage,
+	BaseMessageChunk: () => BaseMessageChunk,
+	ChatMessage: () => ChatMessage,
+	ChatMessageChunk: () => ChatMessageChunk,
+	FunctionMessage: () => FunctionMessage,
+	FunctionMessageChunk: () => FunctionMessageChunk,
+	HumanMessage: () => HumanMessage,
+	HumanMessageChunk: () => HumanMessageChunk,
+	RemoveMessage: () => RemoveMessage,
+	SystemMessage: () => SystemMessage,
+	SystemMessageChunk: () => SystemMessageChunk,
+	ToolMessage: () => ToolMessage,
+	ToolMessageChunk: () => ToolMessageChunk,
+	_isMessageFieldWithRole: () => _isMessageFieldWithRole,
+	_mergeDicts: () => _mergeDicts,
+	_mergeLists: () => _mergeLists,
+	_mergeObj: () => _mergeObj,
+	_mergeStatus: () => _mergeStatus,
+	coerceMessageLikeToMessage: () => coerceMessageLikeToMessage,
+	convertToChunk: () => convertToChunk,
+	convertToOpenAIImageBlock: () => convertToOpenAIImageBlock,
+	convertToProviderContentBlock: () => convertToProviderContentBlock,
+	defaultTextSplitter: () => defaultTextSplitter,
+	filterMessages: () => filterMessages,
+	getBufferString: () => getBufferString,
+	isAIMessage: () => isAIMessage,
+	isAIMessageChunk: () => isAIMessageChunk,
+	isBase64ContentBlock: () => isBase64ContentBlock,
+	isBaseMessage: () => isBaseMessage,
+	isBaseMessageChunk: () => isBaseMessageChunk,
+	isChatMessage: () => isChatMessage,
+	isChatMessageChunk: () => isChatMessageChunk,
+	isDataContentBlock: () => isDataContentBlock,
+	isFunctionMessage: () => isFunctionMessage,
+	isFunctionMessageChunk: () => isFunctionMessageChunk,
+	isHumanMessage: () => isHumanMessage,
+	isHumanMessageChunk: () => isHumanMessageChunk,
+	isIDContentBlock: () => isIDContentBlock,
+	isOpenAIToolCallArray: () => isOpenAIToolCallArray,
+	isPlainTextContentBlock: () => isPlainTextContentBlock,
+	isSystemMessage: () => isSystemMessage,
+	isSystemMessageChunk: () => isSystemMessageChunk,
+	isToolMessage: () => isToolMessage,
+	isToolMessageChunk: () => isToolMessageChunk,
+	isURLContentBlock: () => isURLContentBlock,
+	mapChatMessagesToStoredMessages: () => mapChatMessagesToStoredMessages,
+	mapStoredMessageToChatMessage: () => mapStoredMessageToChatMessage,
+	mapStoredMessagesToChatMessages: () => mapStoredMessagesToChatMessages,
+	mergeContent: () => mergeContent,
+	mergeMessageRuns: () => mergeMessageRuns,
+	parseBase64DataUrl: () => parseBase64DataUrl,
+	parseMimeType: () => parseMimeType,
+	trimMessages: () => trimMessages
+});
+
+//#endregion
+//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/image.js
+/**
+* An image prompt template for a multimodal model.
+*/
+var ImagePromptTemplate = class ImagePromptTemplate extends BasePromptTemplate {
+	static lc_name() {
+		return "ImagePromptTemplate";
+	}
+	constructor(input) {
+		super(input);
+		Object.defineProperty(this, "lc_namespace", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: [
+				"langchain_core",
+				"prompts",
+				"image"
+			]
+		});
+		Object.defineProperty(this, "template", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "templateFormat", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "f-string"
+		});
+		Object.defineProperty(this, "validateTemplate", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+		/**
+		* Additional fields which should be included inside
+		* the message content array if using a complex message
+		* content.
+		*/
+		Object.defineProperty(this, "additionalContentFields", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.template = input.template;
+		this.templateFormat = input.templateFormat ?? this.templateFormat;
+		this.validateTemplate = input.validateTemplate ?? this.validateTemplate;
+		this.additionalContentFields = input.additionalContentFields;
+		if (this.validateTemplate) {
+			let totalInputVariables = this.inputVariables;
+			if (this.partialVariables) totalInputVariables = totalInputVariables.concat(Object.keys(this.partialVariables));
+			checkValidTemplate([{
+				type: "image_url",
+				image_url: this.template
+			}], this.templateFormat, totalInputVariables);
+		}
+	}
+	_getPromptType() {
+		return "prompt";
+	}
+	/**
+	* Partially applies values to the prompt template.
+	* @param values The values to be partially applied to the prompt template.
+	* @returns A new instance of ImagePromptTemplate with the partially applied values.
+	*/
+	async partial(values) {
+		const newInputVariables = this.inputVariables.filter((iv) => !(iv in values));
+		const newPartialVariables = {
+			...this.partialVariables ?? {},
+			...values
+		};
+		const promptDict = {
+			...this,
+			inputVariables: newInputVariables,
+			partialVariables: newPartialVariables
+		};
+		return new ImagePromptTemplate(promptDict);
+	}
+	/**
+	* Formats the prompt template with the provided values.
+	* @param values The values to be used to format the prompt template.
+	* @returns A promise that resolves to a string which is the formatted prompt.
+	*/
+	async format(values) {
+		const formatted = {};
+		for (const [key, value] of Object.entries(this.template)) if (typeof value === "string") formatted[key] = renderTemplate(value, this.templateFormat, values);
+		else formatted[key] = value;
+		const url = values.url || formatted.url;
+		const detail = values.detail || formatted.detail;
+		if (!url) throw new Error("Must provide either an image URL.");
+		if (typeof url !== "string") throw new Error("url must be a string.");
+		const output = { url };
+		if (detail) output.detail = detail;
+		return output;
+	}
+	/**
+	* Formats the prompt given the input values and returns a formatted
+	* prompt value.
+	* @param values The input values to format the prompt.
+	* @returns A Promise that resolves to a formatted prompt value.
+	*/
+	async formatPromptValue(values) {
+		const formattedPrompt = await this.format(values);
+		return new ImagePromptValue(formattedPrompt);
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/dict.js
+var DictPromptTemplate = class extends Runnable {
+	static lc_name() {
+		return "DictPromptTemplate";
+	}
+	constructor(fields) {
+		const templateFormat = fields.templateFormat ?? "f-string";
+		const inputVariables = _getInputVariables(fields.template, templateFormat);
+		super({
+			inputVariables,
+			...fields
+		});
+		Object.defineProperty(this, "lc_namespace", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: [
+				"langchain_core",
+				"prompts",
+				"dict"
+			]
+		});
+		Object.defineProperty(this, "lc_serializable", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+		Object.defineProperty(this, "template", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "templateFormat", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "inputVariables", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.template = fields.template;
+		this.templateFormat = templateFormat;
+		this.inputVariables = inputVariables;
+	}
+	async format(values) {
+		return _insertInputVariables(this.template, values, this.templateFormat);
+	}
+	async invoke(values) {
+		return await this._callWithConfig(this.format.bind(this), values, { runType: "prompt" });
+	}
+};
+function _getInputVariables(template, templateFormat) {
+	const inputVariables = [];
+	for (const v of Object.values(template)) if (typeof v === "string") parseTemplate(v, templateFormat).forEach((t) => {
+		if (t.type === "variable") inputVariables.push(t.name);
+	});
+	else if (Array.isArray(v)) {
+		for (const x of v) if (typeof x === "string") parseTemplate(x, templateFormat).forEach((t) => {
+			if (t.type === "variable") inputVariables.push(t.name);
+		});
+		else if (typeof x === "object") inputVariables.push(..._getInputVariables(x, templateFormat));
+	} else if (typeof v === "object" && v !== null) inputVariables.push(..._getInputVariables(v, templateFormat));
+	return Array.from(new Set(inputVariables));
+}
+function _insertInputVariables(template, inputs, templateFormat) {
+	const formatted = {};
+	for (const [k, v] of Object.entries(template)) if (typeof v === "string") formatted[k] = renderTemplate(v, templateFormat, inputs);
+	else if (Array.isArray(v)) {
+		const formattedV = [];
+		for (const x of v) if (typeof x === "string") formattedV.push(renderTemplate(x, templateFormat, inputs));
+		else if (typeof x === "object") formattedV.push(_insertInputVariables(x, inputs, templateFormat));
+		formatted[k] = formattedV;
+	} else if (typeof v === "object" && v !== null) formatted[k] = _insertInputVariables(v, inputs, templateFormat);
+	else formatted[k] = v;
+	return formatted;
+}
+
+//#endregion
+//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/chat.js
+/**
+* Abstract class that serves as a base for creating message prompt
+* templates. It defines how to format messages for different roles in a
+* conversation.
+*/
+var BaseMessagePromptTemplate = class extends Runnable {
+	constructor() {
+		super(...arguments);
+		Object.defineProperty(this, "lc_namespace", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: [
+				"langchain_core",
+				"prompts",
+				"chat"
+			]
+		});
+		Object.defineProperty(this, "lc_serializable", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+	}
+	/**
+	* Calls the formatMessages method with the provided input and options.
+	* @param input Input for the formatMessages method
+	* @param options Optional BaseCallbackConfig
+	* @returns Formatted output messages
+	*/
+	async invoke(input, options) {
+		return this._callWithConfig((input$1) => this.formatMessages(input$1), input, {
+			...options,
+			runType: "prompt"
+		});
+	}
+};
+/**
+* Class that represents a placeholder for messages in a chat prompt. It
+* extends the BaseMessagePromptTemplate.
+*/
+var MessagesPlaceholder = class extends BaseMessagePromptTemplate {
+	static lc_name() {
+		return "MessagesPlaceholder";
+	}
+	constructor(fields) {
+		if (typeof fields === "string") fields = { variableName: fields };
+		super(fields);
+		Object.defineProperty(this, "variableName", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "optional", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.variableName = fields.variableName;
+		this.optional = fields.optional ?? false;
+	}
+	get inputVariables() {
+		return [this.variableName];
+	}
+	async formatMessages(values) {
+		const input = values[this.variableName];
+		if (this.optional && !input) return [];
+		else if (!input) {
+			const error = new Error(`Field "${this.variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`);
+			error.name = "InputFormatError";
+			throw error;
+		}
+		let formattedMessages;
+		try {
+			if (Array.isArray(input)) formattedMessages = input.map(coerceMessageLikeToMessage);
+			else formattedMessages = [coerceMessageLikeToMessage(input)];
+		} catch (e) {
+			const readableInput = typeof input === "string" ? input : JSON.stringify(input, null, 2);
+			const error = new Error([
+				`Field "${this.variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages or coerceable values as input.`,
+				`Received value: ${readableInput}`,
+				`Additional message: ${e.message}`
+			].join("\n\n"));
+			error.name = "InputFormatError";
+			error.lc_error_code = e.lc_error_code;
+			throw error;
+		}
+		return formattedMessages;
+	}
+};
+/**
+* Abstract class that serves as a base for creating message string prompt
+* templates. It extends the BaseMessagePromptTemplate.
+*/
+var BaseMessageStringPromptTemplate = class extends BaseMessagePromptTemplate {
+	constructor(fields) {
+		if (!("prompt" in fields)) fields = { prompt: fields };
+		super(fields);
+		Object.defineProperty(this, "prompt", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.prompt = fields.prompt;
+	}
+	get inputVariables() {
+		return this.prompt.inputVariables;
+	}
+	async formatMessages(values) {
+		return [await this.format(values)];
+	}
+};
+/**
+* Abstract class that serves as a base for creating chat prompt
+* templates. It extends the BasePromptTemplate.
+*/
+var BaseChatPromptTemplate = class extends BasePromptTemplate {
+	constructor(input) {
+		super(input);
+	}
+	async format(values) {
+		return (await this.formatPromptValue(values)).toString();
+	}
+	async formatPromptValue(values) {
+		const resultMessages = await this.formatMessages(values);
+		return new ChatPromptValue(resultMessages);
+	}
+};
+/**
+* Class that represents a chat message prompt template. It extends the
+* BaseMessageStringPromptTemplate.
+*/
+var ChatMessagePromptTemplate = class extends BaseMessageStringPromptTemplate {
+	static lc_name() {
+		return "ChatMessagePromptTemplate";
+	}
+	constructor(fields, role) {
+		if (!("prompt" in fields)) fields = {
+			prompt: fields,
+			role
+		};
+		super(fields);
+		Object.defineProperty(this, "role", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.role = fields.role;
+	}
+	async format(values) {
+		return new ChatMessage(await this.prompt.format(values), this.role);
+	}
+	static fromTemplate(template, role, options) {
+		return new this(PromptTemplate.fromTemplate(template, { templateFormat: options?.templateFormat }), role);
+	}
+};
+function isTextTemplateParam(param) {
+	if (param === null || typeof param !== "object" || Array.isArray(param)) return false;
+	return Object.keys(param).length === 1 && "text" in param && typeof param.text === "string";
+}
+function isImageTemplateParam(param) {
+	if (param === null || typeof param !== "object" || Array.isArray(param)) return false;
+	return "image_url" in param && (typeof param.image_url === "string" || typeof param.image_url === "object" && param.image_url !== null && "url" in param.image_url && typeof param.image_url.url === "string");
+}
+var _StringImageMessagePromptTemplate = class extends BaseMessagePromptTemplate {
+	static _messageClass() {
+		throw new Error("Can not invoke _messageClass from inside _StringImageMessagePromptTemplate");
+	}
+	constructor(fields, additionalOptions) {
+		if (!("prompt" in fields)) fields = { prompt: fields };
+		super(fields);
+		Object.defineProperty(this, "lc_namespace", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: [
+				"langchain_core",
+				"prompts",
+				"chat"
+			]
+		});
+		Object.defineProperty(this, "lc_serializable", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+		Object.defineProperty(this, "inputVariables", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: []
+		});
+		Object.defineProperty(this, "additionalOptions", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: {}
+		});
+		Object.defineProperty(this, "prompt", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "messageClass", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "chatMessageClass", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.prompt = fields.prompt;
+		if (Array.isArray(this.prompt)) {
+			let inputVariables = [];
+			this.prompt.forEach((prompt) => {
+				if ("inputVariables" in prompt) inputVariables = inputVariables.concat(prompt.inputVariables);
+			});
+			this.inputVariables = inputVariables;
+		} else this.inputVariables = this.prompt.inputVariables;
+		this.additionalOptions = additionalOptions ?? this.additionalOptions;
+	}
+	createMessage(content) {
+		const constructor = this.constructor;
+		if (constructor._messageClass()) {
+			const MsgClass = constructor._messageClass();
+			return new MsgClass({ content });
+		} else if (constructor.chatMessageClass) {
+			const MsgClass = constructor.chatMessageClass();
+			return new MsgClass({
+				content,
+				role: this.getRoleFromMessageClass(MsgClass.lc_name())
+			});
+		} else throw new Error("No message class defined");
+	}
+	getRoleFromMessageClass(name) {
+		switch (name) {
+			case "HumanMessage": return "human";
+			case "AIMessage": return "ai";
+			case "SystemMessage": return "system";
+			case "ChatMessage": return "chat";
+			default: throw new Error("Invalid message class name");
+		}
+	}
+	static fromTemplate(template, additionalOptions) {
+		if (typeof template === "string") return new this(PromptTemplate.fromTemplate(template, additionalOptions));
+		const prompt = [];
+		for (const item of template) if (typeof item === "string") prompt.push(PromptTemplate.fromTemplate(item, additionalOptions));
+		else if (item === null) {} else if (isTextTemplateParam(item)) {
+			let text = "";
+			if (typeof item.text === "string") text = item.text ?? "";
+			const options = {
+				...additionalOptions,
+				additionalContentFields: item
+			};
+			prompt.push(PromptTemplate.fromTemplate(text, options));
+		} else if (isImageTemplateParam(item)) {
+			let imgTemplate = item.image_url ?? "";
+			let imgTemplateObject;
+			let inputVariables = [];
+			if (typeof imgTemplate === "string") {
+				let parsedTemplate;
+				if (additionalOptions?.templateFormat === "mustache") parsedTemplate = parseMustache(imgTemplate);
+				else parsedTemplate = parseFString(imgTemplate);
+				const variables = parsedTemplate.flatMap((item$1) => item$1.type === "variable" ? [item$1.name] : []);
+				if ((variables?.length ?? 0) > 0) {
+					if (variables.length > 1) throw new Error(`Only one format variable allowed per image template.\nGot: ${variables}\nFrom: ${imgTemplate}`);
+					inputVariables = [variables[0]];
+				} else inputVariables = [];
+				imgTemplate = { url: imgTemplate };
+				imgTemplateObject = new ImagePromptTemplate({
+					template: imgTemplate,
+					inputVariables,
+					templateFormat: additionalOptions?.templateFormat,
+					additionalContentFields: item
+				});
+			} else if (typeof imgTemplate === "object") {
+				if ("url" in imgTemplate) {
+					let parsedTemplate;
+					if (additionalOptions?.templateFormat === "mustache") parsedTemplate = parseMustache(imgTemplate.url);
+					else parsedTemplate = parseFString(imgTemplate.url);
+					inputVariables = parsedTemplate.flatMap((item$1) => item$1.type === "variable" ? [item$1.name] : []);
+				} else inputVariables = [];
+				imgTemplateObject = new ImagePromptTemplate({
+					template: imgTemplate,
+					inputVariables,
+					templateFormat: additionalOptions?.templateFormat,
+					additionalContentFields: item
+				});
+			} else throw new Error("Invalid image template");
+			prompt.push(imgTemplateObject);
+		} else if (typeof item === "object") prompt.push(new DictPromptTemplate({
+			template: item,
+			templateFormat: additionalOptions?.templateFormat
+		}));
+		return new this({
+			prompt,
+			additionalOptions
+		});
+	}
+	async format(input) {
+		if (this.prompt instanceof BaseStringPromptTemplate) {
+			const text = await this.prompt.format(input);
+			return this.createMessage(text);
+		} else {
+			const content = [];
+			for (const prompt of this.prompt) {
+				let inputs = {};
+				if (!("inputVariables" in prompt)) throw new Error(`Prompt ${prompt} does not have inputVariables defined.`);
+				for (const item of prompt.inputVariables) {
+					if (!inputs) inputs = { [item]: input[item] };
+					inputs = {
+						...inputs,
+						[item]: input[item]
+					};
+				}
+				if (prompt instanceof BaseStringPromptTemplate) {
+					const formatted = await prompt.format(inputs);
+					let additionalContentFields;
+					if ("additionalContentFields" in prompt) additionalContentFields = prompt.additionalContentFields;
+					content.push({
+						...additionalContentFields,
+						type: "text",
+						text: formatted
+					});
+				} else if (prompt instanceof ImagePromptTemplate) {
+					const formatted = await prompt.format(inputs);
+					let additionalContentFields;
+					if ("additionalContentFields" in prompt) additionalContentFields = prompt.additionalContentFields;
+					content.push({
+						...additionalContentFields,
+						type: "image_url",
+						image_url: formatted
+					});
+				} else if (prompt instanceof DictPromptTemplate) {
+					const formatted = await prompt.format(inputs);
+					let additionalContentFields;
+					if ("additionalContentFields" in prompt) additionalContentFields = prompt.additionalContentFields;
+					content.push({
+						...additionalContentFields,
+						...formatted
+					});
+				}
+			}
+			return this.createMessage(content);
+		}
+	}
+	async formatMessages(values) {
+		return [await this.format(values)];
+	}
+};
+/**
+* Class that represents a human message prompt template. It extends the
+* BaseMessageStringPromptTemplate.
+* @example
+* ```typescript
+* const message = HumanMessagePromptTemplate.fromTemplate("{text}");
+* const formatted = await message.format({ text: "Hello world!" });
+*
+* const chatPrompt = ChatPromptTemplate.fromMessages([message]);
+* const formattedChatPrompt = await chatPrompt.invoke({
+*   text: "Hello world!",
+* });
+* ```
+*/
+var HumanMessagePromptTemplate = class extends _StringImageMessagePromptTemplate {
+	static _messageClass() {
+		return HumanMessage;
+	}
+	static lc_name() {
+		return "HumanMessagePromptTemplate";
+	}
+};
+/**
+* Class that represents an AI message prompt template. It extends the
+* BaseMessageStringPromptTemplate.
+*/
+var AIMessagePromptTemplate = class extends _StringImageMessagePromptTemplate {
+	static _messageClass() {
+		return AIMessage;
+	}
+	static lc_name() {
+		return "AIMessagePromptTemplate";
+	}
+};
+/**
+* Class that represents a system message prompt template. It extends the
+* BaseMessageStringPromptTemplate.
+* @example
+* ```typescript
+* const message = SystemMessagePromptTemplate.fromTemplate("{text}");
+* const formatted = await message.format({ text: "Hello world!" });
+*
+* const chatPrompt = ChatPromptTemplate.fromMessages([message]);
+* const formattedChatPrompt = await chatPrompt.invoke({
+*   text: "Hello world!",
+* });
+* ```
+*/
+var SystemMessagePromptTemplate = class extends _StringImageMessagePromptTemplate {
+	static _messageClass() {
+		return SystemMessage;
+	}
+	static lc_name() {
+		return "SystemMessagePromptTemplate";
+	}
+};
+function _isBaseMessagePromptTemplate(baseMessagePromptTemplateLike) {
+	return typeof baseMessagePromptTemplateLike.formatMessages === "function";
+}
+function _coerceMessagePromptTemplateLike(messagePromptTemplateLike, extra) {
+	if (_isBaseMessagePromptTemplate(messagePromptTemplateLike) || isBaseMessage(messagePromptTemplateLike)) return messagePromptTemplateLike;
+	if (Array.isArray(messagePromptTemplateLike) && messagePromptTemplateLike[0] === "placeholder") {
+		const messageContent = messagePromptTemplateLike[1];
+		if (extra?.templateFormat === "mustache" && typeof messageContent === "string" && messageContent.slice(0, 2) === "{{" && messageContent.slice(-2) === "}}") {
+			const variableName = messageContent.slice(2, -2);
+			return new MessagesPlaceholder({
+				variableName,
+				optional: true
+			});
+		} else if (typeof messageContent === "string" && messageContent[0] === "{" && messageContent[messageContent.length - 1] === "}") {
+			const variableName = messageContent.slice(1, -1);
+			return new MessagesPlaceholder({
+				variableName,
+				optional: true
+			});
+		}
+		throw new Error(`Invalid placeholder template for format ${extra?.templateFormat ?? `"f-string"`}: "${messagePromptTemplateLike[1]}". Expected a variable name surrounded by ${extra?.templateFormat === "mustache" ? "double" : "single"} curly braces.`);
+	}
+	const message = coerceMessageLikeToMessage(messagePromptTemplateLike);
+	let templateData;
+	if (typeof message.content === "string") templateData = message.content;
+	else templateData = message.content.map((item) => {
+		if ("text" in item) return {
+			...item,
+			text: item.text
+		};
+		else if ("image_url" in item) return {
+			...item,
+			image_url: item.image_url
+		};
+		else return item;
+	});
+	if (message._getType() === "human") return HumanMessagePromptTemplate.fromTemplate(templateData, extra);
+	else if (message._getType() === "ai") return AIMessagePromptTemplate.fromTemplate(templateData, extra);
+	else if (message._getType() === "system") return SystemMessagePromptTemplate.fromTemplate(templateData, extra);
+	else if (ChatMessage.isInstance(message)) return ChatMessagePromptTemplate.fromTemplate(message.content, message.role, extra);
+	else throw new Error(`Could not coerce message prompt template from input. Received message type: "${message._getType()}".`);
+}
+function isMessagesPlaceholder(x) {
+	return x.constructor.lc_name() === "MessagesPlaceholder";
+}
+/**
+* Class that represents a chat prompt. It extends the
+* BaseChatPromptTemplate and uses an array of BaseMessagePromptTemplate
+* instances to format a series of messages for a conversation.
+* @example
+* ```typescript
+* const message = SystemMessagePromptTemplate.fromTemplate("{text}");
+* const chatPrompt = ChatPromptTemplate.fromMessages([
+*   ["ai", "You are a helpful assistant."],
+*   message,
+* ]);
+* const formattedChatPrompt = await chatPrompt.invoke({
+*   text: "Hello world!",
+* });
+* ```
+*/
+var ChatPromptTemplate = class ChatPromptTemplate extends BaseChatPromptTemplate {
+	static lc_name() {
+		return "ChatPromptTemplate";
+	}
+	get lc_aliases() {
+		return { promptMessages: "messages" };
+	}
+	constructor(input) {
+		super(input);
+		Object.defineProperty(this, "promptMessages", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "validateTemplate", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+		Object.defineProperty(this, "templateFormat", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "f-string"
+		});
+		if (input.templateFormat === "mustache" && input.validateTemplate === void 0) this.validateTemplate = false;
+		Object.assign(this, input);
+		if (this.validateTemplate) {
+			const inputVariablesMessages = /* @__PURE__ */ new Set();
+			for (const promptMessage of this.promptMessages) {
+				if (promptMessage instanceof BaseMessage) continue;
+				for (const inputVariable of promptMessage.inputVariables) inputVariablesMessages.add(inputVariable);
+			}
+			const totalInputVariables = this.inputVariables;
+			const inputVariablesInstance = new Set(this.partialVariables ? totalInputVariables.concat(Object.keys(this.partialVariables)) : totalInputVariables);
+			const difference = new Set([...inputVariablesInstance].filter((x) => !inputVariablesMessages.has(x)));
+			if (difference.size > 0) throw new Error(`Input variables \`${[...difference]}\` are not used in any of the prompt messages.`);
+			const otherDifference = new Set([...inputVariablesMessages].filter((x) => !inputVariablesInstance.has(x)));
+			if (otherDifference.size > 0) throw new Error(`Input variables \`${[...otherDifference]}\` are used in prompt messages but not in the prompt template.`);
+		}
+	}
+	_getPromptType() {
+		return "chat";
+	}
+	async _parseImagePrompts(message, inputValues) {
+		if (typeof message.content === "string") return message;
+		const formattedMessageContent = await Promise.all(message.content.map(async (item) => {
+			if (item.type !== "image_url") return item;
+			let imageUrl = "";
+			if (typeof item.image_url === "string") imageUrl = item.image_url;
+			else imageUrl = item.image_url.url;
+			const promptTemplatePlaceholder = PromptTemplate.fromTemplate(imageUrl, { templateFormat: this.templateFormat });
+			const formattedUrl = await promptTemplatePlaceholder.format(inputValues);
+			if (typeof item.image_url !== "string" && "url" in item.image_url) item.image_url.url = formattedUrl;
+			else item.image_url = formattedUrl;
+			return item;
+		}));
+		message.content = formattedMessageContent;
+		return message;
+	}
+	async formatMessages(values) {
+		const allValues = await this.mergePartialAndUserVariables(values);
+		let resultMessages = [];
+		for (const promptMessage of this.promptMessages) if (promptMessage instanceof BaseMessage) resultMessages.push(await this._parseImagePrompts(promptMessage, allValues));
+		else {
+			const inputValues = promptMessage.inputVariables.reduce((acc, inputVariable) => {
+				if (!(inputVariable in allValues) && !(isMessagesPlaceholder(promptMessage) && promptMessage.optional)) {
+					const error = addLangChainErrorFields(new Error(`Missing value for input variable \`${inputVariable.toString()}\``), "INVALID_PROMPT_INPUT");
+					throw error;
+				}
+				acc[inputVariable] = allValues[inputVariable];
+				return acc;
+			}, {});
+			const message = await promptMessage.formatMessages(inputValues);
+			resultMessages = resultMessages.concat(message);
+		}
+		return resultMessages;
+	}
+	async partial(values) {
+		const newInputVariables = this.inputVariables.filter((iv) => !(iv in values));
+		const newPartialVariables = {
+			...this.partialVariables ?? {},
+			...values
+		};
+		const promptDict = {
+			...this,
+			inputVariables: newInputVariables,
+			partialVariables: newPartialVariables
+		};
+		return new ChatPromptTemplate(promptDict);
+	}
+	static fromTemplate(template, options) {
+		const prompt = PromptTemplate.fromTemplate(template, options);
+		const humanTemplate = new HumanMessagePromptTemplate({ prompt });
+		return this.fromMessages([humanTemplate]);
+	}
+	/**
+	* Create a chat model-specific prompt from individual chat messages
+	* or message-like tuples.
+	* @param promptMessages Messages to be passed to the chat model
+	* @returns A new ChatPromptTemplate
+	*/
+	static fromMessages(promptMessages, extra) {
+		const flattenedMessages = promptMessages.reduce((acc, promptMessage) => acc.concat(promptMessage instanceof ChatPromptTemplate ? promptMessage.promptMessages : [_coerceMessagePromptTemplateLike(promptMessage, extra)]), []);
+		const flattenedPartialVariables = promptMessages.reduce((acc, promptMessage) => promptMessage instanceof ChatPromptTemplate ? Object.assign(acc, promptMessage.partialVariables) : acc, Object.create(null));
+		const inputVariables = /* @__PURE__ */ new Set();
+		for (const promptMessage of flattenedMessages) {
+			if (promptMessage instanceof BaseMessage) continue;
+			for (const inputVariable of promptMessage.inputVariables) {
+				if (inputVariable in flattenedPartialVariables) continue;
+				inputVariables.add(inputVariable);
+			}
+		}
+		return new this({
+			...extra,
+			inputVariables: [...inputVariables],
+			promptMessages: flattenedMessages,
+			partialVariables: flattenedPartialVariables,
+			templateFormat: extra?.templateFormat
+		});
+	}
+	/** @deprecated Renamed to .fromMessages */
+	static fromPromptMessages(promptMessages) {
+		return this.fromMessages(promptMessages);
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/@langchain+core@0.3.57_openai@5.3.0_ws@8.18.2_zod@3.25.57_/node_modules/@langchain/core/dist/prompts/few_shot.js
+/**
+* Prompt template that contains few-shot examples.
+* @augments BasePromptTemplate
+* @augments FewShotPromptTemplateInput
+* @example
+* ```typescript
+* const examplePrompt = PromptTemplate.fromTemplate(
+*   "Input: {input}\nOutput: {output}",
+* );
+*
+* const exampleSelector = await SemanticSimilarityExampleSelector.fromExamples(
+*   [
+*     { input: "happy", output: "sad" },
+*     { input: "tall", output: "short" },
+*     { input: "energetic", output: "lethargic" },
+*     { input: "sunny", output: "gloomy" },
+*     { input: "windy", output: "calm" },
+*   ],
+*   new OpenAIEmbeddings(),
+*   HNSWLib,
+*   { k: 1 },
+* );
+*
+* const dynamicPrompt = new FewShotPromptTemplate({
+*   exampleSelector,
+*   examplePrompt,
+*   prefix: "Give the antonym of every input",
+*   suffix: "Input: {adjective}\nOutput:",
+*   inputVariables: ["adjective"],
+* });
+*
+* // Format the dynamic prompt with the input 'rainy'
+* console.log(await dynamicPrompt.format({ adjective: "rainy" }));
+*
+* ```
+*/
+var FewShotPromptTemplate = class FewShotPromptTemplate extends BaseStringPromptTemplate {
+	constructor(input) {
+		super(input);
+		Object.defineProperty(this, "lc_serializable", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: false
+		});
+		Object.defineProperty(this, "examples", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "exampleSelector", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "examplePrompt", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "suffix", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: ""
+		});
+		Object.defineProperty(this, "exampleSeparator", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "\n\n"
+		});
+		Object.defineProperty(this, "prefix", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: ""
+		});
+		Object.defineProperty(this, "templateFormat", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "f-string"
+		});
+		Object.defineProperty(this, "validateTemplate", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+		Object.assign(this, input);
+		if (this.examples !== void 0 && this.exampleSelector !== void 0) throw new Error("Only one of 'examples' and 'example_selector' should be provided");
+		if (this.examples === void 0 && this.exampleSelector === void 0) throw new Error("One of 'examples' and 'example_selector' should be provided");
+		if (this.validateTemplate) {
+			let totalInputVariables = this.inputVariables;
+			if (this.partialVariables) totalInputVariables = totalInputVariables.concat(Object.keys(this.partialVariables));
+			checkValidTemplate(this.prefix + this.suffix, this.templateFormat, totalInputVariables);
+		}
+	}
+	_getPromptType() {
+		return "few_shot";
+	}
+	static lc_name() {
+		return "FewShotPromptTemplate";
+	}
+	async getExamples(inputVariables) {
+		if (this.examples !== void 0) return this.examples;
+		if (this.exampleSelector !== void 0) return this.exampleSelector.selectExamples(inputVariables);
+		throw new Error("One of 'examples' and 'example_selector' should be provided");
+	}
+	async partial(values) {
+		const newInputVariables = this.inputVariables.filter((iv) => !(iv in values));
+		const newPartialVariables = {
+			...this.partialVariables ?? {},
+			...values
+		};
+		const promptDict = {
+			...this,
+			inputVariables: newInputVariables,
+			partialVariables: newPartialVariables
+		};
+		return new FewShotPromptTemplate(promptDict);
+	}
+	/**
+	* Formats the prompt with the given values.
+	* @param values The values to format the prompt with.
+	* @returns A promise that resolves to a string representing the formatted prompt.
+	*/
+	async format(values) {
+		const allValues = await this.mergePartialAndUserVariables(values);
+		const examples = await this.getExamples(allValues);
+		const exampleStrings = await Promise.all(examples.map((example) => this.examplePrompt.format(example)));
+		const template = [
+			this.prefix,
+			...exampleStrings,
+			this.suffix
+		].join(this.exampleSeparator);
+		return renderTemplate(template, this.templateFormat, allValues);
+	}
+	serialize() {
+		if (this.exampleSelector || !this.examples) throw new Error("Serializing an example selector is not currently supported");
+		if (this.outputParser !== void 0) throw new Error("Serializing an output parser is not currently supported");
+		return {
+			_type: this._getPromptType(),
+			input_variables: this.inputVariables,
+			example_prompt: this.examplePrompt.serialize(),
+			example_separator: this.exampleSeparator,
+			suffix: this.suffix,
+			prefix: this.prefix,
+			template_format: this.templateFormat,
+			examples: this.examples
+		};
+	}
+	static async deserialize(data) {
+		const { example_prompt } = data;
+		if (!example_prompt) throw new Error("Missing example prompt");
+		const examplePrompt = await PromptTemplate.deserialize(example_prompt);
+		let examples;
+		if (Array.isArray(data.examples)) examples = data.examples;
+		else throw new Error("Invalid examples format. Only list or string are supported.");
+		return new FewShotPromptTemplate({
+			inputVariables: data.input_variables,
+			examplePrompt,
+			examples,
+			exampleSeparator: data.example_separator,
+			prefix: data.prefix,
+			suffix: data.suffix,
+			templateFormat: data.template_format
+		});
+	}
+};
+/**
+* Chat prompt template that contains few-shot examples.
+* @augments BasePromptTemplateInput
+* @augments FewShotChatMessagePromptTemplateInput
+*/
+var FewShotChatMessagePromptTemplate = class FewShotChatMessagePromptTemplate extends BaseChatPromptTemplate {
+	_getPromptType() {
+		return "few_shot_chat";
+	}
+	static lc_name() {
+		return "FewShotChatMessagePromptTemplate";
+	}
+	constructor(fields) {
+		super(fields);
+		Object.defineProperty(this, "lc_serializable", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+		Object.defineProperty(this, "examples", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "exampleSelector", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "examplePrompt", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "suffix", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: ""
+		});
+		Object.defineProperty(this, "exampleSeparator", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "\n\n"
+		});
+		Object.defineProperty(this, "prefix", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: ""
+		});
+		Object.defineProperty(this, "templateFormat", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "f-string"
+		});
+		Object.defineProperty(this, "validateTemplate", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: true
+		});
+		this.examples = fields.examples;
+		this.examplePrompt = fields.examplePrompt;
+		this.exampleSeparator = fields.exampleSeparator ?? "\n\n";
+		this.exampleSelector = fields.exampleSelector;
+		this.prefix = fields.prefix ?? "";
+		this.suffix = fields.suffix ?? "";
+		this.templateFormat = fields.templateFormat ?? "f-string";
+		this.validateTemplate = fields.validateTemplate ?? true;
+		if (this.examples !== void 0 && this.exampleSelector !== void 0) throw new Error("Only one of 'examples' and 'example_selector' should be provided");
+		if (this.examples === void 0 && this.exampleSelector === void 0) throw new Error("One of 'examples' and 'example_selector' should be provided");
+		if (this.validateTemplate) {
+			let totalInputVariables = this.inputVariables;
+			if (this.partialVariables) totalInputVariables = totalInputVariables.concat(Object.keys(this.partialVariables));
+			checkValidTemplate(this.prefix + this.suffix, this.templateFormat, totalInputVariables);
+		}
+	}
+	async getExamples(inputVariables) {
+		if (this.examples !== void 0) return this.examples;
+		if (this.exampleSelector !== void 0) return this.exampleSelector.selectExamples(inputVariables);
+		throw new Error("One of 'examples' and 'example_selector' should be provided");
+	}
+	/**
+	* Formats the list of values and returns a list of formatted messages.
+	* @param values The values to format the prompt with.
+	* @returns A promise that resolves to a string representing the formatted prompt.
+	*/
+	async formatMessages(values) {
+		const allValues = await this.mergePartialAndUserVariables(values);
+		let examples = await this.getExamples(allValues);
+		examples = examples.map((example) => {
+			const result = {};
+			this.examplePrompt.inputVariables.forEach((inputVariable) => {
+				result[inputVariable] = example[inputVariable];
+			});
+			return result;
+		});
+		const messages = [];
+		for (const example of examples) {
+			const exampleMessages = await this.examplePrompt.formatMessages(example);
+			messages.push(...exampleMessages);
+		}
+		return messages;
+	}
+	/**
+	* Formats the prompt with the given values.
+	* @param values The values to format the prompt with.
+	* @returns A promise that resolves to a string representing the formatted prompt.
+	*/
+	async format(values) {
+		const allValues = await this.mergePartialAndUserVariables(values);
+		const examples = await this.getExamples(allValues);
+		const exampleMessages = await Promise.all(examples.map((example) => this.examplePrompt.formatMessages(example)));
+		const exampleStrings = exampleMessages.flat().map((message) => message.content);
+		const template = [
+			this.prefix,
+			...exampleStrings,
+			this.suffix
+		].join(this.exampleSeparator);
+		return renderTemplate(template, this.templateFormat, allValues);
+	}
+	/**
+	* Partially formats the prompt with the given values.
+	* @param values The values to partially format the prompt with.
+	* @returns A promise that resolves to an instance of `FewShotChatMessagePromptTemplate` with the given values partially formatted.
+	*/
+	async partial(values) {
+		const newInputVariables = this.inputVariables.filter((variable) => !(variable in values));
+		const newPartialVariables = {
+			...this.partialVariables ?? {},
+			...values
+		};
+		const promptDict = {
+			...this,
+			inputVariables: newInputVariables,
+			partialVariables: newPartialVariables
+		};
+		return new FewShotChatMessagePromptTemplate(promptDict);
+	}
+};
+
+//#endregion
+export { AIMessagePromptTemplate, BaseChatPromptTemplate, BaseMessagePromptTemplate, BaseMessageStringPromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, DictPromptTemplate, FewShotChatMessagePromptTemplate, FewShotPromptTemplate, HumanMessagePromptTemplate, ImagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, messages_exports };

dist/few_shot-C9MZ9K-V.mjs

@@ -0,0 +1,4 @@
+import "./prompt-Cmq1pjHH.mjs";
+import { FewShotChatMessagePromptTemplate, FewShotPromptTemplate } from "./few_shot-BBzZpDUy.mjs";
+
+export { FewShotPromptTemplate };

dist/fileFromPath-Dg7PGDJc.mjs

@@ -0,0 +1,97 @@
+import { __commonJS, __require, __toESM } from "./chunk-Dx39-ABv.mjs";
+import { File, isFile } from "./isFile-CMs-SNI_.mjs";
+import { createReadStream, promises } from "fs";
+import { basename } from "path";
+
+//#region node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js
+var require_node_domexception = __commonJS({ "node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js"(exports, module) {
+	/*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+	if (!globalThis.DOMException) try {
+		const { MessageChannel } = __require("worker_threads"), port = new MessageChannel().port1, ab = new ArrayBuffer();
+		port.postMessage(ab, [ab, ab]);
+	} catch (err) {
+		err.constructor.name === "DOMException" && (globalThis.DOMException = err.constructor);
+	}
+	module.exports = globalThis.DOMException;
+} });
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/isPlainObject.js
+const getType = (value) => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+function isPlainObject(value) {
+	if (getType(value) !== "object") return false;
+	const pp = Object.getPrototypeOf(value);
+	if (pp === null || pp === void 0) return true;
+	const Ctor = pp.constructor && pp.constructor.toString();
+	return Ctor === Object.toString();
+}
+var isPlainObject_default = isPlainObject;
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/fileFromPath.js
+var import_node_domexception = __toESM(require_node_domexception(), 1);
+var __classPrivateFieldSet = void 0 && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = void 0 && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FileFromPath_path, _FileFromPath_start;
+const MESSAGE = "The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.";
+var FileFromPath = class FileFromPath {
+	constructor(input) {
+		_FileFromPath_path.set(this, void 0);
+		_FileFromPath_start.set(this, void 0);
+		__classPrivateFieldSet(this, _FileFromPath_path, input.path, "f");
+		__classPrivateFieldSet(this, _FileFromPath_start, input.start || 0, "f");
+		this.name = basename(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+		this.size = input.size;
+		this.lastModified = input.lastModified;
+	}
+	slice(start, end) {
+		return new FileFromPath({
+			path: __classPrivateFieldGet(this, _FileFromPath_path, "f"),
+			lastModified: this.lastModified,
+			size: end - start,
+			start
+		});
+	}
+	async *stream() {
+		const { mtimeMs } = await promises.stat(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+		if (mtimeMs > this.lastModified) throw new import_node_domexception.default(MESSAGE, "NotReadableError");
+		if (this.size) yield* createReadStream(__classPrivateFieldGet(this, _FileFromPath_path, "f"), {
+			start: __classPrivateFieldGet(this, _FileFromPath_start, "f"),
+			end: __classPrivateFieldGet(this, _FileFromPath_start, "f") + this.size - 1
+		});
+	}
+	get [(_FileFromPath_path = /* @__PURE__ */ new WeakMap(), _FileFromPath_start = /* @__PURE__ */ new WeakMap(), Symbol.toStringTag)]() {
+		return "File";
+	}
+};
+function createFileFromPath(path, { mtimeMs, size }, filenameOrOptions, options = {}) {
+	let filename;
+	if (isPlainObject_default(filenameOrOptions)) [options, filename] = [filenameOrOptions, void 0];
+	else filename = filenameOrOptions;
+	const file = new FileFromPath({
+		path,
+		size,
+		lastModified: mtimeMs
+	});
+	if (!filename) filename = file.name;
+	return new File([file], filename, {
+		...options,
+		lastModified: file.lastModified
+	});
+}
+async function fileFromPath(path, filenameOrOptions, options) {
+	const stats = await promises.stat(path);
+	return createFileFromPath(path, stats, filenameOrOptions, options);
+}
+
+//#endregion
+export { fileFromPath };

dist/isFile-CMs-SNI_.mjs

@@ -0,0 +1,2250 @@
+//#region node_modules/.pnpm/web-streams-polyfill@4.0.0-beta.3/node_modules/web-streams-polyfill/dist/ponyfill.mjs
+/**
+* @license
+* web-streams-polyfill v4.0.0-beta.3
+* Copyright 2021 Mattias Buelens, Diwank Singh Tomer and other contributors.
+* This code is released under the MIT license.
+* SPDX-License-Identifier: MIT
+*/
+const e = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? Symbol : (e$1) => `Symbol(${e$1})`;
+function t() {}
+function r(e$1) {
+	return "object" == typeof e$1 && null !== e$1 || "function" == typeof e$1;
+}
+const o = t;
+function n(e$1, t$1) {
+	try {
+		Object.defineProperty(e$1, "name", {
+			value: t$1,
+			configurable: !0
+		});
+	} catch (e$2) {}
+}
+const a = Promise, i = Promise.prototype.then, l = Promise.resolve.bind(a), s = Promise.reject.bind(a);
+function u(e$1) {
+	return new a(e$1);
+}
+function c(e$1) {
+	return l(e$1);
+}
+function d(e$1) {
+	return s(e$1);
+}
+function f(e$1, t$1, r$1) {
+	return i.call(e$1, t$1, r$1);
+}
+function b(e$1, t$1, r$1) {
+	f(f(e$1, t$1, r$1), void 0, o);
+}
+function h(e$1, t$1) {
+	b(e$1, t$1);
+}
+function _(e$1, t$1) {
+	b(e$1, void 0, t$1);
+}
+function p(e$1, t$1, r$1) {
+	return f(e$1, t$1, r$1);
+}
+function m(e$1) {
+	f(e$1, void 0, o);
+}
+let y = (e$1) => {
+	if ("function" == typeof queueMicrotask) y = queueMicrotask;
+	else {
+		const e$2 = c(void 0);
+		y = (t$1) => f(e$2, t$1);
+	}
+	return y(e$1);
+};
+function g(e$1, t$1, r$1) {
+	if ("function" != typeof e$1) throw new TypeError("Argument is not a function");
+	return Function.prototype.apply.call(e$1, t$1, r$1);
+}
+function w(e$1, t$1, r$1) {
+	try {
+		return c(g(e$1, t$1, r$1));
+	} catch (e$2) {
+		return d(e$2);
+	}
+}
+var S = class {
+	constructor() {
+		this._cursor = 0, this._size = 0, this._front = {
+			_elements: [],
+			_next: void 0
+		}, this._back = this._front, this._cursor = 0, this._size = 0;
+	}
+	get length() {
+		return this._size;
+	}
+	push(e$1) {
+		const t$1 = this._back;
+		let r$1 = t$1;
+		16383 === t$1._elements.length && (r$1 = {
+			_elements: [],
+			_next: void 0
+		}), t$1._elements.push(e$1), r$1 !== t$1 && (this._back = r$1, t$1._next = r$1), ++this._size;
+	}
+	shift() {
+		const e$1 = this._front;
+		let t$1 = e$1;
+		const r$1 = this._cursor;
+		let o$1 = r$1 + 1;
+		const n$1 = e$1._elements, a$1 = n$1[r$1];
+		return 16384 === o$1 && (t$1 = e$1._next, o$1 = 0), --this._size, this._cursor = o$1, e$1 !== t$1 && (this._front = t$1), n$1[r$1] = void 0, a$1;
+	}
+	forEach(e$1) {
+		let t$1 = this._cursor, r$1 = this._front, o$1 = r$1._elements;
+		for (; !(t$1 === o$1.length && void 0 === r$1._next || t$1 === o$1.length && (r$1 = r$1._next, o$1 = r$1._elements, t$1 = 0, 0 === o$1.length));) e$1(o$1[t$1]), ++t$1;
+	}
+	peek() {
+		const e$1 = this._front, t$1 = this._cursor;
+		return e$1._elements[t$1];
+	}
+};
+const v = e("[[AbortSteps]]"), R = e("[[ErrorSteps]]"), T = e("[[CancelSteps]]"), q = e("[[PullSteps]]"), C = e("[[ReleaseSteps]]");
+function E(e$1, t$1) {
+	e$1._ownerReadableStream = t$1, t$1._reader = e$1, "readable" === t$1._state ? O(e$1) : "closed" === t$1._state ? function(e$2) {
+		O(e$2), j(e$2);
+	}(e$1) : B(e$1, t$1._storedError);
+}
+function P(e$1, t$1) {
+	return Gt(e$1._ownerReadableStream, t$1);
+}
+function W(e$1) {
+	const t$1 = e$1._ownerReadableStream;
+	"readable" === t$1._state ? A(e$1, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : function(e$2, t$2) {
+		B(e$2, t$2);
+	}(e$1, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t$1._readableStreamController[C](), t$1._reader = void 0, e$1._ownerReadableStream = void 0;
+}
+function k(e$1) {
+	return new TypeError("Cannot " + e$1 + " a stream using a released reader");
+}
+function O(e$1) {
+	e$1._closedPromise = u((t$1, r$1) => {
+		e$1._closedPromise_resolve = t$1, e$1._closedPromise_reject = r$1;
+	});
+}
+function B(e$1, t$1) {
+	O(e$1), A(e$1, t$1);
+}
+function A(e$1, t$1) {
+	void 0 !== e$1._closedPromise_reject && (m(e$1._closedPromise), e$1._closedPromise_reject(t$1), e$1._closedPromise_resolve = void 0, e$1._closedPromise_reject = void 0);
+}
+function j(e$1) {
+	void 0 !== e$1._closedPromise_resolve && (e$1._closedPromise_resolve(void 0), e$1._closedPromise_resolve = void 0, e$1._closedPromise_reject = void 0);
+}
+const z = Number.isFinite || function(e$1) {
+	return "number" == typeof e$1 && isFinite(e$1);
+}, L = Math.trunc || function(e$1) {
+	return e$1 < 0 ? Math.ceil(e$1) : Math.floor(e$1);
+};
+function F(e$1, t$1) {
+	if (void 0 !== e$1 && "object" != typeof (r$1 = e$1) && "function" != typeof r$1) throw new TypeError(`${t$1} is not an object.`);
+	var r$1;
+}
+function I(e$1, t$1) {
+	if ("function" != typeof e$1) throw new TypeError(`${t$1} is not a function.`);
+}
+function D(e$1, t$1) {
+	if (!function(e$2) {
+		return "object" == typeof e$2 && null !== e$2 || "function" == typeof e$2;
+	}(e$1)) throw new TypeError(`${t$1} is not an object.`);
+}
+function $(e$1, t$1, r$1) {
+	if (void 0 === e$1) throw new TypeError(`Parameter ${t$1} is required in '${r$1}'.`);
+}
+function M(e$1, t$1, r$1) {
+	if (void 0 === e$1) throw new TypeError(`${t$1} is required in '${r$1}'.`);
+}
+function Y(e$1) {
+	return Number(e$1);
+}
+function Q(e$1) {
+	return 0 === e$1 ? 0 : e$1;
+}
+function N(e$1, t$1) {
+	const r$1 = Number.MAX_SAFE_INTEGER;
+	let o$1 = Number(e$1);
+	if (o$1 = Q(o$1), !z(o$1)) throw new TypeError(`${t$1} is not a finite number`);
+	if (o$1 = function(e$2) {
+		return Q(L(e$2));
+	}(o$1), o$1 < 0 || o$1 > r$1) throw new TypeError(`${t$1} is outside the accepted range of 0 to ${r$1}, inclusive`);
+	return z(o$1) && 0 !== o$1 ? o$1 : 0;
+}
+function H(e$1) {
+	if (!r(e$1)) return !1;
+	if ("function" != typeof e$1.getReader) return !1;
+	try {
+		return "boolean" == typeof e$1.locked;
+	} catch (e$2) {
+		return !1;
+	}
+}
+function x(e$1) {
+	if (!r(e$1)) return !1;
+	if ("function" != typeof e$1.getWriter) return !1;
+	try {
+		return "boolean" == typeof e$1.locked;
+	} catch (e$2) {
+		return !1;
+	}
+}
+function V(e$1, t$1) {
+	if (!Vt(e$1)) throw new TypeError(`${t$1} is not a ReadableStream.`);
+}
+function U(e$1, t$1) {
+	e$1._reader._readRequests.push(t$1);
+}
+function G(e$1, t$1, r$1) {
+	const o$1 = e$1._reader._readRequests.shift();
+	r$1 ? o$1._closeSteps() : o$1._chunkSteps(t$1);
+}
+function X(e$1) {
+	return e$1._reader._readRequests.length;
+}
+function J(e$1) {
+	const t$1 = e$1._reader;
+	return void 0 !== t$1 && !!K(t$1);
+}
+var ReadableStreamDefaultReader = class {
+	constructor(e$1) {
+		if ($(e$1, 1, "ReadableStreamDefaultReader"), V(e$1, "First parameter"), Ut(e$1)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+		E(this, e$1), this._readRequests = new S();
+	}
+	get closed() {
+		return K(this) ? this._closedPromise : d(ee("closed"));
+	}
+	cancel(e$1) {
+		return K(this) ? void 0 === this._ownerReadableStream ? d(k("cancel")) : P(this, e$1) : d(ee("cancel"));
+	}
+	read() {
+		if (!K(this)) return d(ee("read"));
+		if (void 0 === this._ownerReadableStream) return d(k("read from"));
+		let e$1, t$1;
+		const r$1 = u((r$2, o$1) => {
+			e$1 = r$2, t$1 = o$1;
+		});
+		return function(e$2, t$2) {
+			const r$2 = e$2._ownerReadableStream;
+			r$2._disturbed = !0, "closed" === r$2._state ? t$2._closeSteps() : "errored" === r$2._state ? t$2._errorSteps(r$2._storedError) : r$2._readableStreamController[q](t$2);
+		}(this, {
+			_chunkSteps: (t$2) => e$1({
+				value: t$2,
+				done: !1
+			}),
+			_closeSteps: () => e$1({
+				value: void 0,
+				done: !0
+			}),
+			_errorSteps: (e$2) => t$1(e$2)
+		}), r$1;
+	}
+	releaseLock() {
+		if (!K(this)) throw ee("releaseLock");
+		void 0 !== this._ownerReadableStream && function(e$1) {
+			W(e$1);
+			const t$1 = new TypeError("Reader was released");
+			Z(e$1, t$1);
+		}(this);
+	}
+};
+function K(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_readRequests") && e$1 instanceof ReadableStreamDefaultReader;
+}
+function Z(e$1, t$1) {
+	const r$1 = e$1._readRequests;
+	e$1._readRequests = new S(), r$1.forEach((e$2) => {
+		e$2._errorSteps(t$1);
+	});
+}
+function ee(e$1) {
+	return new TypeError(`ReadableStreamDefaultReader.prototype.${e$1} can only be used on a ReadableStreamDefaultReader`);
+}
+Object.defineProperties(ReadableStreamDefaultReader.prototype, {
+	cancel: { enumerable: !0 },
+	read: { enumerable: !0 },
+	releaseLock: { enumerable: !0 },
+	closed: { enumerable: !0 }
+}), n(ReadableStreamDefaultReader.prototype.cancel, "cancel"), n(ReadableStreamDefaultReader.prototype.read, "read"), n(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock"), "symbol" == typeof e.toStringTag && Object.defineProperty(ReadableStreamDefaultReader.prototype, e.toStringTag, {
+	value: "ReadableStreamDefaultReader",
+	configurable: !0
+});
+var te = class {
+	constructor(e$1, t$1) {
+		this._ongoingPromise = void 0, this._isFinished = !1, this._reader = e$1, this._preventCancel = t$1;
+	}
+	next() {
+		const e$1 = () => this._nextSteps();
+		return this._ongoingPromise = this._ongoingPromise ? p(this._ongoingPromise, e$1, e$1) : e$1(), this._ongoingPromise;
+	}
+	return(e$1) {
+		const t$1 = () => this._returnSteps(e$1);
+		return this._ongoingPromise ? p(this._ongoingPromise, t$1, t$1) : t$1();
+	}
+	_nextSteps() {
+		if (this._isFinished) return Promise.resolve({
+			value: void 0,
+			done: !0
+		});
+		const e$1 = this._reader;
+		return void 0 === e$1 ? d(k("iterate")) : f(e$1.read(), (e$2) => {
+			var t$1;
+			return this._ongoingPromise = void 0, e$2.done && (this._isFinished = !0, null === (t$1 = this._reader) || void 0 === t$1 || t$1.releaseLock(), this._reader = void 0), e$2;
+		}, (e$2) => {
+			var t$1;
+			throw this._ongoingPromise = void 0, this._isFinished = !0, null === (t$1 = this._reader) || void 0 === t$1 || t$1.releaseLock(), this._reader = void 0, e$2;
+		});
+	}
+	_returnSteps(e$1) {
+		if (this._isFinished) return Promise.resolve({
+			value: e$1,
+			done: !0
+		});
+		this._isFinished = !0;
+		const t$1 = this._reader;
+		if (void 0 === t$1) return d(k("finish iterating"));
+		if (this._reader = void 0, !this._preventCancel) {
+			const r$1 = t$1.cancel(e$1);
+			return t$1.releaseLock(), p(r$1, () => ({
+				value: e$1,
+				done: !0
+			}));
+		}
+		return t$1.releaseLock(), c({
+			value: e$1,
+			done: !0
+		});
+	}
+};
+const re = {
+	next() {
+		return oe(this) ? this._asyncIteratorImpl.next() : d(ne("next"));
+	},
+	return(e$1) {
+		return oe(this) ? this._asyncIteratorImpl.return(e$1) : d(ne("return"));
+	}
+};
+function oe(e$1) {
+	if (!r(e$1)) return !1;
+	if (!Object.prototype.hasOwnProperty.call(e$1, "_asyncIteratorImpl")) return !1;
+	try {
+		return e$1._asyncIteratorImpl instanceof te;
+	} catch (e$2) {
+		return !1;
+	}
+}
+function ne(e$1) {
+	return new TypeError(`ReadableStreamAsyncIterator.${e$1} can only be used on a ReadableSteamAsyncIterator`);
+}
+"symbol" == typeof e.asyncIterator && Object.defineProperty(re, e.asyncIterator, {
+	value() {
+		return this;
+	},
+	writable: !0,
+	configurable: !0
+});
+const ae = Number.isNaN || function(e$1) {
+	return e$1 != e$1;
+};
+function ie(e$1, t$1, r$1, o$1, n$1) {
+	new Uint8Array(e$1).set(new Uint8Array(r$1, o$1, n$1), t$1);
+}
+function le(e$1) {
+	const t$1 = function(e$2, t$2, r$1) {
+		if (e$2.slice) return e$2.slice(t$2, r$1);
+		const o$1 = r$1 - t$2, n$1 = new ArrayBuffer(o$1);
+		return ie(n$1, 0, e$2, t$2, o$1), n$1;
+	}(e$1.buffer, e$1.byteOffset, e$1.byteOffset + e$1.byteLength);
+	return new Uint8Array(t$1);
+}
+function se(e$1) {
+	const t$1 = e$1._queue.shift();
+	return e$1._queueTotalSize -= t$1.size, e$1._queueTotalSize < 0 && (e$1._queueTotalSize = 0), t$1.value;
+}
+function ue(e$1, t$1, r$1) {
+	if ("number" != typeof (o$1 = r$1) || ae(o$1) || o$1 < 0 || r$1 === Infinity) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
+	var o$1;
+	e$1._queue.push({
+		value: t$1,
+		size: r$1
+	}), e$1._queueTotalSize += r$1;
+}
+function ce(e$1) {
+	e$1._queue = new S(), e$1._queueTotalSize = 0;
+}
+var ReadableStreamBYOBRequest = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get view() {
+		if (!fe(this)) throw Be("view");
+		return this._view;
+	}
+	respond(e$1) {
+		if (!fe(this)) throw Be("respond");
+		if ($(e$1, 1, "respond"), e$1 = N(e$1, "First parameter"), void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
+		this._view.buffer, function(e$2, t$1) {
+			const r$1 = e$2._pendingPullIntos.peek();
+			if ("closed" === e$2._controlledReadableByteStream._state) {
+				if (0 !== t$1) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
+			} else {
+				if (0 === t$1) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
+				if (r$1.bytesFilled + t$1 > r$1.byteLength) throw new RangeError("bytesWritten out of range");
+			}
+			r$1.buffer = r$1.buffer, qe(e$2, t$1);
+		}(this._associatedReadableByteStreamController, e$1);
+	}
+	respondWithNewView(e$1) {
+		if (!fe(this)) throw Be("respondWithNewView");
+		if ($(e$1, 1, "respondWithNewView"), !ArrayBuffer.isView(e$1)) throw new TypeError("You can only respond with array buffer views");
+		if (void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
+		e$1.buffer, function(e$2, t$1) {
+			const r$1 = e$2._pendingPullIntos.peek();
+			if ("closed" === e$2._controlledReadableByteStream._state) {
+				if (0 !== t$1.byteLength) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
+			} else if (0 === t$1.byteLength) throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
+			if (r$1.byteOffset + r$1.bytesFilled !== t$1.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
+			if (r$1.bufferByteLength !== t$1.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
+			if (r$1.bytesFilled + t$1.byteLength > r$1.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
+			const o$1 = t$1.byteLength;
+			r$1.buffer = t$1.buffer, qe(e$2, o$1);
+		}(this._associatedReadableByteStreamController, e$1);
+	}
+};
+Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
+	respond: { enumerable: !0 },
+	respondWithNewView: { enumerable: !0 },
+	view: { enumerable: !0 }
+}), n(ReadableStreamBYOBRequest.prototype.respond, "respond"), n(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView"), "symbol" == typeof e.toStringTag && Object.defineProperty(ReadableStreamBYOBRequest.prototype, e.toStringTag, {
+	value: "ReadableStreamBYOBRequest",
+	configurable: !0
+});
+var ReadableByteStreamController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get byobRequest() {
+		if (!de(this)) throw Ae("byobRequest");
+		return function(e$1) {
+			if (null === e$1._byobRequest && e$1._pendingPullIntos.length > 0) {
+				const t$1 = e$1._pendingPullIntos.peek(), r$1 = new Uint8Array(t$1.buffer, t$1.byteOffset + t$1.bytesFilled, t$1.byteLength - t$1.bytesFilled), o$1 = Object.create(ReadableStreamBYOBRequest.prototype);
+				(function(e$2, t$2, r$2) {
+					e$2._associatedReadableByteStreamController = t$2, e$2._view = r$2;
+				})(o$1, e$1, r$1), e$1._byobRequest = o$1;
+			}
+			return e$1._byobRequest;
+		}(this);
+	}
+	get desiredSize() {
+		if (!de(this)) throw Ae("desiredSize");
+		return ke(this);
+	}
+	close() {
+		if (!de(this)) throw Ae("close");
+		if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
+		const e$1 = this._controlledReadableByteStream._state;
+		if ("readable" !== e$1) throw new TypeError(`The stream (in ${e$1} state) is not in the readable state and cannot be closed`);
+		(function(e$2) {
+			const t$1 = e$2._controlledReadableByteStream;
+			if (e$2._closeRequested || "readable" !== t$1._state) return;
+			if (e$2._queueTotalSize > 0) return void (e$2._closeRequested = !0);
+			if (e$2._pendingPullIntos.length > 0) {
+				if (e$2._pendingPullIntos.peek().bytesFilled > 0) {
+					const t$2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
+					throw Pe(e$2, t$2), t$2;
+				}
+			}
+			Ee(e$2), Xt(t$1);
+		})(this);
+	}
+	enqueue(e$1) {
+		if (!de(this)) throw Ae("enqueue");
+		if ($(e$1, 1, "enqueue"), !ArrayBuffer.isView(e$1)) throw new TypeError("chunk must be an array buffer view");
+		if (0 === e$1.byteLength) throw new TypeError("chunk must have non-zero byteLength");
+		if (0 === e$1.buffer.byteLength) throw new TypeError("chunk's buffer must have non-zero byteLength");
+		if (this._closeRequested) throw new TypeError("stream is closed or draining");
+		const t$1 = this._controlledReadableByteStream._state;
+		if ("readable" !== t$1) throw new TypeError(`The stream (in ${t$1} state) is not in the readable state and cannot be enqueued to`);
+		(function(e$2, t$2) {
+			const r$1 = e$2._controlledReadableByteStream;
+			if (e$2._closeRequested || "readable" !== r$1._state) return;
+			const o$1 = t$2.buffer, n$1 = t$2.byteOffset, a$1 = t$2.byteLength, i$1 = o$1;
+			if (e$2._pendingPullIntos.length > 0) {
+				const t$3 = e$2._pendingPullIntos.peek();
+				t$3.buffer, Re(e$2), t$3.buffer = t$3.buffer, "none" === t$3.readerType && ge(e$2, t$3);
+			}
+			if (J(r$1)) if (function(e$3) {
+				const t$3 = e$3._controlledReadableByteStream._reader;
+				for (; t$3._readRequests.length > 0;) {
+					if (0 === e$3._queueTotalSize) return;
+					We(e$3, t$3._readRequests.shift());
+				}
+			}(e$2), 0 === X(r$1)) me(e$2, i$1, n$1, a$1);
+			else {
+				e$2._pendingPullIntos.length > 0 && Ce(e$2);
+				G(r$1, new Uint8Array(i$1, n$1, a$1), !1);
+			}
+			else Le(r$1) ? (me(e$2, i$1, n$1, a$1), Te(e$2)) : me(e$2, i$1, n$1, a$1);
+			be(e$2);
+		})(this, e$1);
+	}
+	error(e$1) {
+		if (!de(this)) throw Ae("error");
+		Pe(this, e$1);
+	}
+	[T](e$1) {
+		he(this), ce(this);
+		const t$1 = this._cancelAlgorithm(e$1);
+		return Ee(this), t$1;
+	}
+	[q](e$1) {
+		const t$1 = this._controlledReadableByteStream;
+		if (this._queueTotalSize > 0) return void We(this, e$1);
+		const r$1 = this._autoAllocateChunkSize;
+		if (void 0 !== r$1) {
+			let t$2;
+			try {
+				t$2 = new ArrayBuffer(r$1);
+			} catch (t$3) {
+				return void e$1._errorSteps(t$3);
+			}
+			const o$1 = {
+				buffer: t$2,
+				bufferByteLength: r$1,
+				byteOffset: 0,
+				byteLength: r$1,
+				bytesFilled: 0,
+				elementSize: 1,
+				viewConstructor: Uint8Array,
+				readerType: "default"
+			};
+			this._pendingPullIntos.push(o$1);
+		}
+		U(t$1, e$1), be(this);
+	}
+	[C]() {
+		if (this._pendingPullIntos.length > 0) {
+			const e$1 = this._pendingPullIntos.peek();
+			e$1.readerType = "none", this._pendingPullIntos = new S(), this._pendingPullIntos.push(e$1);
+		}
+	}
+};
+function de(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_controlledReadableByteStream") && e$1 instanceof ReadableByteStreamController;
+}
+function fe(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_associatedReadableByteStreamController") && e$1 instanceof ReadableStreamBYOBRequest;
+}
+function be(e$1) {
+	const t$1 = function(e$2) {
+		const t$2 = e$2._controlledReadableByteStream;
+		if ("readable" !== t$2._state) return !1;
+		if (e$2._closeRequested) return !1;
+		if (!e$2._started) return !1;
+		if (J(t$2) && X(t$2) > 0) return !0;
+		if (Le(t$2) && ze(t$2) > 0) return !0;
+		if (ke(e$2) > 0) return !0;
+		return !1;
+	}(e$1);
+	if (!t$1) return;
+	if (e$1._pulling) return void (e$1._pullAgain = !0);
+	e$1._pulling = !0;
+	b(e$1._pullAlgorithm(), () => (e$1._pulling = !1, e$1._pullAgain && (e$1._pullAgain = !1, be(e$1)), null), (t$2) => (Pe(e$1, t$2), null));
+}
+function he(e$1) {
+	Re(e$1), e$1._pendingPullIntos = new S();
+}
+function _e(e$1, t$1) {
+	let r$1 = !1;
+	"closed" === e$1._state && (r$1 = !0);
+	const o$1 = pe(t$1);
+	"default" === t$1.readerType ? G(e$1, o$1, r$1) : function(e$2, t$2, r$2) {
+		const o$2 = e$2._reader._readIntoRequests.shift();
+		r$2 ? o$2._closeSteps(t$2) : o$2._chunkSteps(t$2);
+	}(e$1, o$1, r$1);
+}
+function pe(e$1) {
+	const t$1 = e$1.bytesFilled, r$1 = e$1.elementSize;
+	return new e$1.viewConstructor(e$1.buffer, e$1.byteOffset, t$1 / r$1);
+}
+function me(e$1, t$1, r$1, o$1) {
+	e$1._queue.push({
+		buffer: t$1,
+		byteOffset: r$1,
+		byteLength: o$1
+	}), e$1._queueTotalSize += o$1;
+}
+function ye(e$1, t$1, r$1, o$1) {
+	let n$1;
+	try {
+		n$1 = t$1.slice(r$1, r$1 + o$1);
+	} catch (t$2) {
+		throw Pe(e$1, t$2), t$2;
+	}
+	me(e$1, n$1, 0, o$1);
+}
+function ge(e$1, t$1) {
+	t$1.bytesFilled > 0 && ye(e$1, t$1.buffer, t$1.byteOffset, t$1.bytesFilled), Ce(e$1);
+}
+function we(e$1, t$1) {
+	const r$1 = t$1.elementSize, o$1 = t$1.bytesFilled - t$1.bytesFilled % r$1, n$1 = Math.min(e$1._queueTotalSize, t$1.byteLength - t$1.bytesFilled), a$1 = t$1.bytesFilled + n$1, i$1 = a$1 - a$1 % r$1;
+	let l$1 = n$1, s$1 = !1;
+	i$1 > o$1 && (l$1 = i$1 - t$1.bytesFilled, s$1 = !0);
+	const u$1 = e$1._queue;
+	for (; l$1 > 0;) {
+		const r$2 = u$1.peek(), o$2 = Math.min(l$1, r$2.byteLength), n$2 = t$1.byteOffset + t$1.bytesFilled;
+		ie(t$1.buffer, n$2, r$2.buffer, r$2.byteOffset, o$2), r$2.byteLength === o$2 ? u$1.shift() : (r$2.byteOffset += o$2, r$2.byteLength -= o$2), e$1._queueTotalSize -= o$2, Se(e$1, o$2, t$1), l$1 -= o$2;
+	}
+	return s$1;
+}
+function Se(e$1, t$1, r$1) {
+	r$1.bytesFilled += t$1;
+}
+function ve(e$1) {
+	0 === e$1._queueTotalSize && e$1._closeRequested ? (Ee(e$1), Xt(e$1._controlledReadableByteStream)) : be(e$1);
+}
+function Re(e$1) {
+	null !== e$1._byobRequest && (e$1._byobRequest._associatedReadableByteStreamController = void 0, e$1._byobRequest._view = null, e$1._byobRequest = null);
+}
+function Te(e$1) {
+	for (; e$1._pendingPullIntos.length > 0;) {
+		if (0 === e$1._queueTotalSize) return;
+		const t$1 = e$1._pendingPullIntos.peek();
+		we(e$1, t$1) && (Ce(e$1), _e(e$1._controlledReadableByteStream, t$1));
+	}
+}
+function qe(e$1, t$1) {
+	const r$1 = e$1._pendingPullIntos.peek();
+	Re(e$1);
+	"closed" === e$1._controlledReadableByteStream._state ? function(e$2, t$2) {
+		"none" === t$2.readerType && Ce(e$2);
+		const r$2 = e$2._controlledReadableByteStream;
+		if (Le(r$2)) for (; ze(r$2) > 0;) _e(r$2, Ce(e$2));
+	}(e$1, r$1) : function(e$2, t$2, r$2) {
+		if (Se(0, t$2, r$2), "none" === r$2.readerType) return ge(e$2, r$2), void Te(e$2);
+		if (r$2.bytesFilled < r$2.elementSize) return;
+		Ce(e$2);
+		const o$1 = r$2.bytesFilled % r$2.elementSize;
+		if (o$1 > 0) {
+			const t$3 = r$2.byteOffset + r$2.bytesFilled;
+			ye(e$2, r$2.buffer, t$3 - o$1, o$1);
+		}
+		r$2.bytesFilled -= o$1, _e(e$2._controlledReadableByteStream, r$2), Te(e$2);
+	}(e$1, t$1, r$1), be(e$1);
+}
+function Ce(e$1) {
+	return e$1._pendingPullIntos.shift();
+}
+function Ee(e$1) {
+	e$1._pullAlgorithm = void 0, e$1._cancelAlgorithm = void 0;
+}
+function Pe(e$1, t$1) {
+	const r$1 = e$1._controlledReadableByteStream;
+	"readable" === r$1._state && (he(e$1), ce(e$1), Ee(e$1), Jt(r$1, t$1));
+}
+function We(e$1, t$1) {
+	const r$1 = e$1._queue.shift();
+	e$1._queueTotalSize -= r$1.byteLength, ve(e$1);
+	const o$1 = new Uint8Array(r$1.buffer, r$1.byteOffset, r$1.byteLength);
+	t$1._chunkSteps(o$1);
+}
+function ke(e$1) {
+	const t$1 = e$1._controlledReadableByteStream._state;
+	return "errored" === t$1 ? null : "closed" === t$1 ? 0 : e$1._strategyHWM - e$1._queueTotalSize;
+}
+function Oe(e$1, t$1, r$1) {
+	const o$1 = Object.create(ReadableByteStreamController.prototype);
+	let n$1, a$1, i$1;
+	n$1 = void 0 !== t$1.start ? () => t$1.start(o$1) : () => {}, a$1 = void 0 !== t$1.pull ? () => t$1.pull(o$1) : () => c(void 0), i$1 = void 0 !== t$1.cancel ? (e$2) => t$1.cancel(e$2) : () => c(void 0);
+	const l$1 = t$1.autoAllocateChunkSize;
+	if (0 === l$1) throw new TypeError("autoAllocateChunkSize must be greater than 0");
+	(function(e$2, t$2, r$2, o$2, n$2, a$2, i$2) {
+		t$2._controlledReadableByteStream = e$2, t$2._pullAgain = !1, t$2._pulling = !1, t$2._byobRequest = null, t$2._queue = t$2._queueTotalSize = void 0, ce(t$2), t$2._closeRequested = !1, t$2._started = !1, t$2._strategyHWM = a$2, t$2._pullAlgorithm = o$2, t$2._cancelAlgorithm = n$2, t$2._autoAllocateChunkSize = i$2, t$2._pendingPullIntos = new S(), e$2._readableStreamController = t$2, b(c(r$2()), () => (t$2._started = !0, be(t$2), null), (e$3) => (Pe(t$2, e$3), null));
+	})(e$1, o$1, n$1, a$1, i$1, r$1, l$1);
+}
+function Be(e$1) {
+	return new TypeError(`ReadableStreamBYOBRequest.prototype.${e$1} can only be used on a ReadableStreamBYOBRequest`);
+}
+function Ae(e$1) {
+	return new TypeError(`ReadableByteStreamController.prototype.${e$1} can only be used on a ReadableByteStreamController`);
+}
+function je(e$1, t$1) {
+	e$1._reader._readIntoRequests.push(t$1);
+}
+function ze(e$1) {
+	return e$1._reader._readIntoRequests.length;
+}
+function Le(e$1) {
+	const t$1 = e$1._reader;
+	return void 0 !== t$1 && !!Fe(t$1);
+}
+Object.defineProperties(ReadableByteStreamController.prototype, {
+	close: { enumerable: !0 },
+	enqueue: { enumerable: !0 },
+	error: { enumerable: !0 },
+	byobRequest: { enumerable: !0 },
+	desiredSize: { enumerable: !0 }
+}), n(ReadableByteStreamController.prototype.close, "close"), n(ReadableByteStreamController.prototype.enqueue, "enqueue"), n(ReadableByteStreamController.prototype.error, "error"), "symbol" == typeof e.toStringTag && Object.defineProperty(ReadableByteStreamController.prototype, e.toStringTag, {
+	value: "ReadableByteStreamController",
+	configurable: !0
+});
+var ReadableStreamBYOBReader = class {
+	constructor(e$1) {
+		if ($(e$1, 1, "ReadableStreamBYOBReader"), V(e$1, "First parameter"), Ut(e$1)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+		if (!de(e$1._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
+		E(this, e$1), this._readIntoRequests = new S();
+	}
+	get closed() {
+		return Fe(this) ? this._closedPromise : d(De("closed"));
+	}
+	cancel(e$1) {
+		return Fe(this) ? void 0 === this._ownerReadableStream ? d(k("cancel")) : P(this, e$1) : d(De("cancel"));
+	}
+	read(e$1) {
+		if (!Fe(this)) return d(De("read"));
+		if (!ArrayBuffer.isView(e$1)) return d(new TypeError("view must be an array buffer view"));
+		if (0 === e$1.byteLength) return d(new TypeError("view must have non-zero byteLength"));
+		if (0 === e$1.buffer.byteLength) return d(new TypeError("view's buffer must have non-zero byteLength"));
+		if (e$1.buffer, void 0 === this._ownerReadableStream) return d(k("read from"));
+		let t$1, r$1;
+		const o$1 = u((e$2, o$2) => {
+			t$1 = e$2, r$1 = o$2;
+		});
+		return function(e$2, t$2, r$2) {
+			const o$2 = e$2._ownerReadableStream;
+			o$2._disturbed = !0, "errored" === o$2._state ? r$2._errorSteps(o$2._storedError) : function(e$3, t$3, r$3) {
+				const o$3 = e$3._controlledReadableByteStream;
+				let n$1 = 1;
+				t$3.constructor !== DataView && (n$1 = t$3.constructor.BYTES_PER_ELEMENT);
+				const a$1 = t$3.constructor, i$1 = t$3.buffer, l$1 = {
+					buffer: i$1,
+					bufferByteLength: i$1.byteLength,
+					byteOffset: t$3.byteOffset,
+					byteLength: t$3.byteLength,
+					bytesFilled: 0,
+					elementSize: n$1,
+					viewConstructor: a$1,
+					readerType: "byob"
+				};
+				if (e$3._pendingPullIntos.length > 0) return e$3._pendingPullIntos.push(l$1), void je(o$3, r$3);
+				if ("closed" !== o$3._state) {
+					if (e$3._queueTotalSize > 0) {
+						if (we(e$3, l$1)) {
+							const t$4 = pe(l$1);
+							return ve(e$3), void r$3._chunkSteps(t$4);
+						}
+						if (e$3._closeRequested) {
+							const t$4 = new TypeError("Insufficient bytes to fill elements in the given buffer");
+							return Pe(e$3, t$4), void r$3._errorSteps(t$4);
+						}
+					}
+					e$3._pendingPullIntos.push(l$1), je(o$3, r$3), be(e$3);
+				} else {
+					const e$4 = new a$1(l$1.buffer, l$1.byteOffset, 0);
+					r$3._closeSteps(e$4);
+				}
+			}(o$2._readableStreamController, t$2, r$2);
+		}(this, e$1, {
+			_chunkSteps: (e$2) => t$1({
+				value: e$2,
+				done: !1
+			}),
+			_closeSteps: (e$2) => t$1({
+				value: e$2,
+				done: !0
+			}),
+			_errorSteps: (e$2) => r$1(e$2)
+		}), o$1;
+	}
+	releaseLock() {
+		if (!Fe(this)) throw De("releaseLock");
+		void 0 !== this._ownerReadableStream && function(e$1) {
+			W(e$1);
+			const t$1 = new TypeError("Reader was released");
+			Ie(e$1, t$1);
+		}(this);
+	}
+};
+function Fe(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_readIntoRequests") && e$1 instanceof ReadableStreamBYOBReader;
+}
+function Ie(e$1, t$1) {
+	const r$1 = e$1._readIntoRequests;
+	e$1._readIntoRequests = new S(), r$1.forEach((e$2) => {
+		e$2._errorSteps(t$1);
+	});
+}
+function De(e$1) {
+	return new TypeError(`ReadableStreamBYOBReader.prototype.${e$1} can only be used on a ReadableStreamBYOBReader`);
+}
+function $e(e$1, t$1) {
+	const { highWaterMark: r$1 } = e$1;
+	if (void 0 === r$1) return t$1;
+	if (ae(r$1) || r$1 < 0) throw new RangeError("Invalid highWaterMark");
+	return r$1;
+}
+function Me(e$1) {
+	const { size: t$1 } = e$1;
+	return t$1 || (() => 1);
+}
+function Ye(e$1, t$1) {
+	F(e$1, t$1);
+	const r$1 = null == e$1 ? void 0 : e$1.highWaterMark, o$1 = null == e$1 ? void 0 : e$1.size;
+	return {
+		highWaterMark: void 0 === r$1 ? void 0 : Y(r$1),
+		size: void 0 === o$1 ? void 0 : Qe(o$1, `${t$1} has member 'size' that`)
+	};
+}
+function Qe(e$1, t$1) {
+	return I(e$1, t$1), (t$2) => Y(e$1(t$2));
+}
+function Ne(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2) => w(e$1, t$1, [r$2]);
+}
+function He(e$1, t$1, r$1) {
+	return I(e$1, r$1), () => w(e$1, t$1, []);
+}
+function xe(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2) => g(e$1, t$1, [r$2]);
+}
+function Ve(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2, o$1) => w(e$1, t$1, [r$2, o$1]);
+}
+Object.defineProperties(ReadableStreamBYOBReader.prototype, {
+	cancel: { enumerable: !0 },
+	read: { enumerable: !0 },
+	releaseLock: { enumerable: !0 },
+	closed: { enumerable: !0 }
+}), n(ReadableStreamBYOBReader.prototype.cancel, "cancel"), n(ReadableStreamBYOBReader.prototype.read, "read"), n(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock"), "symbol" == typeof e.toStringTag && Object.defineProperty(ReadableStreamBYOBReader.prototype, e.toStringTag, {
+	value: "ReadableStreamBYOBReader",
+	configurable: !0
+});
+const Ue = "function" == typeof AbortController;
+var WritableStream = class {
+	constructor(e$1 = {}, t$1 = {}) {
+		void 0 === e$1 ? e$1 = null : D(e$1, "First parameter");
+		const r$1 = Ye(t$1, "Second parameter"), o$1 = function(e$2, t$2) {
+			F(e$2, t$2);
+			const r$2 = null == e$2 ? void 0 : e$2.abort, o$2 = null == e$2 ? void 0 : e$2.close, n$2 = null == e$2 ? void 0 : e$2.start, a$2 = null == e$2 ? void 0 : e$2.type, i$1 = null == e$2 ? void 0 : e$2.write;
+			return {
+				abort: void 0 === r$2 ? void 0 : Ne(r$2, e$2, `${t$2} has member 'abort' that`),
+				close: void 0 === o$2 ? void 0 : He(o$2, e$2, `${t$2} has member 'close' that`),
+				start: void 0 === n$2 ? void 0 : xe(n$2, e$2, `${t$2} has member 'start' that`),
+				write: void 0 === i$1 ? void 0 : Ve(i$1, e$2, `${t$2} has member 'write' that`),
+				type: a$2
+			};
+		}(e$1, "First parameter");
+		var n$1;
+		(n$1 = this)._state = "writable", n$1._storedError = void 0, n$1._writer = void 0, n$1._writableStreamController = void 0, n$1._writeRequests = new S(), n$1._inFlightWriteRequest = void 0, n$1._closeRequest = void 0, n$1._inFlightCloseRequest = void 0, n$1._pendingAbortRequest = void 0, n$1._backpressure = !1;
+		if (void 0 !== o$1.type) throw new RangeError("Invalid type is specified");
+		const a$1 = Me(r$1);
+		(function(e$2, t$2, r$2, o$2) {
+			const n$2 = Object.create(WritableStreamDefaultController.prototype);
+			let a$2, i$1, l$1, s$1;
+			a$2 = void 0 !== t$2.start ? () => t$2.start(n$2) : () => {};
+			i$1 = void 0 !== t$2.write ? (e$3) => t$2.write(e$3, n$2) : () => c(void 0);
+			l$1 = void 0 !== t$2.close ? () => t$2.close() : () => c(void 0);
+			s$1 = void 0 !== t$2.abort ? (e$3) => t$2.abort(e$3) : () => c(void 0);
+			(function(e$3, t$3, r$3, o$3, n$3, a$3, i$2, l$2) {
+				t$3._controlledWritableStream = e$3, e$3._writableStreamController = t$3, t$3._queue = void 0, t$3._queueTotalSize = void 0, ce(t$3), t$3._abortReason = void 0, t$3._abortController = function() {
+					if (Ue) return new AbortController();
+				}(), t$3._started = !1, t$3._strategySizeAlgorithm = l$2, t$3._strategyHWM = i$2, t$3._writeAlgorithm = o$3, t$3._closeAlgorithm = n$3, t$3._abortAlgorithm = a$3;
+				const s$2 = bt(t$3);
+				nt(e$3, s$2);
+				const u$1 = r$3();
+				b(c(u$1), () => (t$3._started = !0, dt(t$3), null), (r$4) => (t$3._started = !0, Ze(e$3, r$4), null));
+			})(e$2, n$2, a$2, i$1, l$1, s$1, r$2, o$2);
+		})(this, o$1, $e(r$1, 1), a$1);
+	}
+	get locked() {
+		if (!Ge(this)) throw _t("locked");
+		return Xe(this);
+	}
+	abort(e$1) {
+		return Ge(this) ? Xe(this) ? d(new TypeError("Cannot abort a stream that already has a writer")) : Je(this, e$1) : d(_t("abort"));
+	}
+	close() {
+		return Ge(this) ? Xe(this) ? d(new TypeError("Cannot close a stream that already has a writer")) : rt(this) ? d(new TypeError("Cannot close an already-closing stream")) : Ke(this) : d(_t("close"));
+	}
+	getWriter() {
+		if (!Ge(this)) throw _t("getWriter");
+		return new WritableStreamDefaultWriter(this);
+	}
+};
+function Ge(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_writableStreamController") && e$1 instanceof WritableStream;
+}
+function Xe(e$1) {
+	return void 0 !== e$1._writer;
+}
+function Je(e$1, t$1) {
+	var r$1;
+	if ("closed" === e$1._state || "errored" === e$1._state) return c(void 0);
+	e$1._writableStreamController._abortReason = t$1, null === (r$1 = e$1._writableStreamController._abortController) || void 0 === r$1 || r$1.abort(t$1);
+	const o$1 = e$1._state;
+	if ("closed" === o$1 || "errored" === o$1) return c(void 0);
+	if (void 0 !== e$1._pendingAbortRequest) return e$1._pendingAbortRequest._promise;
+	let n$1 = !1;
+	"erroring" === o$1 && (n$1 = !0, t$1 = void 0);
+	const a$1 = u((r$2, o$2) => {
+		e$1._pendingAbortRequest = {
+			_promise: void 0,
+			_resolve: r$2,
+			_reject: o$2,
+			_reason: t$1,
+			_wasAlreadyErroring: n$1
+		};
+	});
+	return e$1._pendingAbortRequest._promise = a$1, n$1 || et(e$1, t$1), a$1;
+}
+function Ke(e$1) {
+	const t$1 = e$1._state;
+	if ("closed" === t$1 || "errored" === t$1) return d(new TypeError(`The stream (in ${t$1} state) is not in the writable state and cannot be closed`));
+	const r$1 = u((t$2, r$2) => {
+		const o$2 = {
+			_resolve: t$2,
+			_reject: r$2
+		};
+		e$1._closeRequest = o$2;
+	}), o$1 = e$1._writer;
+	var n$1;
+	return void 0 !== o$1 && e$1._backpressure && "writable" === t$1 && Et(o$1), ue(n$1 = e$1._writableStreamController, lt, 0), dt(n$1), r$1;
+}
+function Ze(e$1, t$1) {
+	"writable" !== e$1._state ? tt(e$1) : et(e$1, t$1);
+}
+function et(e$1, t$1) {
+	const r$1 = e$1._writableStreamController;
+	e$1._state = "erroring", e$1._storedError = t$1;
+	const o$1 = e$1._writer;
+	void 0 !== o$1 && it(o$1, t$1), !function(e$2) {
+		if (void 0 === e$2._inFlightWriteRequest && void 0 === e$2._inFlightCloseRequest) return !1;
+		return !0;
+	}(e$1) && r$1._started && tt(e$1);
+}
+function tt(e$1) {
+	e$1._state = "errored", e$1._writableStreamController[R]();
+	const t$1 = e$1._storedError;
+	if (e$1._writeRequests.forEach((e$2) => {
+		e$2._reject(t$1);
+	}), e$1._writeRequests = new S(), void 0 === e$1._pendingAbortRequest) return void ot(e$1);
+	const r$1 = e$1._pendingAbortRequest;
+	if (e$1._pendingAbortRequest = void 0, r$1._wasAlreadyErroring) return r$1._reject(t$1), void ot(e$1);
+	b(e$1._writableStreamController[v](r$1._reason), () => (r$1._resolve(), ot(e$1), null), (t$2) => (r$1._reject(t$2), ot(e$1), null));
+}
+function rt(e$1) {
+	return void 0 !== e$1._closeRequest || void 0 !== e$1._inFlightCloseRequest;
+}
+function ot(e$1) {
+	void 0 !== e$1._closeRequest && (e$1._closeRequest._reject(e$1._storedError), e$1._closeRequest = void 0);
+	const t$1 = e$1._writer;
+	void 0 !== t$1 && St(t$1, e$1._storedError);
+}
+function nt(e$1, t$1) {
+	const r$1 = e$1._writer;
+	void 0 !== r$1 && t$1 !== e$1._backpressure && (t$1 ? function(e$2) {
+		Rt(e$2);
+	}(r$1) : Et(r$1)), e$1._backpressure = t$1;
+}
+Object.defineProperties(WritableStream.prototype, {
+	abort: { enumerable: !0 },
+	close: { enumerable: !0 },
+	getWriter: { enumerable: !0 },
+	locked: { enumerable: !0 }
+}), n(WritableStream.prototype.abort, "abort"), n(WritableStream.prototype.close, "close"), n(WritableStream.prototype.getWriter, "getWriter"), "symbol" == typeof e.toStringTag && Object.defineProperty(WritableStream.prototype, e.toStringTag, {
+	value: "WritableStream",
+	configurable: !0
+});
+var WritableStreamDefaultWriter = class {
+	constructor(e$1) {
+		if ($(e$1, 1, "WritableStreamDefaultWriter"), function(e$2, t$2) {
+			if (!Ge(e$2)) throw new TypeError(`${t$2} is not a WritableStream.`);
+		}(e$1, "First parameter"), Xe(e$1)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");
+		this._ownerWritableStream = e$1, e$1._writer = this;
+		const t$1 = e$1._state;
+		if ("writable" === t$1) !rt(e$1) && e$1._backpressure ? Rt(this) : qt(this), gt(this);
+		else if ("erroring" === t$1) Tt(this, e$1._storedError), gt(this);
+		else if ("closed" === t$1) qt(this), gt(r$1 = this), vt(r$1);
+		else {
+			const t$2 = e$1._storedError;
+			Tt(this, t$2), wt(this, t$2);
+		}
+		var r$1;
+	}
+	get closed() {
+		return at(this) ? this._closedPromise : d(mt("closed"));
+	}
+	get desiredSize() {
+		if (!at(this)) throw mt("desiredSize");
+		if (void 0 === this._ownerWritableStream) throw yt("desiredSize");
+		return function(e$1) {
+			const t$1 = e$1._ownerWritableStream, r$1 = t$1._state;
+			if ("errored" === r$1 || "erroring" === r$1) return null;
+			if ("closed" === r$1) return 0;
+			return ct(t$1._writableStreamController);
+		}(this);
+	}
+	get ready() {
+		return at(this) ? this._readyPromise : d(mt("ready"));
+	}
+	abort(e$1) {
+		return at(this) ? void 0 === this._ownerWritableStream ? d(yt("abort")) : function(e$2, t$1) {
+			return Je(e$2._ownerWritableStream, t$1);
+		}(this, e$1) : d(mt("abort"));
+	}
+	close() {
+		if (!at(this)) return d(mt("close"));
+		const e$1 = this._ownerWritableStream;
+		return void 0 === e$1 ? d(yt("close")) : rt(e$1) ? d(new TypeError("Cannot close an already-closing stream")) : Ke(this._ownerWritableStream);
+	}
+	releaseLock() {
+		if (!at(this)) throw mt("releaseLock");
+		void 0 !== this._ownerWritableStream && function(e$1) {
+			const t$1 = e$1._ownerWritableStream, r$1 = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
+			it(e$1, r$1), function(e$2, t$2) {
+				"pending" === e$2._closedPromiseState ? St(e$2, t$2) : function(e$3, t$3) {
+					wt(e$3, t$3);
+				}(e$2, t$2);
+			}(e$1, r$1), t$1._writer = void 0, e$1._ownerWritableStream = void 0;
+		}(this);
+	}
+	write(e$1) {
+		return at(this) ? void 0 === this._ownerWritableStream ? d(yt("write to")) : function(e$2, t$1) {
+			const r$1 = e$2._ownerWritableStream, o$1 = r$1._writableStreamController, n$1 = function(e$3, t$2) {
+				try {
+					return e$3._strategySizeAlgorithm(t$2);
+				} catch (t$3) {
+					return ft(e$3, t$3), 1;
+				}
+			}(o$1, t$1);
+			if (r$1 !== e$2._ownerWritableStream) return d(yt("write to"));
+			const a$1 = r$1._state;
+			if ("errored" === a$1) return d(r$1._storedError);
+			if (rt(r$1) || "closed" === a$1) return d(new TypeError("The stream is closing or closed and cannot be written to"));
+			if ("erroring" === a$1) return d(r$1._storedError);
+			const i$1 = function(e$3) {
+				return u((t$2, r$2) => {
+					const o$2 = {
+						_resolve: t$2,
+						_reject: r$2
+					};
+					e$3._writeRequests.push(o$2);
+				});
+			}(r$1);
+			return function(e$3, t$2, r$2) {
+				try {
+					ue(e$3, t$2, r$2);
+				} catch (t$3) {
+					return void ft(e$3, t$3);
+				}
+				const o$2 = e$3._controlledWritableStream;
+				if (!rt(o$2) && "writable" === o$2._state) nt(o$2, bt(e$3));
+				dt(e$3);
+			}(o$1, t$1, n$1), i$1;
+		}(this, e$1) : d(mt("write"));
+	}
+};
+function at(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_ownerWritableStream") && e$1 instanceof WritableStreamDefaultWriter;
+}
+function it(e$1, t$1) {
+	"pending" === e$1._readyPromiseState ? Ct(e$1, t$1) : function(e$2, t$2) {
+		Tt(e$2, t$2);
+	}(e$1, t$1);
+}
+Object.defineProperties(WritableStreamDefaultWriter.prototype, {
+	abort: { enumerable: !0 },
+	close: { enumerable: !0 },
+	releaseLock: { enumerable: !0 },
+	write: { enumerable: !0 },
+	closed: { enumerable: !0 },
+	desiredSize: { enumerable: !0 },
+	ready: { enumerable: !0 }
+}), n(WritableStreamDefaultWriter.prototype.abort, "abort"), n(WritableStreamDefaultWriter.prototype.close, "close"), n(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock"), n(WritableStreamDefaultWriter.prototype.write, "write"), "symbol" == typeof e.toStringTag && Object.defineProperty(WritableStreamDefaultWriter.prototype, e.toStringTag, {
+	value: "WritableStreamDefaultWriter",
+	configurable: !0
+});
+const lt = {};
+var WritableStreamDefaultController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get abortReason() {
+		if (!st(this)) throw pt("abortReason");
+		return this._abortReason;
+	}
+	get signal() {
+		if (!st(this)) throw pt("signal");
+		if (void 0 === this._abortController) throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
+		return this._abortController.signal;
+	}
+	error(e$1) {
+		if (!st(this)) throw pt("error");
+		"writable" === this._controlledWritableStream._state && ht(this, e$1);
+	}
+	[v](e$1) {
+		const t$1 = this._abortAlgorithm(e$1);
+		return ut(this), t$1;
+	}
+	[R]() {
+		ce(this);
+	}
+};
+function st(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_controlledWritableStream") && e$1 instanceof WritableStreamDefaultController;
+}
+function ut(e$1) {
+	e$1._writeAlgorithm = void 0, e$1._closeAlgorithm = void 0, e$1._abortAlgorithm = void 0, e$1._strategySizeAlgorithm = void 0;
+}
+function ct(e$1) {
+	return e$1._strategyHWM - e$1._queueTotalSize;
+}
+function dt(e$1) {
+	const t$1 = e$1._controlledWritableStream;
+	if (!e$1._started) return;
+	if (void 0 !== t$1._inFlightWriteRequest) return;
+	if ("erroring" === t$1._state) return void tt(t$1);
+	if (0 === e$1._queue.length) return;
+	const r$1 = e$1._queue.peek().value;
+	r$1 === lt ? function(e$2) {
+		const t$2 = e$2._controlledWritableStream;
+		(function(e$3) {
+			e$3._inFlightCloseRequest = e$3._closeRequest, e$3._closeRequest = void 0;
+		})(t$2), se(e$2);
+		const r$2 = e$2._closeAlgorithm();
+		ut(e$2), b(r$2, () => (function(e$3) {
+			e$3._inFlightCloseRequest._resolve(void 0), e$3._inFlightCloseRequest = void 0, "erroring" === e$3._state && (e$3._storedError = void 0, void 0 !== e$3._pendingAbortRequest && (e$3._pendingAbortRequest._resolve(), e$3._pendingAbortRequest = void 0)), e$3._state = "closed";
+			const t$3 = e$3._writer;
+			void 0 !== t$3 && vt(t$3);
+		}(t$2), null), (e$3) => (function(e$4, t$3) {
+			e$4._inFlightCloseRequest._reject(t$3), e$4._inFlightCloseRequest = void 0, void 0 !== e$4._pendingAbortRequest && (e$4._pendingAbortRequest._reject(t$3), e$4._pendingAbortRequest = void 0), Ze(e$4, t$3);
+		}(t$2, e$3), null));
+	}(e$1) : function(e$2, t$2) {
+		const r$2 = e$2._controlledWritableStream;
+		(function(e$3) {
+			e$3._inFlightWriteRequest = e$3._writeRequests.shift();
+		})(r$2);
+		b(e$2._writeAlgorithm(t$2), () => {
+			(function(e$3) {
+				e$3._inFlightWriteRequest._resolve(void 0), e$3._inFlightWriteRequest = void 0;
+			})(r$2);
+			const t$3 = r$2._state;
+			if (se(e$2), !rt(r$2) && "writable" === t$3) {
+				const t$4 = bt(e$2);
+				nt(r$2, t$4);
+			}
+			return dt(e$2), null;
+		}, (t$3) => ("writable" === r$2._state && ut(e$2), function(e$3, t$4) {
+			e$3._inFlightWriteRequest._reject(t$4), e$3._inFlightWriteRequest = void 0, Ze(e$3, t$4);
+		}(r$2, t$3), null));
+	}(e$1, r$1);
+}
+function ft(e$1, t$1) {
+	"writable" === e$1._controlledWritableStream._state && ht(e$1, t$1);
+}
+function bt(e$1) {
+	return ct(e$1) <= 0;
+}
+function ht(e$1, t$1) {
+	const r$1 = e$1._controlledWritableStream;
+	ut(e$1), et(r$1, t$1);
+}
+function _t(e$1) {
+	return new TypeError(`WritableStream.prototype.${e$1} can only be used on a WritableStream`);
+}
+function pt(e$1) {
+	return new TypeError(`WritableStreamDefaultController.prototype.${e$1} can only be used on a WritableStreamDefaultController`);
+}
+function mt(e$1) {
+	return new TypeError(`WritableStreamDefaultWriter.prototype.${e$1} can only be used on a WritableStreamDefaultWriter`);
+}
+function yt(e$1) {
+	return new TypeError("Cannot " + e$1 + " a stream using a released writer");
+}
+function gt(e$1) {
+	e$1._closedPromise = u((t$1, r$1) => {
+		e$1._closedPromise_resolve = t$1, e$1._closedPromise_reject = r$1, e$1._closedPromiseState = "pending";
+	});
+}
+function wt(e$1, t$1) {
+	gt(e$1), St(e$1, t$1);
+}
+function St(e$1, t$1) {
+	void 0 !== e$1._closedPromise_reject && (m(e$1._closedPromise), e$1._closedPromise_reject(t$1), e$1._closedPromise_resolve = void 0, e$1._closedPromise_reject = void 0, e$1._closedPromiseState = "rejected");
+}
+function vt(e$1) {
+	void 0 !== e$1._closedPromise_resolve && (e$1._closedPromise_resolve(void 0), e$1._closedPromise_resolve = void 0, e$1._closedPromise_reject = void 0, e$1._closedPromiseState = "resolved");
+}
+function Rt(e$1) {
+	e$1._readyPromise = u((t$1, r$1) => {
+		e$1._readyPromise_resolve = t$1, e$1._readyPromise_reject = r$1;
+	}), e$1._readyPromiseState = "pending";
+}
+function Tt(e$1, t$1) {
+	Rt(e$1), Ct(e$1, t$1);
+}
+function qt(e$1) {
+	Rt(e$1), Et(e$1);
+}
+function Ct(e$1, t$1) {
+	void 0 !== e$1._readyPromise_reject && (m(e$1._readyPromise), e$1._readyPromise_reject(t$1), e$1._readyPromise_resolve = void 0, e$1._readyPromise_reject = void 0, e$1._readyPromiseState = "rejected");
+}
+function Et(e$1) {
+	void 0 !== e$1._readyPromise_resolve && (e$1._readyPromise_resolve(void 0), e$1._readyPromise_resolve = void 0, e$1._readyPromise_reject = void 0, e$1._readyPromiseState = "fulfilled");
+}
+Object.defineProperties(WritableStreamDefaultController.prototype, {
+	abortReason: { enumerable: !0 },
+	signal: { enumerable: !0 },
+	error: { enumerable: !0 }
+}), "symbol" == typeof e.toStringTag && Object.defineProperty(WritableStreamDefaultController.prototype, e.toStringTag, {
+	value: "WritableStreamDefaultController",
+	configurable: !0
+});
+const Pt = "undefined" != typeof DOMException ? DOMException : void 0;
+const Wt = function(e$1) {
+	if ("function" != typeof e$1 && "object" != typeof e$1) return !1;
+	try {
+		return new e$1(), !0;
+	} catch (e$2) {
+		return !1;
+	}
+}(Pt) ? Pt : function() {
+	const e$1 = function(e$2, t$1) {
+		this.message = e$2 || "", this.name = t$1 || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+	};
+	return e$1.prototype = Object.create(Error.prototype), Object.defineProperty(e$1.prototype, "constructor", {
+		value: e$1,
+		writable: !0,
+		configurable: !0
+	}), e$1;
+}();
+function kt(e$1, t$1, r$1, o$1, n$1, a$1) {
+	const i$1 = e$1.getReader(), l$1 = t$1.getWriter();
+	Vt(e$1) && (e$1._disturbed = !0);
+	let s$1, _$1, g$1, w$1 = !1, S$1 = !1, v$1 = "readable", R$1 = "writable", T$1 = !1, q$1 = !1;
+	const C$1 = u((e$2) => {
+		g$1 = e$2;
+	});
+	let E$1 = Promise.resolve(void 0);
+	return u((P$1, W$1) => {
+		let k$1;
+		function O$1() {
+			if (w$1) return;
+			const e$2 = u((e$3, t$2) => {
+				(function r$2(o$2) {
+					o$2 ? e$3() : f(function() {
+						if (w$1) return c(!0);
+						return f(l$1.ready, () => f(i$1.read(), (e$4) => !!e$4.done || (E$1 = l$1.write(e$4.value), m(E$1), !1)));
+					}(), r$2, t$2);
+				})(!1);
+			});
+			m(e$2);
+		}
+		function B$1() {
+			return v$1 = "closed", r$1 ? L$1() : z$1(() => (Ge(t$1) && (T$1 = rt(t$1), R$1 = t$1._state), T$1 || "closed" === R$1 ? c(void 0) : "erroring" === R$1 || "errored" === R$1 ? d(_$1) : (T$1 = !0, l$1.close())), !1, void 0), null;
+		}
+		function A$1(e$2) {
+			return w$1 || (v$1 = "errored", s$1 = e$2, o$1 ? L$1(!0, e$2) : z$1(() => l$1.abort(e$2), !0, e$2)), null;
+		}
+		function j$1(e$2) {
+			return S$1 || (R$1 = "errored", _$1 = e$2, n$1 ? L$1(!0, e$2) : z$1(() => i$1.cancel(e$2), !0, e$2)), null;
+		}
+		if (void 0 !== a$1 && (k$1 = () => {
+			const e$2 = void 0 !== a$1.reason ? a$1.reason : new Wt("Aborted", "AbortError"), t$2 = [];
+			o$1 || t$2.push(() => "writable" === R$1 ? l$1.abort(e$2) : c(void 0)), n$1 || t$2.push(() => "readable" === v$1 ? i$1.cancel(e$2) : c(void 0)), z$1(() => Promise.all(t$2.map((e$3) => e$3())), !0, e$2);
+		}, a$1.aborted ? k$1() : a$1.addEventListener("abort", k$1)), Vt(e$1) && (v$1 = e$1._state, s$1 = e$1._storedError), Ge(t$1) && (R$1 = t$1._state, _$1 = t$1._storedError, T$1 = rt(t$1)), Vt(e$1) && Ge(t$1) && (q$1 = !0, g$1()), "errored" === v$1) A$1(s$1);
+		else if ("erroring" === R$1 || "errored" === R$1) j$1(_$1);
+		else if ("closed" === v$1) B$1();
+		else if (T$1 || "closed" === R$1) {
+			const e$2 = new TypeError("the destination writable stream closed before all data could be piped to it");
+			n$1 ? L$1(!0, e$2) : z$1(() => i$1.cancel(e$2), !0, e$2);
+		}
+		function z$1(e$2, t$2, r$2) {
+			function o$2() {
+				return "writable" !== R$1 || T$1 ? n$2() : h(function() {
+					let e$3;
+					return c(function t$3() {
+						if (e$3 !== E$1) return e$3 = E$1, p(E$1, t$3, t$3);
+					}());
+				}(), n$2), null;
+			}
+			function n$2() {
+				return e$2 ? b(e$2(), () => F$1(t$2, r$2), (e$3) => F$1(!0, e$3)) : F$1(t$2, r$2), null;
+			}
+			w$1 || (w$1 = !0, q$1 ? o$2() : h(C$1, o$2));
+		}
+		function L$1(e$2, t$2) {
+			z$1(void 0, e$2, t$2);
+		}
+		function F$1(e$2, t$2) {
+			return S$1 = !0, l$1.releaseLock(), i$1.releaseLock(), void 0 !== a$1 && a$1.removeEventListener("abort", k$1), e$2 ? W$1(t$2) : P$1(void 0), null;
+		}
+		w$1 || (b(i$1.closed, B$1, A$1), b(l$1.closed, function() {
+			return S$1 || (R$1 = "closed"), null;
+		}, j$1)), q$1 ? O$1() : y(() => {
+			q$1 = !0, g$1(), O$1();
+		});
+	});
+}
+function Ot(e$1, t$1) {
+	return function(e$2) {
+		try {
+			return e$2.getReader({ mode: "byob" }).releaseLock(), !0;
+		} catch (e$3) {
+			return !1;
+		}
+	}(e$1) ? function(e$2) {
+		let t$2, r$1, o$1, n$1, a$1, i$1 = e$2.getReader(), l$1 = !1, s$1 = !1, d$1 = !1, f$1 = !1, h$1 = !1, p$1 = !1;
+		const m$1 = u((e$3) => {
+			a$1 = e$3;
+		});
+		function y$1(e$3) {
+			_(e$3.closed, (t$3) => (e$3 !== i$1 || (o$1.error(t$3), n$1.error(t$3), h$1 && p$1 || a$1(void 0)), null));
+		}
+		function g$1() {
+			l$1 && (i$1.releaseLock(), i$1 = e$2.getReader(), y$1(i$1), l$1 = !1), b(i$1.read(), (e$3) => {
+				var t$3, r$2;
+				if (d$1 = !1, f$1 = !1, e$3.done) return h$1 || o$1.close(), p$1 || n$1.close(), null === (t$3 = o$1.byobRequest) || void 0 === t$3 || t$3.respond(0), null === (r$2 = n$1.byobRequest) || void 0 === r$2 || r$2.respond(0), h$1 && p$1 || a$1(void 0), null;
+				const l$2 = e$3.value, u$1 = l$2;
+				let c$1 = l$2;
+				if (!h$1 && !p$1) try {
+					c$1 = le(l$2);
+				} catch (e$4) {
+					return o$1.error(e$4), n$1.error(e$4), a$1(i$1.cancel(e$4)), null;
+				}
+				return h$1 || o$1.enqueue(u$1), p$1 || n$1.enqueue(c$1), s$1 = !1, d$1 ? S$1() : f$1 && v$1(), null;
+			}, () => (s$1 = !1, null));
+		}
+		function w$1(t$3, r$2) {
+			l$1 || (i$1.releaseLock(), i$1 = e$2.getReader({ mode: "byob" }), y$1(i$1), l$1 = !0);
+			const u$1 = r$2 ? n$1 : o$1, c$1 = r$2 ? o$1 : n$1;
+			b(i$1.read(t$3), (e$3) => {
+				var t$4;
+				d$1 = !1, f$1 = !1;
+				const o$2 = r$2 ? p$1 : h$1, n$2 = r$2 ? h$1 : p$1;
+				if (e$3.done) {
+					o$2 || u$1.close(), n$2 || c$1.close();
+					const r$3 = e$3.value;
+					return void 0 !== r$3 && (o$2 || u$1.byobRequest.respondWithNewView(r$3), n$2 || null === (t$4 = c$1.byobRequest) || void 0 === t$4 || t$4.respond(0)), o$2 && n$2 || a$1(void 0), null;
+				}
+				const l$2 = e$3.value;
+				if (n$2) o$2 || u$1.byobRequest.respondWithNewView(l$2);
+				else {
+					let e$4;
+					try {
+						e$4 = le(l$2);
+					} catch (e$5) {
+						return u$1.error(e$5), c$1.error(e$5), a$1(i$1.cancel(e$5)), null;
+					}
+					o$2 || u$1.byobRequest.respondWithNewView(l$2), c$1.enqueue(e$4);
+				}
+				return s$1 = !1, d$1 ? S$1() : f$1 && v$1(), null;
+			}, () => (s$1 = !1, null));
+		}
+		function S$1() {
+			if (s$1) return d$1 = !0, c(void 0);
+			s$1 = !0;
+			const e$3 = o$1.byobRequest;
+			return null === e$3 ? g$1() : w$1(e$3.view, !1), c(void 0);
+		}
+		function v$1() {
+			if (s$1) return f$1 = !0, c(void 0);
+			s$1 = !0;
+			const e$3 = n$1.byobRequest;
+			return null === e$3 ? g$1() : w$1(e$3.view, !0), c(void 0);
+		}
+		function R$1(e$3) {
+			if (h$1 = !0, t$2 = e$3, p$1) {
+				const e$4 = [t$2, r$1], o$2 = i$1.cancel(e$4);
+				a$1(o$2);
+			}
+			return m$1;
+		}
+		function T$1(e$3) {
+			if (p$1 = !0, r$1 = e$3, h$1) {
+				const e$4 = [t$2, r$1], o$2 = i$1.cancel(e$4);
+				a$1(o$2);
+			}
+			return m$1;
+		}
+		const q$1 = new ReadableStream({
+			type: "bytes",
+			start(e$3) {
+				o$1 = e$3;
+			},
+			pull: S$1,
+			cancel: R$1
+		}), C$1 = new ReadableStream({
+			type: "bytes",
+			start(e$3) {
+				n$1 = e$3;
+			},
+			pull: v$1,
+			cancel: T$1
+		});
+		return y$1(i$1), [q$1, C$1];
+	}(e$1) : function(e$2, t$2) {
+		const r$1 = e$2.getReader();
+		let o$1, n$1, a$1, i$1, l$1, s$1 = !1, d$1 = !1, f$1 = !1, h$1 = !1;
+		const p$1 = u((e$3) => {
+			l$1 = e$3;
+		});
+		function m$1() {
+			return s$1 ? (d$1 = !0, c(void 0)) : (s$1 = !0, b(r$1.read(), (e$3) => {
+				if (d$1 = !1, e$3.done) return f$1 || a$1.close(), h$1 || i$1.close(), f$1 && h$1 || l$1(void 0), null;
+				const t$3 = e$3.value, r$2 = t$3, o$2 = t$3;
+				return f$1 || a$1.enqueue(r$2), h$1 || i$1.enqueue(o$2), s$1 = !1, d$1 && m$1(), null;
+			}, () => (s$1 = !1, null)), c(void 0));
+		}
+		function y$1(e$3) {
+			if (f$1 = !0, o$1 = e$3, h$1) {
+				const e$4 = [o$1, n$1], t$3 = r$1.cancel(e$4);
+				l$1(t$3);
+			}
+			return p$1;
+		}
+		function g$1(e$3) {
+			if (h$1 = !0, n$1 = e$3, f$1) {
+				const e$4 = [o$1, n$1], t$3 = r$1.cancel(e$4);
+				l$1(t$3);
+			}
+			return p$1;
+		}
+		const w$1 = new ReadableStream({
+			start(e$3) {
+				a$1 = e$3;
+			},
+			pull: m$1,
+			cancel: y$1
+		}), S$1 = new ReadableStream({
+			start(e$3) {
+				i$1 = e$3;
+			},
+			pull: m$1,
+			cancel: g$1
+		});
+		return _(r$1.closed, (e$3) => (a$1.error(e$3), i$1.error(e$3), f$1 && h$1 || l$1(void 0), null)), [w$1, S$1];
+	}(e$1);
+}
+var ReadableStreamDefaultController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get desiredSize() {
+		if (!Bt(this)) throw Dt("desiredSize");
+		return Lt(this);
+	}
+	close() {
+		if (!Bt(this)) throw Dt("close");
+		if (!Ft(this)) throw new TypeError("The stream is not in a state that permits close");
+		(function(e$1) {
+			if (!Ft(e$1)) return;
+			const t$1 = e$1._controlledReadableStream;
+			e$1._closeRequested = !0, 0 === e$1._queue.length && (jt(e$1), Xt(t$1));
+		})(this);
+	}
+	enqueue(e$1) {
+		if (!Bt(this)) throw Dt("enqueue");
+		if (!Ft(this)) throw new TypeError("The stream is not in a state that permits enqueue");
+		return function(e$2, t$1) {
+			if (!Ft(e$2)) return;
+			const r$1 = e$2._controlledReadableStream;
+			if (Ut(r$1) && X(r$1) > 0) G(r$1, t$1, !1);
+			else {
+				let r$2;
+				try {
+					r$2 = e$2._strategySizeAlgorithm(t$1);
+				} catch (t$2) {
+					throw zt(e$2, t$2), t$2;
+				}
+				try {
+					ue(e$2, t$1, r$2);
+				} catch (t$2) {
+					throw zt(e$2, t$2), t$2;
+				}
+			}
+			At(e$2);
+		}(this, e$1);
+	}
+	error(e$1) {
+		if (!Bt(this)) throw Dt("error");
+		zt(this, e$1);
+	}
+	[T](e$1) {
+		ce(this);
+		const t$1 = this._cancelAlgorithm(e$1);
+		return jt(this), t$1;
+	}
+	[q](e$1) {
+		const t$1 = this._controlledReadableStream;
+		if (this._queue.length > 0) {
+			const r$1 = se(this);
+			this._closeRequested && 0 === this._queue.length ? (jt(this), Xt(t$1)) : At(this), e$1._chunkSteps(r$1);
+		} else U(t$1, e$1), At(this);
+	}
+	[C]() {}
+};
+function Bt(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_controlledReadableStream") && e$1 instanceof ReadableStreamDefaultController;
+}
+function At(e$1) {
+	const t$1 = function(e$2) {
+		const t$2 = e$2._controlledReadableStream;
+		if (!Ft(e$2)) return !1;
+		if (!e$2._started) return !1;
+		if (Ut(t$2) && X(t$2) > 0) return !0;
+		if (Lt(e$2) > 0) return !0;
+		return !1;
+	}(e$1);
+	if (!t$1) return;
+	if (e$1._pulling) return void (e$1._pullAgain = !0);
+	e$1._pulling = !0;
+	b(e$1._pullAlgorithm(), () => (e$1._pulling = !1, e$1._pullAgain && (e$1._pullAgain = !1, At(e$1)), null), (t$2) => (zt(e$1, t$2), null));
+}
+function jt(e$1) {
+	e$1._pullAlgorithm = void 0, e$1._cancelAlgorithm = void 0, e$1._strategySizeAlgorithm = void 0;
+}
+function zt(e$1, t$1) {
+	const r$1 = e$1._controlledReadableStream;
+	"readable" === r$1._state && (ce(e$1), jt(e$1), Jt(r$1, t$1));
+}
+function Lt(e$1) {
+	const t$1 = e$1._controlledReadableStream._state;
+	return "errored" === t$1 ? null : "closed" === t$1 ? 0 : e$1._strategyHWM - e$1._queueTotalSize;
+}
+function Ft(e$1) {
+	return !e$1._closeRequested && "readable" === e$1._controlledReadableStream._state;
+}
+function It(e$1, t$1, r$1, o$1) {
+	const n$1 = Object.create(ReadableStreamDefaultController.prototype);
+	let a$1, i$1, l$1;
+	a$1 = void 0 !== t$1.start ? () => t$1.start(n$1) : () => {}, i$1 = void 0 !== t$1.pull ? () => t$1.pull(n$1) : () => c(void 0), l$1 = void 0 !== t$1.cancel ? (e$2) => t$1.cancel(e$2) : () => c(void 0), function(e$2, t$2, r$2, o$2, n$2, a$2, i$2) {
+		t$2._controlledReadableStream = e$2, t$2._queue = void 0, t$2._queueTotalSize = void 0, ce(t$2), t$2._started = !1, t$2._closeRequested = !1, t$2._pullAgain = !1, t$2._pulling = !1, t$2._strategySizeAlgorithm = i$2, t$2._strategyHWM = a$2, t$2._pullAlgorithm = o$2, t$2._cancelAlgorithm = n$2, e$2._readableStreamController = t$2, b(c(r$2()), () => (t$2._started = !0, At(t$2), null), (e$3) => (zt(t$2, e$3), null));
+	}(e$1, n$1, a$1, i$1, l$1, r$1, o$1);
+}
+function Dt(e$1) {
+	return new TypeError(`ReadableStreamDefaultController.prototype.${e$1} can only be used on a ReadableStreamDefaultController`);
+}
+function $t(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2) => w(e$1, t$1, [r$2]);
+}
+function Mt(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2) => w(e$1, t$1, [r$2]);
+}
+function Yt(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2) => g(e$1, t$1, [r$2]);
+}
+function Qt(e$1, t$1) {
+	if ("bytes" !== (e$1 = `${e$1}`)) throw new TypeError(`${t$1} '${e$1}' is not a valid enumeration value for ReadableStreamType`);
+	return e$1;
+}
+function Nt(e$1, t$1) {
+	if ("byob" !== (e$1 = `${e$1}`)) throw new TypeError(`${t$1} '${e$1}' is not a valid enumeration value for ReadableStreamReaderMode`);
+	return e$1;
+}
+function Ht(e$1, t$1) {
+	F(e$1, t$1);
+	const r$1 = null == e$1 ? void 0 : e$1.preventAbort, o$1 = null == e$1 ? void 0 : e$1.preventCancel, n$1 = null == e$1 ? void 0 : e$1.preventClose, a$1 = null == e$1 ? void 0 : e$1.signal;
+	return void 0 !== a$1 && function(e$2, t$2) {
+		if (!function(e$3) {
+			if ("object" != typeof e$3 || null === e$3) return !1;
+			try {
+				return "boolean" == typeof e$3.aborted;
+			} catch (e$4) {
+				return !1;
+			}
+		}(e$2)) throw new TypeError(`${t$2} is not an AbortSignal.`);
+	}(a$1, `${t$1} has member 'signal' that`), {
+		preventAbort: Boolean(r$1),
+		preventCancel: Boolean(o$1),
+		preventClose: Boolean(n$1),
+		signal: a$1
+	};
+}
+function xt(e$1, t$1) {
+	F(e$1, t$1);
+	const r$1 = null == e$1 ? void 0 : e$1.readable;
+	M(r$1, "readable", "ReadableWritablePair"), function(e$2, t$2) {
+		if (!H(e$2)) throw new TypeError(`${t$2} is not a ReadableStream.`);
+	}(r$1, `${t$1} has member 'readable' that`);
+	const o$1 = null == e$1 ? void 0 : e$1.writable;
+	return M(o$1, "writable", "ReadableWritablePair"), function(e$2, t$2) {
+		if (!x(e$2)) throw new TypeError(`${t$2} is not a WritableStream.`);
+	}(o$1, `${t$1} has member 'writable' that`), {
+		readable: r$1,
+		writable: o$1
+	};
+}
+Object.defineProperties(ReadableStreamDefaultController.prototype, {
+	close: { enumerable: !0 },
+	enqueue: { enumerable: !0 },
+	error: { enumerable: !0 },
+	desiredSize: { enumerable: !0 }
+}), n(ReadableStreamDefaultController.prototype.close, "close"), n(ReadableStreamDefaultController.prototype.enqueue, "enqueue"), n(ReadableStreamDefaultController.prototype.error, "error"), "symbol" == typeof e.toStringTag && Object.defineProperty(ReadableStreamDefaultController.prototype, e.toStringTag, {
+	value: "ReadableStreamDefaultController",
+	configurable: !0
+});
+var ReadableStream = class {
+	constructor(e$1 = {}, t$1 = {}) {
+		void 0 === e$1 ? e$1 = null : D(e$1, "First parameter");
+		const r$1 = Ye(t$1, "Second parameter"), o$1 = function(e$2, t$2) {
+			F(e$2, t$2);
+			const r$2 = e$2, o$2 = null == r$2 ? void 0 : r$2.autoAllocateChunkSize, n$2 = null == r$2 ? void 0 : r$2.cancel, a$1 = null == r$2 ? void 0 : r$2.pull, i$1 = null == r$2 ? void 0 : r$2.start, l$1 = null == r$2 ? void 0 : r$2.type;
+			return {
+				autoAllocateChunkSize: void 0 === o$2 ? void 0 : N(o$2, `${t$2} has member 'autoAllocateChunkSize' that`),
+				cancel: void 0 === n$2 ? void 0 : $t(n$2, r$2, `${t$2} has member 'cancel' that`),
+				pull: void 0 === a$1 ? void 0 : Mt(a$1, r$2, `${t$2} has member 'pull' that`),
+				start: void 0 === i$1 ? void 0 : Yt(i$1, r$2, `${t$2} has member 'start' that`),
+				type: void 0 === l$1 ? void 0 : Qt(l$1, `${t$2} has member 'type' that`)
+			};
+		}(e$1, "First parameter");
+		var n$1;
+		if ((n$1 = this)._state = "readable", n$1._reader = void 0, n$1._storedError = void 0, n$1._disturbed = !1, "bytes" === o$1.type) {
+			if (void 0 !== r$1.size) throw new RangeError("The strategy for a byte stream cannot have a size function");
+			Oe(this, o$1, $e(r$1, 0));
+		} else {
+			const e$2 = Me(r$1);
+			It(this, o$1, $e(r$1, 1), e$2);
+		}
+	}
+	get locked() {
+		if (!Vt(this)) throw Kt("locked");
+		return Ut(this);
+	}
+	cancel(e$1) {
+		return Vt(this) ? Ut(this) ? d(new TypeError("Cannot cancel a stream that already has a reader")) : Gt(this, e$1) : d(Kt("cancel"));
+	}
+	getReader(e$1) {
+		if (!Vt(this)) throw Kt("getReader");
+		return void 0 === function(e$2, t$1) {
+			F(e$2, t$1);
+			const r$1 = null == e$2 ? void 0 : e$2.mode;
+			return { mode: void 0 === r$1 ? void 0 : Nt(r$1, `${t$1} has member 'mode' that`) };
+		}(e$1, "First parameter").mode ? new ReadableStreamDefaultReader(this) : function(e$2) {
+			return new ReadableStreamBYOBReader(e$2);
+		}(this);
+	}
+	pipeThrough(e$1, t$1 = {}) {
+		if (!H(this)) throw Kt("pipeThrough");
+		$(e$1, 1, "pipeThrough");
+		const r$1 = xt(e$1, "First parameter"), o$1 = Ht(t$1, "Second parameter");
+		if (this.locked) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
+		if (r$1.writable.locked) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
+		return m(kt(this, r$1.writable, o$1.preventClose, o$1.preventAbort, o$1.preventCancel, o$1.signal)), r$1.readable;
+	}
+	pipeTo(e$1, t$1 = {}) {
+		if (!H(this)) return d(Kt("pipeTo"));
+		if (void 0 === e$1) return d("Parameter 1 is required in 'pipeTo'.");
+		if (!x(e$1)) return d(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
+		let r$1;
+		try {
+			r$1 = Ht(t$1, "Second parameter");
+		} catch (e$2) {
+			return d(e$2);
+		}
+		return this.locked ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : e$1.locked ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : kt(this, e$1, r$1.preventClose, r$1.preventAbort, r$1.preventCancel, r$1.signal);
+	}
+	tee() {
+		if (!H(this)) throw Kt("tee");
+		if (this.locked) throw new TypeError("Cannot tee a stream that already has a reader");
+		return Ot(this);
+	}
+	values(e$1) {
+		if (!H(this)) throw Kt("values");
+		return function(e$2, t$1) {
+			const r$1 = e$2.getReader(), o$1 = new te(r$1, t$1), n$1 = Object.create(re);
+			return n$1._asyncIteratorImpl = o$1, n$1;
+		}(this, function(e$2, t$1) {
+			F(e$2, t$1);
+			const r$1 = null == e$2 ? void 0 : e$2.preventCancel;
+			return { preventCancel: Boolean(r$1) };
+		}(e$1, "First parameter").preventCancel);
+	}
+};
+function Vt(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_readableStreamController") && e$1 instanceof ReadableStream;
+}
+function Ut(e$1) {
+	return void 0 !== e$1._reader;
+}
+function Gt(e$1, r$1) {
+	if (e$1._disturbed = !0, "closed" === e$1._state) return c(void 0);
+	if ("errored" === e$1._state) return d(e$1._storedError);
+	Xt(e$1);
+	const o$1 = e$1._reader;
+	if (void 0 !== o$1 && Fe(o$1)) {
+		const e$2 = o$1._readIntoRequests;
+		o$1._readIntoRequests = new S(), e$2.forEach((e$3) => {
+			e$3._closeSteps(void 0);
+		});
+	}
+	return p(e$1._readableStreamController[T](r$1), t);
+}
+function Xt(e$1) {
+	e$1._state = "closed";
+	const t$1 = e$1._reader;
+	if (void 0 !== t$1 && (j(t$1), K(t$1))) {
+		const e$2 = t$1._readRequests;
+		t$1._readRequests = new S(), e$2.forEach((e$3) => {
+			e$3._closeSteps();
+		});
+	}
+}
+function Jt(e$1, t$1) {
+	e$1._state = "errored", e$1._storedError = t$1;
+	const r$1 = e$1._reader;
+	void 0 !== r$1 && (A(r$1, t$1), K(r$1) ? Z(r$1, t$1) : Ie(r$1, t$1));
+}
+function Kt(e$1) {
+	return new TypeError(`ReadableStream.prototype.${e$1} can only be used on a ReadableStream`);
+}
+function Zt(e$1, t$1) {
+	F(e$1, t$1);
+	const r$1 = null == e$1 ? void 0 : e$1.highWaterMark;
+	return M(r$1, "highWaterMark", "QueuingStrategyInit"), { highWaterMark: Y(r$1) };
+}
+Object.defineProperties(ReadableStream.prototype, {
+	cancel: { enumerable: !0 },
+	getReader: { enumerable: !0 },
+	pipeThrough: { enumerable: !0 },
+	pipeTo: { enumerable: !0 },
+	tee: { enumerable: !0 },
+	values: { enumerable: !0 },
+	locked: { enumerable: !0 }
+}), n(ReadableStream.prototype.cancel, "cancel"), n(ReadableStream.prototype.getReader, "getReader"), n(ReadableStream.prototype.pipeThrough, "pipeThrough"), n(ReadableStream.prototype.pipeTo, "pipeTo"), n(ReadableStream.prototype.tee, "tee"), n(ReadableStream.prototype.values, "values"), "symbol" == typeof e.toStringTag && Object.defineProperty(ReadableStream.prototype, e.toStringTag, {
+	value: "ReadableStream",
+	configurable: !0
+}), "symbol" == typeof e.asyncIterator && Object.defineProperty(ReadableStream.prototype, e.asyncIterator, {
+	value: ReadableStream.prototype.values,
+	writable: !0,
+	configurable: !0
+});
+const er = (e$1) => e$1.byteLength;
+n(er, "size");
+var ByteLengthQueuingStrategy = class {
+	constructor(e$1) {
+		$(e$1, 1, "ByteLengthQueuingStrategy"), e$1 = Zt(e$1, "First parameter"), this._byteLengthQueuingStrategyHighWaterMark = e$1.highWaterMark;
+	}
+	get highWaterMark() {
+		if (!rr(this)) throw tr("highWaterMark");
+		return this._byteLengthQueuingStrategyHighWaterMark;
+	}
+	get size() {
+		if (!rr(this)) throw tr("size");
+		return er;
+	}
+};
+function tr(e$1) {
+	return new TypeError(`ByteLengthQueuingStrategy.prototype.${e$1} can only be used on a ByteLengthQueuingStrategy`);
+}
+function rr(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_byteLengthQueuingStrategyHighWaterMark") && e$1 instanceof ByteLengthQueuingStrategy;
+}
+Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
+	highWaterMark: { enumerable: !0 },
+	size: { enumerable: !0 }
+}), "symbol" == typeof e.toStringTag && Object.defineProperty(ByteLengthQueuingStrategy.prototype, e.toStringTag, {
+	value: "ByteLengthQueuingStrategy",
+	configurable: !0
+});
+const or = () => 1;
+n(or, "size");
+var CountQueuingStrategy = class {
+	constructor(e$1) {
+		$(e$1, 1, "CountQueuingStrategy"), e$1 = Zt(e$1, "First parameter"), this._countQueuingStrategyHighWaterMark = e$1.highWaterMark;
+	}
+	get highWaterMark() {
+		if (!ar(this)) throw nr("highWaterMark");
+		return this._countQueuingStrategyHighWaterMark;
+	}
+	get size() {
+		if (!ar(this)) throw nr("size");
+		return or;
+	}
+};
+function nr(e$1) {
+	return new TypeError(`CountQueuingStrategy.prototype.${e$1} can only be used on a CountQueuingStrategy`);
+}
+function ar(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_countQueuingStrategyHighWaterMark") && e$1 instanceof CountQueuingStrategy;
+}
+function ir(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2) => w(e$1, t$1, [r$2]);
+}
+function lr(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2) => g(e$1, t$1, [r$2]);
+}
+function sr(e$1, t$1, r$1) {
+	return I(e$1, r$1), (r$2, o$1) => w(e$1, t$1, [r$2, o$1]);
+}
+Object.defineProperties(CountQueuingStrategy.prototype, {
+	highWaterMark: { enumerable: !0 },
+	size: { enumerable: !0 }
+}), "symbol" == typeof e.toStringTag && Object.defineProperty(CountQueuingStrategy.prototype, e.toStringTag, {
+	value: "CountQueuingStrategy",
+	configurable: !0
+});
+var TransformStream = class {
+	constructor(e$1 = {}, t$1 = {}, r$1 = {}) {
+		void 0 === e$1 && (e$1 = null);
+		const o$1 = Ye(t$1, "Second parameter"), n$1 = Ye(r$1, "Third parameter"), a$1 = function(e$2, t$2) {
+			F(e$2, t$2);
+			const r$2 = null == e$2 ? void 0 : e$2.flush, o$2 = null == e$2 ? void 0 : e$2.readableType, n$2 = null == e$2 ? void 0 : e$2.start, a$2 = null == e$2 ? void 0 : e$2.transform, i$2 = null == e$2 ? void 0 : e$2.writableType;
+			return {
+				flush: void 0 === r$2 ? void 0 : ir(r$2, e$2, `${t$2} has member 'flush' that`),
+				readableType: o$2,
+				start: void 0 === n$2 ? void 0 : lr(n$2, e$2, `${t$2} has member 'start' that`),
+				transform: void 0 === a$2 ? void 0 : sr(a$2, e$2, `${t$2} has member 'transform' that`),
+				writableType: i$2
+			};
+		}(e$1, "First parameter");
+		if (void 0 !== a$1.readableType) throw new RangeError("Invalid readableType specified");
+		if (void 0 !== a$1.writableType) throw new RangeError("Invalid writableType specified");
+		const i$1 = $e(n$1, 0), l$1 = Me(n$1), s$1 = $e(o$1, 1), f$1 = Me(o$1);
+		let b$1;
+		(function(e$2, t$2, r$2, o$2, n$2, a$2) {
+			function i$2() {
+				return t$2;
+			}
+			function l$2(t$3) {
+				return function(e$3, t$4) {
+					const r$3 = e$3._transformStreamController;
+					if (e$3._backpressure) return p(e$3._backpressureChangePromise, () => {
+						if ("erroring" === (Ge(e$3._writable) ? e$3._writable._state : e$3._writableState)) throw Ge(e$3._writable) ? e$3._writable._storedError : e$3._writableStoredError;
+						return pr(r$3, t$4);
+					});
+					return pr(r$3, t$4);
+				}(e$2, t$3);
+			}
+			function s$2(t$3) {
+				return function(e$3, t$4) {
+					return cr(e$3, t$4), c(void 0);
+				}(e$2, t$3);
+			}
+			function u$1() {
+				return function(e$3) {
+					const t$3 = e$3._transformStreamController, r$3 = t$3._flushAlgorithm();
+					return hr(t$3), p(r$3, () => {
+						if ("errored" === e$3._readableState) throw e$3._readableStoredError;
+						gr(e$3) && wr(e$3);
+					}, (t$4) => {
+						throw cr(e$3, t$4), e$3._readableStoredError;
+					});
+				}(e$2);
+			}
+			function d$1() {
+				return function(e$3) {
+					return fr(e$3, !1), e$3._backpressureChangePromise;
+				}(e$2);
+			}
+			function f$2(t$3) {
+				return dr(e$2, t$3), c(void 0);
+			}
+			e$2._writableState = "writable", e$2._writableStoredError = void 0, e$2._writableHasInFlightOperation = !1, e$2._writableStarted = !1, e$2._writable = function(e$3, t$3, r$3, o$3, n$3, a$3, i$3) {
+				return new WritableStream({
+					start(r$4) {
+						e$3._writableController = r$4;
+						try {
+							const t$4 = r$4.signal;
+							void 0 !== t$4 && t$4.addEventListener("abort", () => {
+								"writable" === e$3._writableState && (e$3._writableState = "erroring", t$4.reason && (e$3._writableStoredError = t$4.reason));
+							});
+						} catch (e$4) {}
+						return p(t$3(), () => (e$3._writableStarted = !0, Cr(e$3), null), (t$4) => {
+							throw e$3._writableStarted = !0, Rr(e$3, t$4), t$4;
+						});
+					},
+					write: (t$4) => (function(e$4) {
+						e$4._writableHasInFlightOperation = !0;
+					}(e$3), p(r$3(t$4), () => (function(e$4) {
+						e$4._writableHasInFlightOperation = !1;
+					}(e$3), Cr(e$3), null), (t$5) => {
+						throw function(e$4, t$6) {
+							e$4._writableHasInFlightOperation = !1, Rr(e$4, t$6);
+						}(e$3, t$5), t$5;
+					})),
+					close: () => (function(e$4) {
+						e$4._writableHasInFlightOperation = !0;
+					}(e$3), p(o$3(), () => (function(e$4) {
+						e$4._writableHasInFlightOperation = !1;
+						"erroring" === e$4._writableState && (e$4._writableStoredError = void 0);
+						e$4._writableState = "closed";
+					}(e$3), null), (t$4) => {
+						throw function(e$4, t$5) {
+							e$4._writableHasInFlightOperation = !1, e$4._writableState, Rr(e$4, t$5);
+						}(e$3, t$4), t$4;
+					})),
+					abort: (t$4) => (e$3._writableState = "errored", e$3._writableStoredError = t$4, n$3(t$4))
+				}, {
+					highWaterMark: a$3,
+					size: i$3
+				});
+			}(e$2, i$2, l$2, u$1, s$2, r$2, o$2), e$2._readableState = "readable", e$2._readableStoredError = void 0, e$2._readableCloseRequested = !1, e$2._readablePulling = !1, e$2._readable = function(e$3, t$3, r$3, o$3, n$3, a$3) {
+				return new ReadableStream({
+					start: (r$4) => (e$3._readableController = r$4, t$3().catch((t$4) => {
+						Sr(e$3, t$4);
+					})),
+					pull: () => (e$3._readablePulling = !0, r$3().catch((t$4) => {
+						Sr(e$3, t$4);
+					})),
+					cancel: (t$4) => (e$3._readableState = "closed", o$3(t$4))
+				}, {
+					highWaterMark: n$3,
+					size: a$3
+				});
+			}(e$2, i$2, d$1, f$2, n$2, a$2), e$2._backpressure = void 0, e$2._backpressureChangePromise = void 0, e$2._backpressureChangePromise_resolve = void 0, fr(e$2, !0), e$2._transformStreamController = void 0;
+		})(this, u((e$2) => {
+			b$1 = e$2;
+		}), s$1, f$1, i$1, l$1), function(e$2, t$2) {
+			const r$2 = Object.create(TransformStreamDefaultController.prototype);
+			let o$2, n$2;
+			o$2 = void 0 !== t$2.transform ? (e$3) => t$2.transform(e$3, r$2) : (e$3) => {
+				try {
+					return _r(r$2, e$3), c(void 0);
+				} catch (e$4) {
+					return d(e$4);
+				}
+			};
+			n$2 = void 0 !== t$2.flush ? () => t$2.flush(r$2) : () => c(void 0);
+			(function(e$3, t$3, r$3, o$3) {
+				t$3._controlledTransformStream = e$3, e$3._transformStreamController = t$3, t$3._transformAlgorithm = r$3, t$3._flushAlgorithm = o$3;
+			})(e$2, r$2, o$2, n$2);
+		}(this, a$1), void 0 !== a$1.start ? b$1(a$1.start(this._transformStreamController)) : b$1(void 0);
+	}
+	get readable() {
+		if (!ur(this)) throw yr("readable");
+		return this._readable;
+	}
+	get writable() {
+		if (!ur(this)) throw yr("writable");
+		return this._writable;
+	}
+};
+function ur(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_transformStreamController") && e$1 instanceof TransformStream;
+}
+function cr(e$1, t$1) {
+	Sr(e$1, t$1), dr(e$1, t$1);
+}
+function dr(e$1, t$1) {
+	hr(e$1._transformStreamController), function(e$2, t$2) {
+		e$2._writableController.error(t$2);
+		"writable" === e$2._writableState && Tr(e$2, t$2);
+	}(e$1, t$1), e$1._backpressure && fr(e$1, !1);
+}
+function fr(e$1, t$1) {
+	void 0 !== e$1._backpressureChangePromise && e$1._backpressureChangePromise_resolve(), e$1._backpressureChangePromise = u((t$2) => {
+		e$1._backpressureChangePromise_resolve = t$2;
+	}), e$1._backpressure = t$1;
+}
+Object.defineProperties(TransformStream.prototype, {
+	readable: { enumerable: !0 },
+	writable: { enumerable: !0 }
+}), "symbol" == typeof e.toStringTag && Object.defineProperty(TransformStream.prototype, e.toStringTag, {
+	value: "TransformStream",
+	configurable: !0
+});
+var TransformStreamDefaultController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get desiredSize() {
+		if (!br(this)) throw mr("desiredSize");
+		return vr(this._controlledTransformStream);
+	}
+	enqueue(e$1) {
+		if (!br(this)) throw mr("enqueue");
+		_r(this, e$1);
+	}
+	error(e$1) {
+		if (!br(this)) throw mr("error");
+		var t$1;
+		t$1 = e$1, cr(this._controlledTransformStream, t$1);
+	}
+	terminate() {
+		if (!br(this)) throw mr("terminate");
+		(function(e$1) {
+			const t$1 = e$1._controlledTransformStream;
+			gr(t$1) && wr(t$1);
+			const r$1 = new TypeError("TransformStream terminated");
+			dr(t$1, r$1);
+		})(this);
+	}
+};
+function br(e$1) {
+	return !!r(e$1) && !!Object.prototype.hasOwnProperty.call(e$1, "_controlledTransformStream") && e$1 instanceof TransformStreamDefaultController;
+}
+function hr(e$1) {
+	e$1._transformAlgorithm = void 0, e$1._flushAlgorithm = void 0;
+}
+function _r(e$1, t$1) {
+	const r$1 = e$1._controlledTransformStream;
+	if (!gr(r$1)) throw new TypeError("Readable side is not in a state that permits enqueue");
+	try {
+		(function(e$2, t$2) {
+			e$2._readablePulling = !1;
+			try {
+				e$2._readableController.enqueue(t$2);
+			} catch (t$3) {
+				throw Sr(e$2, t$3), t$3;
+			}
+		})(r$1, t$1);
+	} catch (e$2) {
+		throw dr(r$1, e$2), r$1._readableStoredError;
+	}
+	const o$1 = function(e$2) {
+		return !function(e$3) {
+			if (!gr(e$3)) return !1;
+			if (e$3._readablePulling) return !0;
+			if (vr(e$3) > 0) return !0;
+			return !1;
+		}(e$2);
+	}(r$1);
+	o$1 !== r$1._backpressure && fr(r$1, !0);
+}
+function pr(e$1, t$1) {
+	return p(e$1._transformAlgorithm(t$1), void 0, (t$2) => {
+		throw cr(e$1._controlledTransformStream, t$2), t$2;
+	});
+}
+function mr(e$1) {
+	return new TypeError(`TransformStreamDefaultController.prototype.${e$1} can only be used on a TransformStreamDefaultController`);
+}
+function yr(e$1) {
+	return new TypeError(`TransformStream.prototype.${e$1} can only be used on a TransformStream`);
+}
+function gr(e$1) {
+	return !e$1._readableCloseRequested && "readable" === e$1._readableState;
+}
+function wr(e$1) {
+	e$1._readableState = "closed", e$1._readableCloseRequested = !0, e$1._readableController.close();
+}
+function Sr(e$1, t$1) {
+	"readable" === e$1._readableState && (e$1._readableState = "errored", e$1._readableStoredError = t$1), e$1._readableController.error(t$1);
+}
+function vr(e$1) {
+	return e$1._readableController.desiredSize;
+}
+function Rr(e$1, t$1) {
+	"writable" !== e$1._writableState ? qr(e$1) : Tr(e$1, t$1);
+}
+function Tr(e$1, t$1) {
+	e$1._writableState = "erroring", e$1._writableStoredError = t$1, !function(e$2) {
+		return e$2._writableHasInFlightOperation;
+	}(e$1) && e$1._writableStarted && qr(e$1);
+}
+function qr(e$1) {
+	e$1._writableState = "errored";
+}
+function Cr(e$1) {
+	"erroring" === e$1._writableState && qr(e$1);
+}
+Object.defineProperties(TransformStreamDefaultController.prototype, {
+	enqueue: { enumerable: !0 },
+	error: { enumerable: !0 },
+	terminate: { enumerable: !0 },
+	desiredSize: { enumerable: !0 }
+}), n(TransformStreamDefaultController.prototype.enqueue, "enqueue"), n(TransformStreamDefaultController.prototype.error, "error"), n(TransformStreamDefaultController.prototype.terminate, "terminate"), "symbol" == typeof e.toStringTag && Object.defineProperty(TransformStreamDefaultController.prototype, e.toStringTag, {
+	value: "TransformStreamDefaultController",
+	configurable: !0
+});
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/isFunction.js
+const isFunction = (value) => typeof value === "function";
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/blobHelpers.js
+const CHUNK_SIZE = 65536;
+async function* clonePart(part) {
+	const end = part.byteOffset + part.byteLength;
+	let position = part.byteOffset;
+	while (position !== end) {
+		const size = Math.min(end - position, CHUNK_SIZE);
+		const chunk = part.buffer.slice(position, position + size);
+		position += chunk.byteLength;
+		yield new Uint8Array(chunk);
+	}
+}
+async function* consumeNodeBlob(blob) {
+	let position = 0;
+	while (position !== blob.size) {
+		const chunk = blob.slice(position, Math.min(blob.size, position + CHUNK_SIZE));
+		const buffer = await chunk.arrayBuffer();
+		position += buffer.byteLength;
+		yield new Uint8Array(buffer);
+	}
+}
+async function* consumeBlobParts(parts, clone = false) {
+	for (const part of parts) if (ArrayBuffer.isView(part)) if (clone) yield* clonePart(part);
+	else yield part;
+	else if (isFunction(part.stream)) yield* part.stream();
+	else yield* consumeNodeBlob(part);
+}
+function* sliceBlob(blobParts, blobSize, start = 0, end) {
+	end !== null && end !== void 0 || (end = blobSize);
+	let relativeStart = start < 0 ? Math.max(blobSize + start, 0) : Math.min(start, blobSize);
+	let relativeEnd = end < 0 ? Math.max(blobSize + end, 0) : Math.min(end, blobSize);
+	const span = Math.max(relativeEnd - relativeStart, 0);
+	let added = 0;
+	for (const part of blobParts) {
+		if (added >= span) break;
+		const partSize = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+		if (relativeStart && partSize <= relativeStart) {
+			relativeStart -= partSize;
+			relativeEnd -= partSize;
+		} else {
+			let chunk;
+			if (ArrayBuffer.isView(part)) {
+				chunk = part.subarray(relativeStart, Math.min(partSize, relativeEnd));
+				added += chunk.byteLength;
+			} else {
+				chunk = part.slice(relativeStart, Math.min(partSize, relativeEnd));
+				added += chunk.size;
+			}
+			relativeEnd -= partSize;
+			relativeStart = 0;
+			yield chunk;
+		}
+	}
+}
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/Blob.js
+/*! Based on fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> & David Frank */
+var __classPrivateFieldGet$1 = void 0 && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f$1) {
+	if (kind === "a" && !f$1) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f$1 : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f$1 : kind === "a" ? f$1.call(receiver) : f$1 ? f$1.value : state.get(receiver);
+};
+var __classPrivateFieldSet$1 = void 0 && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f$1) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f$1) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f$1 : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f$1.call(receiver, value) : f$1 ? f$1.value = value : state.set(receiver, value), value;
+};
+var _Blob_parts, _Blob_type, _Blob_size;
+var Blob = class Blob {
+	constructor(blobParts = [], options = {}) {
+		_Blob_parts.set(this, []);
+		_Blob_type.set(this, "");
+		_Blob_size.set(this, 0);
+		options !== null && options !== void 0 || (options = {});
+		if (typeof blobParts !== "object" || blobParts === null) throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
+		if (!isFunction(blobParts[Symbol.iterator])) throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property.");
+		if (typeof options !== "object" && !isFunction(options)) throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary.");
+		const encoder = new TextEncoder();
+		for (const raw of blobParts) {
+			let part;
+			if (ArrayBuffer.isView(raw)) part = new Uint8Array(raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength));
+			else if (raw instanceof ArrayBuffer) part = new Uint8Array(raw.slice(0));
+			else if (raw instanceof Blob) part = raw;
+			else part = encoder.encode(String(raw));
+			__classPrivateFieldSet$1(this, _Blob_size, __classPrivateFieldGet$1(this, _Blob_size, "f") + (ArrayBuffer.isView(part) ? part.byteLength : part.size), "f");
+			__classPrivateFieldGet$1(this, _Blob_parts, "f").push(part);
+		}
+		const type = options.type === void 0 ? "" : String(options.type);
+		__classPrivateFieldSet$1(this, _Blob_type, /^[\x20-\x7E]*$/.test(type) ? type : "", "f");
+	}
+	static [(_Blob_parts = /* @__PURE__ */ new WeakMap(), _Blob_type = /* @__PURE__ */ new WeakMap(), _Blob_size = /* @__PURE__ */ new WeakMap(), Symbol.hasInstance)](value) {
+		return Boolean(value && typeof value === "object" && isFunction(value.constructor) && (isFunction(value.stream) || isFunction(value.arrayBuffer)) && /^(Blob|File)$/.test(value[Symbol.toStringTag]));
+	}
+	get type() {
+		return __classPrivateFieldGet$1(this, _Blob_type, "f");
+	}
+	get size() {
+		return __classPrivateFieldGet$1(this, _Blob_size, "f");
+	}
+	slice(start, end, contentType) {
+		return new Blob(sliceBlob(__classPrivateFieldGet$1(this, _Blob_parts, "f"), this.size, start, end), { type: contentType });
+	}
+	async text() {
+		const decoder = new TextDecoder();
+		let result = "";
+		for await (const chunk of consumeBlobParts(__classPrivateFieldGet$1(this, _Blob_parts, "f"))) result += decoder.decode(chunk, { stream: true });
+		result += decoder.decode();
+		return result;
+	}
+	async arrayBuffer() {
+		const view = new Uint8Array(this.size);
+		let offset = 0;
+		for await (const chunk of consumeBlobParts(__classPrivateFieldGet$1(this, _Blob_parts, "f"))) {
+			view.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return view.buffer;
+	}
+	stream() {
+		const iterator = consumeBlobParts(__classPrivateFieldGet$1(this, _Blob_parts, "f"), true);
+		return new ReadableStream({
+			async pull(controller) {
+				const { value, done } = await iterator.next();
+				if (done) return queueMicrotask(() => controller.close());
+				controller.enqueue(value);
+			},
+			async cancel() {
+				await iterator.return();
+			}
+		});
+	}
+	get [Symbol.toStringTag]() {
+		return "Blob";
+	}
+};
+Object.defineProperties(Blob.prototype, {
+	type: { enumerable: true },
+	size: { enumerable: true },
+	slice: { enumerable: true },
+	stream: { enumerable: true },
+	text: { enumerable: true },
+	arrayBuffer: { enumerable: true }
+});
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/File.js
+var __classPrivateFieldSet = void 0 && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f$1) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f$1) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f$1 : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f$1.call(receiver, value) : f$1 ? f$1.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = void 0 && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f$1) {
+	if (kind === "a" && !f$1) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f$1 : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f$1 : kind === "a" ? f$1.call(receiver) : f$1 ? f$1.value : state.get(receiver);
+};
+var _File_name, _File_lastModified;
+var File = class extends Blob {
+	constructor(fileBits, name, options = {}) {
+		super(fileBits, options);
+		_File_name.set(this, void 0);
+		_File_lastModified.set(this, 0);
+		if (arguments.length < 2) throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
+		__classPrivateFieldSet(this, _File_name, String(name), "f");
+		const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified);
+		if (!Number.isNaN(lastModified)) __classPrivateFieldSet(this, _File_lastModified, lastModified, "f");
+	}
+	static [(_File_name = /* @__PURE__ */ new WeakMap(), _File_lastModified = /* @__PURE__ */ new WeakMap(), Symbol.hasInstance)](value) {
+		return value instanceof Blob && value[Symbol.toStringTag] === "File" && typeof value.name === "string";
+	}
+	get name() {
+		return __classPrivateFieldGet(this, _File_name, "f");
+	}
+	get lastModified() {
+		return __classPrivateFieldGet(this, _File_lastModified, "f");
+	}
+	get webkitRelativePath() {
+		return "";
+	}
+	get [Symbol.toStringTag]() {
+		return "File";
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/isFile.js
+const isFile = (value) => value instanceof File;
+
+//#endregion
+export { Blob, File, isFile, isFunction };

dist/prompt-DoC83bWw.mjs

@@ -0,0 +1,3 @@
+import { PromptTemplate } from "./prompt-Cmq1pjHH.mjs";
+
+export { PromptTemplate };

langgraph.json

@@ -0,0 +1,9 @@
+{
+  "node_version": "20",
+  "dockerfile_lines": ["RUN npm i -g corepack@latest"],
+  "dependencies": ["."],
+  "graphs": {
+    "auto-anime-agent": "./dist/agent.mjs:graph"
+  },
+  "env": ".env"
+}

package.json

@@ -0,0 +1,155 @@
+{
+  "name": "@autoanim/web",
+  "private": true,
+  "sideEffects": false,
+  "type": "module",
+  "scripts": {
+    "dev:web": "vite dev",
+    "dev:agent:langgraph": "pnpx @langchain/langgraph-cli dev --port 8123",
+    "dev:agent:mastra": "mastra dev --dir src/agent/mastra",
+    "build:web": "vite build",
+    "build:agent:langgraph": "pnpx @langchain/langgraph-cli build --dir src/agent/langgraph",
+    "start": "vite start",
+    "typecheck": "tsc --noEmit",
+    "shadcn": "pnpm dlx shadcn@latest"
+  },
+  "dependencies": {
+    "@ag-ui/client": "^0.0.28",
+    "@ag-ui/core": "^0.0.28",
+    "@ag-ui/encoder": "^0.0.28",
+    "@ai-sdk/openai": "^1.3.22",
+    "@ai-sdk/react": "^1.2.12",
+    "@aws-sdk/client-s3": "^3.826.0",
+    "@codemirror/lang-python": "^6.2.1",
+    "@codemirror/state": "^6.5.2",
+    "@codemirror/theme-one-dark": "^6.1.2",
+    "@codemirror/view": "^6.37.1",
+    "@copilotkit/react-core": "1.8.14",
+    "@copilotkit/react-ui": "1.8.14",
+    "@copilotkit/runtime": "1.8.14",
+    "@copilotkit/runtime-client-gql": "^1.8.14",
+    "@copilotkit/sdk-js": "^1.8.14",
+    "@copilotkit/shared": "1.8.14",
+    "@diffusionstudio/core": "^3.8.3",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/modifiers": "^9.0.0",
+    "@dotenvx/dotenvx": "^1.44.1",
+    "@faker-js/faker": "^9.8.0",
+    "@fal-ai/client": "^1.5.0",
+    "@hono/standard-validator": "^0.1.2",
+    "@hookform/resolvers": "^5.0.1",
+    "@langchain/core": "^0.3.57",
+    "@langchain/langgraph": "^0.3.1",
+    "@langchain/openai": "^0.5.12",
+    "@legendapp/state": "3.0.0-beta.31",
+    "@mastra/agui": "1.0.2",
+    "@mastra/client-js": "^0.10.2",
+    "@mastra/core": "^0.10.3",
+    "@mastra/libsql": "^0.10.1",
+    "@mastra/loggers": "^0.10.1",
+    "@mastra/mcp": "^0.10.2",
+    "@mastra/memory": "^0.10.2",
+    "@notionhq/client": "^3.1.3",
+    "@openrouter/ai-sdk-provider": "^0.7.1",
+    "@radix-ui/react-accordion": "^1.2.11",
+    "@radix-ui/react-alert-dialog": "^1.1.14",
+    "@radix-ui/react-aspect-ratio": "^1.1.7",
+    "@radix-ui/react-avatar": "^1.1.10",
+    "@radix-ui/react-checkbox": "^1.3.2",
+    "@radix-ui/react-collapsible": "^1.1.11",
+    "@radix-ui/react-context-menu": "^2.2.15",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-dropdown-menu": "^2.1.15",
+    "@radix-ui/react-hover-card": "^1.1.14",
+    "@radix-ui/react-label": "^2.1.7",
+    "@radix-ui/react-menubar": "^1.1.15",
+    "@radix-ui/react-navigation-menu": "^1.2.13",
+    "@radix-ui/react-popover": "^1.1.14",
+    "@radix-ui/react-progress": "^1.1.7",
+    "@radix-ui/react-radio-group": "^1.3.7",
+    "@radix-ui/react-scroll-area": "^1.2.9",
+    "@radix-ui/react-select": "^2.2.5",
+    "@radix-ui/react-separator": "^1.1.7",
+    "@radix-ui/react-slider": "^1.3.5",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-switch": "^1.2.5",
+    "@radix-ui/react-tabs": "^1.1.12",
+    "@radix-ui/react-toggle": "^1.1.9",
+    "@radix-ui/react-toggle-group": "^1.1.10",
+    "@radix-ui/react-tooltip": "^1.2.7",
+    "@stepperize/react": "^5.1.6",
+    "@tanstack/react-query": "^5.80.6",
+    "@tanstack/react-query-devtools": "^5.80.6",
+    "@tanstack/react-router": "1.121.0-alpha.22",
+    "@tanstack/react-router-devtools": "1.121.0-alpha.22",
+    "@tanstack/react-router-with-query": "1.121.0-alpha.22",
+    "@tanstack/react-start": "1.121.0-alpha.26",
+    "@tanstack/react-table": "^8.21.3",
+    "@tavily/core": "^0.5.6",
+    "ai": "^4.3.16",
+    "arktype": "^2.1.20",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "codemirror": "^6.0.1",
+    "confbox": "^0.2.2",
+    "date-fns": "^4.1.0",
+    "decode-formdata": "^0.9.0",
+    "drizzle-orm": "^0.44.2",
+    "embla-carousel": "^8.6.0",
+    "embla-carousel-react": "^8.6.0",
+    "fast-deep-equal": "^3.1.3",
+    "fetch-event-stream": "^0.1.5",
+    "framer-motion": "^12.16.0",
+    "hono": "^4.7.11",
+    "html-to-text": "^9.0.5",
+    "input-otp": "^1.4.2",
+    "lodash-es": "^4.17.21",
+    "lucide-react": "^0.514.0",
+    "mastra": "^0.10.3",
+    "media-chrome": "^4.11.0",
+    "motion": "^12.16.0",
+    "openai": "^5.3.0",
+    "papaparse": "^5.5.3",
+    "postgres": "^3.4.7",
+    "prosemirror-example-setup": "^1.2.3",
+    "prosemirror-inputrules": "^1.5.0",
+    "prosemirror-markdown": "^1.13.2",
+    "prosemirror-model": "^1.25.1",
+    "prosemirror-schema-basic": "^1.2.4",
+    "prosemirror-schema-list": "^1.5.1",
+    "prosemirror-state": "^1.4.3",
+    "prosemirror-view": "^1.40.0",
+    "react": "^19.0.0",
+    "react-data-grid": "7.0.0-beta.56",
+    "react-day-picker": "8.10.1",
+    "react-dom": "^19.0.0",
+    "react-dropzone": "^14.3.8",
+    "react-hook-form": "^7.57.0",
+    "react-markdown": "^10.1.0",
+    "react-medium-image-zoom": "^5.2.14",
+    "react-resizable-panels": "^3.0.2",
+    "recharts": "^2.15.3",
+    "redaxios": "^0.5.1",
+    "redis": "^5.5.6",
+    "remark-gfm": "^4.0.1",
+    "resumable-stream": "^2.2.0",
+    "rxjs": "^7.8.2",
+    "shosho": "^1.4.3",
+    "sonner": "^2.0.5",
+    "tailwind-merge": "^3.3.0",
+    "ulid": "^3.0.1",
+    "usehooks-ts": "^3.1.1",
+    "vaul": "^1.1.2",
+    "zod": "^3.25.57"
+  },
+  "devDependencies": {
+    "@types/html-to-text": "^9.0.4",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.15.30",
+    "@types/papaparse": "^5.3.16",
+    "@types/react": "^19.1.6",
+    "@types/react-dom": "^19.1.6",
+    "tw-animate-css": "^1.3.4"
+  }
+}

release.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+set -e  # Exit on any error
+
+echo "Starting release process..."
+
+# Execute build script
+echo "Running build script..."
+./build.sh
+
+# Check if build was successful
+if [ $? -ne 0 ]; then
+    echo "Error: Build failed, aborting release"
+    exit 1
+fi
+
+echo "Build completed successfully, preparing git operations..."
+
+# Add all new build artifacts
+echo "Adding build artifacts to git..."
+git add .output/
+git add .env 2>/dev/null || echo "No .env file to add"
+git add .env.example 2>/dev/null || echo "No .env.example file to add"
+
+# Check if there are any changes to commit
+if git diff --staged --quiet; then
+    echo "No changes to commit, release process completed"
+    exit 0
+fi
+
+# Get current timestamp for commit message
+TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
+
+# Commit changes
+echo "Committing changes..."
+git commit -m "chore: update build artifacts - $TIMESTAMP"
+
+# Push changes
+echo "Pushing changes to remote..."
+git push
+
+# Get git remote URL and generate HF Space short link
+echo "Generating Hugging Face Space link..."
+GIT_URL=$(git remote get-url origin)
+echo "Git remote URL: $GIT_URL"
+
+# Extract repo path from HF Space URL and generate short link
+if [[ $GIT_URL == *"huggingface.co"* ]]; then
+    # Extract the repo path (remove .git suffix if present)
+    REPO_PATH=$(echo "$GIT_URL" | sed -E 's|.*huggingface\.co/spaces/([^/]+/[^/]+)(\.git)?.*|\1|')
+    HF_SHORT_LINK="https://hf.co/spaces/$REPO_PATH"
+    echo "🚀 Hugging Face Space: $HF_SHORT_LINK"
+else
+    echo "Note: This doesn't appear to be a Hugging Face Space repository"
+fi
+
+echo "Release completed successfully!"
+echo "Build artifacts have been committed and pushed to remote repository"